Java中的反射

反射

Class类

Java是一个面向对象的语言，在Java中万事万物皆对象，但除了基本数据类型和静态的成员。

那类是谁的对象呢？

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

public class ClassDemo1 {
    public static void main(String[] args) {
        //类A的实例对象如何表示
        A a = new A();
        //A这个类也是一个实例对象，是Class类的实例对象，所有类都是Class类的实例对象
        //有三种表示方式
        //第一种表示方式-->告诉我们任何一个类都有一个class静态成员变量
        Class c1 = A.class;

        //第二种表示方式-->通过A类的实例对象来getClass();
        Class c2 = a.getClass();
        System.out.println(c1 == c2);

        //第三种表示方式--> 反射 通过类的全类名
        Class c3 = null;
        try {
            c3 = Class.forName("com.thc.reflect.A");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        System.out.println(c1 == c3);

        /**
         * c1,c2,c3表示了A类的类类型（class type）
         * 因为class A本身是Class类的对象，而class A本身也有自己的实例对象，用于区分。
         * 类也是对象，是Class类的对象
         * 这个对象我们称为类类型
         * 一个类只可能是Class类的一个实例对象，所有都输出true
         */
        //我们可以通过类的类型来创建对象实例，通过c1,c2,c3来创建类A的实例对象
        try {
            A a1 = (A) c1.newInstance();//需要有无参构造方法
            a1.print();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }

    }
}

class A {
    void print() {
        System.out.println("a");
    }
}

动态加载类

使用new创建对象，是静态加载类，在编译期就需要加载所有可能需要使用到的类。

使用Class.forname()，动态加载类，在运行时刻才会加载类，在编译的时候不会去管你用的是什么类，只有在运行时把你要用的类拿过来才回去检查是否有该类。

获取方法信息

我们可以通过一个对象来获取该对象的类的类类型，然后通过类的类类型来获取类的成员变量、成员函数、构造方法等。

public class ClassUtil {
    /**
     * 获取类的成员方法的信息
     * @param obj
     */
    public static void printClassMethodMessage(Object obj) {
        // 要获取类的信息，首先要获取类的类类型
        Class c = obj.getClass();
        // 获取类的名称
        System.out.println(c.getName());
        /**
         * Method类，方法对象
         * 一个成员方法就是一个Method对象
         * getMethods（）方法获取的是所有的public函数，包括父类继承而来的
         * getDeclaredMethods()方法是获取该类的自己声明的方法，不管访问权限
         */
        Method[] ms = c.getMethods();//c.getDeclaredMethods();
        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[] parameterTypes = ms[i].getParameterTypes();
            for (Class class1 : parameterTypes) {
                System.out.println(class1.getName() + ",");
            }
            System.out.println(")");
        }
    }

    /**
     * 获取成员变量的信息
     * @param obj
     */
    public static void printClassFieldMessage(Object obj) {
        Class c = obj.getClass();

        /**
         * Field类 封装了成员变量的操作
         * getFields()方法获取的是所有public的成员变量信息
         * getDeclareFields获取的是该类自己声明的所有成员变量信息
         */
        Field[] fields = c.getFields();
        for (Field field: fields) {
            //得到成员变量的类型的类类型
            Class fieldType = field.getType();
            String typeName = fieldType.getName();
            //得到成员变量的名称
            String fieldName = field.getName();
            System.out.println(typeName + " " + fieldName);

        }
    }

    /**
     * 获取类的构造器信息
     * @param obj
     */
    public static void printClassConMessage(Object obj) {
        Class c = obj.getClass();

        /**
         * 构造函数也是对象
         * java.lang.Constructor中封装了构造函数的信息
         * getConstructors()可以获取类中public修饰的构造函数
         * getDeclaredConstructors得到所有构造函数
         */
        Constructor[] constructors = c.getConstructors();
        for (Constructor constructor : constructors) {
            System.out.print(constructor.getName() + "(");
            // 获取构造函数的参数列表---> 参数列表的类类型
            Class[] parameterTypes = constructor.getParameterTypes();
            for (Class class1 : parameterTypes) {
                System.out.print(class1.getName() + ",");
            }
            System.out.println(")");
        }
    }
}

public class ClassDemo3 {
    public static void main(String[] args) {
        ClassUtil.printClassMethodMessage("abc");
        System.out.println("=================");
        ClassUtil.printClassConMessage("abc");
        System.out.println("=================");
        ClassUtil.printClassConMessage(new Integer(1));
        System.out.println("=================");
        ClassUtil.printClassFieldMessage(new Integer(1));
    }
}

部分打印结果如下：

java.lang.String toLowerCase(java.util.Locale,)
java.lang.String toLowerCase()
java.lang.String toUpperCase()
java.lang.String toUpperCase(java.util.Locale,)
java.lang.String trim()
void wait()
void wait(long,int,)
void wait(long,)
java.lang.Class getClass()
void notify()
void notifyAll()
java.util.stream.IntStream chars()
java.util.stream.IntStream codePoints()
=================
java.lang.String([B,int,int,)
java.lang.String([B,)
java.lang.String([I,int,int,)
java.lang.String()
java.lang.String([C,)
java.lang.String(java.lang.String,)
java.lang.String([C,int,int,)
java.lang.String([B,int,)
java.lang.String([B,int,int,int,)
=================
java.lang.Integer(int,)
java.lang.Integer(java.lang.String,)
=================
int MIN_VALUE
int MAX_VALUE
java.lang.Class TYPE
int SIZE
int BYTES

通过反射调用方法

public class ClassDemo4 {
    public static void main(String[] args) {
        B b = new B();
        // 获取类的类类型
        Class c = b.getClass();
        try {
            //获取方法print(int, int)
            //c.getMethod("print", int.class, int.class);
            Method m = c.getMethod("print", new Class[]{int.class, int.class});
            //m.invoke(b, new Object[] {10, 20});
            //方法有返回值返回具体的返回值，没返回值返回null
            Object o = m.invoke(b, 10, 20);

            Method m1 = c.getMethod("print", String.class, String.class);
            m1.invoke(b, new Object[] {"hello", "WORLD"});

            //c.getMethod("print", new Class[] {});
            Method m2 = c.getMethod("print");
            m2.invoke(b);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

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

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

    public void print() {
        System.out.println("Hello,world!");
    }
}

反射可以绕过编译检查

public class ClassDemo5 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        ArrayList list1 = new ArrayList();

        // 通过泛型可以防止我们错误操作
        list.add("a");
//        list.add(1);

        list1.add("a");
        list1.add(1);

        Class c1 = list.getClass();
        Class c2 = list1.getClass();
        // 返回true，说明在编译期间会进行泛型擦除
        System.out.println(c1 == c2); // true

        try {
            //通过反射可以绕过编译检查
            Method m = c1.getMethod("add", Object.class);
            // 将整数1加入了list
            m.invoke(list, 1);
            // 这时候打印就会报错，Integer cannot be cast to java.lang.String
            for (String s : list) {
                System.out.println(s);
            }
            System.out.println(list.size());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}