Java反射

注：内如来自慕课网：
http://www.imooc.com/learn/199

一、反射的概念

1.在面向对象的世界里，万事万物皆对象。
java中：静态的成员、普通数据类型是不是对象呢？
其实：前者是属于某个类的、而后者有包装类来封装成对象；
那么我们自己写的类呢？
其实我们自己写的类本身也是对象，他属于java.lang.Class类的实例对象；
There is a class named Class
所以，在面向对象世界里，万事万物皆对象。

Class源代码
构造器私有化，仅可以JVM调用

  /*
     * Private constructor. Only the Java Virtual Machine creates Class objects.
     * This constructor is not used and prevents the default constructor being
     * generated.
     */
    private Class(ClassLoader loader) {
        // Initialize final field for classLoader.  The initialization value of non-null
        // prevents future JIT optimizations from assuming this final field is null.
        classLoader = loader;
    }

2.如何表示他呢？

/**
 * Author:林万新 lwx
 * Date:  2017/11/14
 * Time: 18:42
 */
public class ClassDemo1 {
    public static void main(String[] args) {
        //Foo的实例对象如何表示？
        Foo foo1 = new Foo();
        //Foo这个类本身也是实例对象，属于Class类的对象
        //任何一个类都是Class类的实例对象，表示方式3种

        //1，知道类名创建。告诉我们任何一个类都有一个隐含的静态成员变量：class
        Class c1 = Foo.class;

        //2.已知该类的对象。通过getClass方法
        Class c2 = foo1.getClass();

        //c1,c2表示了Foo类的类 类型（class type），类比其他基本类型啊，什么的
        //这个对象称为该类的类 类型

        //c1 or c2都代表了Foo类的类类型，1个类只可能是Class类的一个实例对象
        System.out.println(c1 == c2);

        //3.
        Class c3= null;
        try {
            c3 = Class.forName("Fanshe.Foo");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        System.out.println(c3 == c2);

        //通过类的类类型创建该类的实例
        try {
            Foo foo = (Foo) c1.newInstance();//前提是需要无参的构造方法
            foo.foo();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }

    }

}

class Foo{
    public void foo(){
        System.out.println("foo");
    }
}

运行结果：

动态加载

这里需要用记事本操作一下实现类编译、运行，就能明白什么道路了：
1.如果是用new 来创建对象，那么就属于静态加载，编译时期就要全部加载，其中某个类没创建就会报错；
2.但是如果用Class.for.name()来动态加载，用到哪个类就加载运行哪个，而不是全部一下子加载完毕才可以运行，

通过反射获取类对象的信息

/**
 * Author:林万新 lwx
 * Date:  2017/11/14
 * Time: 19:40
 */
public class ClassDemo2 {
    public static void main(String[] args) {
        //基本类型都有类类型
        Class c1 = int.class;
        Class c2 = String.class;//可以理解成String类字节码（.class）
        Class c3 = Double.class;
        Class c4 = double.class;
        Class c5 = void.class;
        System.out.println(c1.getName());
        System.out.println(c2.getName());
        System.out.println(c2.getSimpleName());//没有包名的名称
        System.out.println(c5.getName());
    }
}
运行结果：
int
java.lang.String
String
void

Class类的基本API使用

/**
 * Author:林万新 lwx
 * Date:  2017/11/14
 * Time: 19:58
 */
public class ClassUtil {

    /**
     * 打印类对象的方法
     *
     * @param obj
     */
    public static void printClassMethodMessage(Object obj){
        //1.获取类的类类型
        Class c = obj.getClass();//传递的是那个子类的对象，c就是该子类的类类型
        //获取类的名称
        System.out.println("类的名称："+ c.getName());
        /**Method类
         * 一个成员方法就是1个Method对象
         * getMethods()获取所有public函数，包括父类继承而来的
         * getDeclaredMethods()获取该类自己声明的方法
         *
         * 比如：int test(int ,int )
         */
        Method[] ms = c.getMethods();
        for (int i = 0; i <ms.length ; i++) {
            //得到的是返回值类型的类类型
            Class returnType = ms[i].getReturnType();
            System.out.print(returnType.getName()+ " ");
            //方法名称
            System.out.print(ms[i].getName() +"(");
            //获取参数类型
            Class[] paramTypes = ms[i].getParameterTypes();
            for(Class class1 : paramTypes)
            System.out.print(class1.getName()+",");

            System.out.println(")");

        }
    }

