java基础-反射

1.Class类

任何一个类都是Class的实例对象，但是Class类的构造方法是私有的，必须由jvm创建对象

1.1 获取Class类的对象

(1) 任何一个类都有一个隐含的静态成员变量

Class clazz = Foo.class;

(2) 通过已知该类的对象通过getclass()方法

Class c2 = foo.getClass();

以上的c1，c2为Foo类的类类型

也就是说万事万物都是对象，类也是对象，是Class类的实例对象，这个对象我们称为该类的类类型，一个类就是Class的一个实例对象

(3) 

Class c3 = Class.forName("com.freeht.Foo");

我们可以通过类的类类型创建该类的对象实例，可以通过c1，c2，c3创建Foo的实例对象

Foo foo1 = (Foo) c2.newInstance();

2.静态加载和动态加载

静态加载

new创建的对象是静态加载类，在编译时刻就需要加载全部可能用到的类

动态加载

在运行时加载的类，通过Class.forName(...)来动态加载

上面的强制类型转换如果想要使用动态加载，那么需要写一个接口，并且强制类型转换成的类需要实现那个接口

3.基本数据类型都存在类类型

4.Class类的基本api

4.1 获取方法的信息

public class ClassUtil {

    /**
     * 打印类的信息，包括类的成员变量和信息
     * @param o 该对象所属类的信息
     */
    public static void printClassMessage(Object o) {
        //要获取类的信息，首先要获取类的类类型
        Class c = o.getClass();     //传递的是哪个子类的对象，c就是该子类的类类型
        //获取类的名称
        System.out.println("类的名称是：" + c.getName());
        //获取类的方法
        //getMethods方法获取的是所有public的函数，包括从父类继承而来的方法
        //getDeclaredMethods获取的是自己声明的方法
        Method[] methods = c.getMethods();  //c.getDeclaredMethods()
        for(int i = 0; i < methods.length; i++) {
            //得到方法的名称
            System.out.println(methods[i].getName());
            //等到返回值类型
            Class retureType = methods[i].getReturnType();
            System.out.println(retureType);
            System.out.println(methods[i].getName());
            //获取参数类型
            Class[] paramsTypes = methods[i].getParameterTypes();
            for(Class clazz : paramsTypes){
                System.out.println(clazz);
            }
        }
    }
}

4.2 获取成员变量的信息

public static void printFieldMessage(Object o) {
          Class c = o.getClass();
         /**
         * 成员变量也是对象
         * java.lang.reflect.Field
         * Field类封装了关于成员变量的信息
         * getFields()方法获取的是所有public的成员变量的信息
         * getDeclaredFields()方法获取的是自己声明的成员变量的信息
         */
        Field[] fields = c.getDeclaredFields();
        for (Field field : fields) {
            //得到成员变量的类型的类类型
            Class fieldType = field.getClass();
            String typeName = field.getName();      //得到成员变量的名字
            String fileName = fieldType.getName();  //得到成员变量的类型
            System.out.println(typeName + fileName);
        }
}

4.3 打印构造函数的信息

    /**
     * 获取构造函数信息
     * 构造函数也是对象
     * @param o
     */
    public static void printConMessage(Object o) {
        Class c = o.getClass();
        Constructor[] constructors = c.getConstructors();       //c.getDeclaredConstructors()
        for(Constructor constructor : constructors) {
            Class[] classes = constructor.getParameterTypes();      //得到构造函数的类类型
            for (Class c1 : classes) {
                System.out.println(c1.getName());
            }
        }
    }

　　

5.方法的反射

方法的名称和方法的参数列表才能决定某个列表

5.1 方法反射的操作

method.invoke(对象，参数列表)

public class MethodDemo1 {
    public static void main(String[] args) {
        //要获取print(int a, int b)
        //1.要获取一个方法就是获取类的信息，获取类的信息首先要获取类的类类型
        A a1 = new A();
        Class c1 = a1.getClass();
        /**
         * getMethod() 获得的是public的方法
         */
        try {
            //Method method = c1.getMethod("print", new Class[]{int.class, int.class});
            Method method = c1.getMethod("print", int.class, int.class);
            //方法的反射操作
            //是指method对象来进行方法调用，和a1.print()的调用相同
            //方法如果没有返回类型，那么就是null，如果有返回值类型，那么就是具体的返回值类型
            Object o = method.invoke(a1, new Object[]{10,20});
            Method method1 = c1.getMethod("print", String.class, String.class);
            Object o1 = method1.invoke(a1, "hello", "world");

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

class A{
    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.toUpperCase());
    }
}

　　

6.泛型的本质

反射的操作都是编译之后的操作

编译之后的集合是去泛型化的，也就是说java中集合泛型，是防止错误输入的，只在编译阶段有效，绕过编译就无效了

public class MethonDemo2 {
    public static void main(String[] args) {
        List list = new ArrayList();
        List<String> list1 = new ArrayList<String>();
        list1.add("hello");
        Class c1 = list.getClass();
        Class c2 = list1.getClass();
        System.out.println(c1 == c2);
        try {
            Method method = c1.getMethod("add", Object.class);
            method.invoke(list1, 100);  //绕过了编译就绕过了泛型
            System.out.println(list1.size());
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }
    }
}