java的反射机制

JAVA反射机制是在运行状态中，对于任意一个实体类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意方法和属性；这种动态获取信息以及动态调用对象方法的功能称为java语言的反射机制。

java反射的关键：万事万物皆对象

反射就是把java类中的各种成分映射成一个个的Java对象

Girl girl =new Girl();
 //Girl这个类 也是一个实例对象，任何一个类都都是Class的实例对象

如何获取类类型

三种表达方式，得到的类类型是一样的输出值如：class top.maniy.factory.YouthGirl
class +包名.类名

//第一种表达方式--》实际在告诉我们任何一个类都有一个隐含的静态成员变量
        Class c1 =Girl.class;

        //第二中表达方式，已经知道该类的对象通过getClass方法
        Class c2 =girl.getClass();//c2是Girl类类型（class type）

        System.out.println(c1==c2);
        //第三种表达方式
        Class c3 =null;

        try {
            c3 =Class.forName("Girl");//如果有包要加包名 如:top.maniy.Girl
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        System.out.println(c2==c3);

通过类的类类型创建给类的对象实例

//可以通过类的类类型创建给类的对象实例 --》通过c1\c2\c3创建Girl类实例
        try {
            Girl girl1 =(Girl)c1.newInstance();//要求存在无参的构造方法
            girl1.print();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }

java动态加载类

Class.forName(“类的全称”)
不仅表示了类的类类型，还代表了动态加载类
注意：编译时刻加载类是静态加载类，运行时刻加载类是动态加载类

java获取类相关信息

数据类型和关键字都有类类型

  Class c4 =int.class;//int类类型
  Class c5 =String.class;//String类的类类型

类名称

       System.out.println(c5.getName());//含包名的类名称
        System.out.println(c5.getSimpleName());//不含包名的类名称

方法信息（一个成员方法就是一个Method对象）

	Method[] ms =c5.getMethods();
        Method[] mds =c5.getDeclaredMethods();

        for(int i =0;i<ms.length;i++){
            //得到方法的返回值类型的类类型 如：class int
            Class returnType=ms[i].getReturnType();
            //其类类型名名称 如：int
            System.out.println(returnType.getName());
            //获取方法名
            System.out.println(ms[i].getName());

            //获取参数类型--》得到的是参数列表的类型的类类型
            Class[] paramTypes =ms[i].getParameterTypes();

            for (int j = 0; j <ms.length ; j++) {
                System.out.println(ms[j].getName());
            }

        }

获取成员变量信息

 /**
         * 成员变量也是对象
         * java.lang.reflect.Field
         * Field类封装了关于成员变量的操作
         * getFields()方法获取的是所有的public的成员变量的信息
         */
        Field[] fs =c1.getFields();
        Field[] fds =c1.getDeclaredFields();
        for(Field field:fs){
            //得到成员变量的类型的类类型
            Class fieldType =field.getType();
            String typeName =fieldType.getTypeName();
            //得到成员变量的名称
            String fieldName =field.getName();            
        }

获取构造方法信息

/**
         * 构造函数也是对象
         * java.lang.Constructor中封装构造函数的信息
         */
        Constructor[] cs = c1.getConstructors();
        for(Constructor constructor:cs){
            System.out.println(constructor.getName());
            //获取参数类型--》得到的是参数列表的类型的类类型
            Class[] paramTypes =constructor.getParameterTypes();

            for (int j = 0; j <ms.length ; j++) {
                System.out.println(ms[j].getName());
            }
        }

方法的反射操作

   try {
            //Method m=c1.getMethod("aPrint", new Class[]{int.class, int.class});
            Method m=c1.getMethod("aPrint", int.class, int.class);
            //方法的反射操作是用m对象来进行方法调用 和c1.aPrint完全相同
            //Object o =m.invoke(girl,new Object[]{20,30});
            Object o =m.invoke(girl,20,30);
        } catch (Exception e) {
            e.printStackTrace();
        }

泛型

java中集合的泛型，是防止错误输入的，只在编译阶段有效
反射的操作都输编译之后的操作，所以绕过编译泛型就无效了