    /**
     * 打印类对象的成员变量
     * @param obj
     */
    public static void printFieldMessage(Object obj){
        Class c = obj.getClass();

        /**
         *    成员变量也是对象: 比如：int name
         java.lang.reflect.Filed
         Field类封装了关于成员变量的操作
         getFields()方法获取的是public的成员变量信息
         getDeclaredFileds获取的是该类自己声明的成员变量信息
         */
        Field[] fs = c.getDeclaredFields();
        for(Field field : fs){
            Class fieldType  = field.getType();//得到比如：int.class
            String typeName = fieldType.getName();//得到成员类型 ；int
            String fieldName = field.getName();//得到成员变量的名称：name
            System.out.println(typeName + " " + fieldName);
        }
    }

    /**
     * 打印类对象的构造信息
     * @param obj
     */
    public static void printConMessage(Object obj){
        Class c = obj.getClass();
        /**
         *    Constructor构造函数也是对象
         *    java.lang.Constructor封装了构造函数的信息
         */
        //Constructor[] cs = c.getConstructors();这是获取public的构造函数
        Constructor[] cs = c.getDeclaredConstructors();//得到所有的，也就是自己声明的
        for(Constructor constructor : cs){
            System.out.print(constructor.getName()+"(");
            //获取他的参数列表的类类型
            Class [] paramTypes = constructor.getParameterTypes();
            for(Class class1:paramTypes)
                System.out.print(class1.getName() + ",");

            System.out.println(")");
        }

    }
}

public class ClassDemo3 {
    public static void main(String[] args) {
        String s = "hello";
        ClassUtil.printClassMethodMessage(s);

        ClassUtil.printFieldMessage(s);

        ClassUtil.printConMessage(s);
    }
}

运行结果部分显示：

方法反射调用类对象方法执行

/**
 * Author:林万新 lwx
 * Date:  2017/11/14
 * Time: 21:33
 */
public class MethodDemo1 {
    public static void main(String[] args) {
        //获取print（int,int）方法
        //第1步.获取类的类类型
        A a1 = new A();
        Class c = a1.getClass();
        //2.获取方法：   名称和参数列表
        //c.getMethod()获取的是public方法
        //c.getDeclaredMethod()获取自己声明的方法
        try {
           // Method m = c.getMethod("print",new Class[]{int.class,int.class});
            Method m = c.getMethod("print", int.class, int.class);


           // a1.print(10,20);以前的会这样子调用
            //方法的反射操作：用m对象来进行方法的调用
            //方法如果没有返回值返回null，如果有返回具体的返回值
            try {
                //m.invoke(a1,new Object[]{10,20});
                m.invoke(a1,10,20);
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            } catch (InvocationTargetException e) {
                e.printStackTrace();
            }

        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        }

        System.out.println("===============");
        try {
            //获取方法print(String,String)
            Method m1 = c.getMethod("print", String.class, String.class);

            try {
                //用方法反射操作
                m1.invoke(a1,"hello","world");
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            } catch (InvocationTargetException e) {
                e.printStackTrace();
            }
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        }
        System.out.println("============");
        try {
            Method m2 = c.getMethod("print");
            try {
                m2.invoke(a1);
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            } catch (InvocationTargetException e) {
                e.printStackTrace();
            }
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        }
    }

}

class A{
    public void print(){
        System.out.println("无参数");
    }

    public void print(int a,int b){
        System.out.println(a+b);
    }
    public void print(String a,String b){
        System.out.println(a.toUpperCase()+"," + b.toLowerCase());
    }
}

运行结果

通过反射理解集合泛型的本质

/**
 * Author:林万新 lwx
 * Date:  2017/11/14
 * Time: 22:21
 */
public class MethodDemo2 {
    public static void main(String[] args) {
        ArrayList list = new ArrayList();

        ArrayList<String> list1 = new ArrayList<>();

        list1.add("hello");
        //list1.add(20);这个就不允许加入
        Class c1 = list.getClass();
        Class c2 = list1.getClass();
        System.out.println(c1 == c2);//输出true，说明编译之后集合的泛型是去泛型化的

        //反射的操作都是编译之后的操作，因为是.class字节码文件。编译完之后才进行的，也就是运行时操作

        //集合的泛型是防止错误输入，只在编译阶段有效，绕过编译就无效了；
        //验证：用反射才验证，

        try {
            Method m = c2.getMethod("add",Object.class);
            try {
                m.invoke(list1,100);
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            } catch (InvocationTargetException e) {
                e.printStackTrace();
            }
            System.out.println(list1.size());
            System.out.println(list1);//不允许for each遍历
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        }

    }
}

运行结果：