初识java反射

1、首先一个问题，什么是类，类是不是对象？

我们总是说我们new一个对象出来

那么我们还没有new的时候，建造的那个java类是不是对象呢？

类是对象，类是java.lang.Class类的实例对象

对于反射，我们需要了解Class类（自行百度）

任何一个类都是Class的实例对象，这个实例对象有三种表达方式
第一种表达方式：实际在告诉我们任何一个类都有一个隐含的静态的静态成员变量class
Class c1=foo.class;

第二种表达方式:已经知道该类的对象通过getClass方式
Class c2=foo1.getClass();

第三种表达方式：
Class c3=null;
可以通过类的类类型创建该类的对象实例

c3=Class.forName("类的地址");
//必须有无参的构造方法
Foo foo=(Foo)c1.newInstance();

c1,c2,c3表示了Foo类的类类型(class type)
需要知道的是类的类类型是一样的，都指的是一个，所以c1,c2,c3都是一样的。都是相等的。

package reflect;

public class Reflect
{
    public static void main(String[] args) 
    {
        Foo foo=new Foo();
        //第一种表示方式--->实际在告诉我们任何一个类都有一个隐含的静态成员变量class
        Class c1=Foo.class;
        //第二中表达方式  已经知道该类的对象通过getClass方法
        Class c2=foo.getClass();
        //第三种
        Class c3=null;
        try 
        {
            c3=Class.forName("reflect.Foo");
        } 
        catch (ClassNotFoundException e)
        {   
            e.printStackTrace();
        }
            
        try 
        {
            
            System.out.println(c2==c3);
            System.out.println(c1==c2);
            System.out.println(c1==c3);
            //需要有无参数的构造方法
            foo=(Foo) c1.newInstance();
            foo.pint();
            foo.print("hello world");
        } 
        catch (Exception e)
        {
            
            e.printStackTrace();
        } 
    }

}
class Foo
{
    public void pint()
    {
        System.out.println("反射");
    }
    public void print(String a)
    {
        System.out.println(a);
    }
}

方法反射的操作

要获取反射对象的方法，首先获取类的信息，获取类的类类型
获取方法 名称和参数列表来决定
getMethod获取为public的方法
getDelcaredMethod获取自己声明的方法

package reflect;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

public class MethodDemo01 
{

    
    public static void main(String[] args) throws SecurityException, NoSuchMethodException, IllegalArgumentException, IllegalAccessException, InvocationTargetException 
    {
        //要获取print(int n,int m)的方法，首先获取类的信息，获取类的类类型
        A a=new A();
        Class c=a.getClass();

            /**
             * 获取方法 名称和参数列表来决定 
             * getMethod获取为public的方法
             * getDelcaredMethod获取自己声明的方法
             */
            Method m=c.getMethod("print", int.class,int.class);
            Method m1=c.getMethod("print", String.class,String.class);
            Method m2=c.getMethod("print", new Class[]{});
            Method m3=c.getMethod("print",int.class);
            
                //invoke方法的反射操作，如果有值就返回，如果没有值就是null类型
                Object o=m.invoke(a, 10,20);
                o=m1.invoke(a, "hello","world");
                o=m2.invoke(a);
                Object w=(Integer) m3.invoke(a, 50);
                System.out.println(w);
    }

}
class A
{
    public void print()
    {
        System.out.println("反射机制");
    }
    
    public void print(int n,int m)
    {
        System.out.println(n+m);
    }
    public void print(String a,String b)
    {
        System.out.println(a+" "+b);
    }
    public Object print(int a)
    {
        return a;
    }
}