JAVA--reflect(反射)

java编程之ReFlect(反射)

---

• Class类的反射
• 方法的反射
• 成员变量的反射
• 构造函数的反射

• java类加载机制

  ---

  Class类的反射

• Class类

  在面向对象的世界里，万事万物都是对象。
  java语言中，静态的成员，普通的数据类型也是对象，类的实例就是类的对象。
  那么类是谁的对象呢？
  类是对象，类是java.lang.Class类的实力对象。
  There is a class named Class

package com.imooc.ReFlectTest;
/**
*这段代码介绍了关于Class类的实例的三种创建方法
*/
public class ClassDemo1 {

    public static void main(String[] args) {
        //创建一个Dog类的实例对象
        Dog dog = new Dog();
        //Dog类也是实例对象，Dog类是Class类的实例对象
        //Class类只有private权限的构造函数，只允许jvm调用！
        //我Class类的实例对象，一共有3种表示方式

        //第一种每个类都有一个隐含的static（静态）的成员class，可以直接调用
        Class c1 = Dog.class;

        //第二种，已知一个类的实例对象，可以调用getClass（）方法
        Class c2 = dog.getClass();

        /**
         * 官方上给的解释，此处的c1,c2是Dog类的(class type(类类型))
         */

        //结果是true，说明c1,c2都代表了Dog类的类类型，也说明了一个类只有一个Class类的一个实例对象
        System.out.println(c1 == c2);

        //第三种方式，调用Class类的forName方法,会有异常
        Class c3 = null;
        try {
            //方法中写入类的全称
            c3 = Class.forName("com.imooc.ReFlectTest.Dog");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        //此处依然是true，还是那句话一个类只有一个Class类的实例对象
        System.out.println(c2 == c3);

        /**
         * 我们也可以通过类的类类型来创建该类的实例
         * 即我们可以用c1 or c2 or c3 来创建一个Dog类的对象
         */
        try {
            //类类型创建的类的实例是Object类型的，此处因为没有用泛型，所以我们需要进行强制类型转换
            //前提是该类要有无参数的构造方法
            Dog dog1 = (Dog)c1.newInstance();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }

    }
}


class Dog{}

Class.forName(“类的全称”)

• 不仅表示类的类类型，还表示了动态加载类
• 区分编译和运行
• 编译时加载的类是静态加载类，运行时加载的类是动态加载类

---

使用反射访问类的所有信息

代码中的注释已经详细解释了他们的作用

package com.imooc.ReFlectTest;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;

public class Classutil {

    /**
     * 打印类的信息，包括类的成员函数的信息
     * obj 即类的对象，此处没用泛型，所以用多态来实现
     */
    public static void printClassMassage(Object obj) {
        //获取实际传递的obj的类类型
        Class c = obj.getClass();//存在多态，实际调用时，调用的是传递的类的方法
        //获取类的名字
        System.out.println(c.getName());
        /**
         * Method方法，用来获取类的方法名
         * 一个方法就是一个Method对象
         * getMethods()方法获取的是所有的public的函数，包括从父类继承来的
         * getDeclaredMethods()方法获取类自己声明的所有方法，不问访问权限
         */
        Method[] methods =  c.getMethods();//c.getDeclaredMethods();

        for(int i=0; i<methods.length; i++) {
            //输出方法的名字
            System.out.print(methods[i].getName() + "(");
            //通过方法，获取方法的参数列表
            //getParameterType()方法，获取参数列表的类型的类类型
            Class[] parameterType = methods[i].getParameterTypes();
            //依次打印方法的参数列表
            for (Class class1 : parameterType) {
                System.out.print(class1.getName() + ",");
            }
            System.out.println(")");


        }

    }

    public static void printFieldMessage(Object obj) {
        Class c = obj.getClass();
        /**
         * 获取类的成员变量的信息
         * 用java.lang.reflect.Field
         * Field封装了关于类的成员变量的所有操作
         * getFileds()方法获取所有权限为public的成员变量的信息
         * getDeclaredFileds()方法获取的是该类自己声明的变量的信息
         */

        Field[] fileds = c.getDeclaredFields();

        for (Field field : fileds) {
            //得到成员变量的类型的类类型
            Class fieldType = field.getType();
            //typeName，成员变量的名字，即变量名
            String typeName = fieldType.getName();
            //fieldName，变量的类类型的名字，即变量的类型名（例：int，String）
            String fieldName = field.getName();

            System.out.println("typeName = " + typeName + " " +"fieldName = "+ fieldName);
        }
    }

    public static void printConMessage(Object obj) {
        Class c = obj.getClass();
        //获取所有的public的构造方法
        //Constructor[] cs = c.getConstructors();
        //获取当前类内的所有的构造方法Constructor
        Constructor[] cs = c.getDeclaredConstructors();
        for (Constructor constructor : cs) {
            System.out.print(constructor.getName() + "(");
            Class[] parameter = constructor.getParameterTypes();
            for (Class class1 : parameter) {
                System.out.print(class1.getName() + ",");
            }
            System.out.println(")");
        }
    }
}

通过上述代码的方法，我们可以访问任意一个类的名称以及它的所有方法的名称，参数列表以及返回值，包括构造函数！
当然除了上述的三种访问以外，reflect中还封装了很多很好的方法，我们可以在需要的时候，去查阅java.lang,Class的API

---

通过获取的类信息，可以做反射操作

我们通过获取的类的信息，可以方法调用对象

package com.imooc.ReFlectTest;

import java.lang.reflect.Method;

public class ClassDemo5 {

    public static void main(String[] args) {

        A a1 = new A();
        //获取方法的信息的前提是获取类的信息,获取类的信息要先获取类的类类型
        Class c = a1.getClass();

        try {
            /**
             * 获取方法，由名称和参数列表来决定
             * getMethod()获取public的方法
             * getDeclaredMethod()获取自己声明的方法
             */
            Method m = c.getMethod("print", int.class, int.class);
            //方法的反射调用，利用m对象进行方法的调用invoke（）方法，和a1.print()的效果完全相同
            //invoke(obj, new Object[])
            //方法无返回值，则返回null，否则返回方法的返回值 
            Object o = m.invoke(a1, new Object[]{10,20});
//          Object o = m.invoke(a1, 10,20);
            System.out.println("================================");
            Method m1 = c.getMethod("printStr", String.class, String.class);
            //用方法进行反射操作
//          a1.printStr("Hello", "World");
            m1.invoke(a1, "hello", "World");
            System.out.println("=================================");
            //方法没有参数
            //方法1 ，传一个空的类类型数组
//          Method m2 = c.getMethod("print", new Class[]{});
            //方法2，不穿参数也可以
            Method m2 = c.getMethod("print");
//          m2.invoke(a1, new Object[]{});
            m2.invoke(a1);

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

class A {
    public void print(int a, int b) {
        System.out.println(a + b);
    }

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

---

通过反射我们可以理解集合泛型的本质

泛型的目的是为了防止输入错误，但只在编译时有效。

package com.imooc.ReFlectTest;

import java.awt.event.FocusEvent;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;

public class ClassDemo6 {

    public static void main(String[] args) {
        List l1 = new ArrayList();
        List<String> l2 = new ArrayList<String>();

        Class c1 = l1.getClass();
        Class c2 = l2.getClass();
        //结果为true
        System.out.println(c1 == c2);


        l2.add("hello");
        //String类型的List不能添加int型的数，编译时无法通过
//      l2.add(20);

        /**
         * 反射的操作都是编译之后的操作
         * c1 == c2 返回值为true说明编译之后的集合是“去泛型化”的
         * java集合中的泛型，是防止错误输入的，只在编译阶段有效
         * 当我们绕过编译时，泛型就无效了
         * 验证：通过方法的反射操作，绕过编译
         */

        try {
            Method m = c2.getMethod("add", Object.class);
            m.invoke(l2, 20);
            System.out.println(l2.size());
            System.out.println(l2);

            /*
             * 不能使用foreach循环，会出异常
             * for (String string : l2) {
             *      System.out.println(string);
             * }
             */

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

    }

}