java学习笔记#10-反射机制

• CLASS类的使用
• 方法的反射

CLASS类的使用

在面向对象的中，几乎所有的内容都是对象，除了静态成员和基本类型外。
类是java.lang.Class类的对象。
对象是对客观事物的抽象，类是对对象的抽象。它们的关系是，对象是类的实例，类是对象的模板。

任何一个类，都是Class类的实例对象。在java底层，Class类的构造方法是私有的

• 动态加载和静态加载
  编译时刻加载是静态加载类，运行时刻加载是动态加载类。
  new创建的对象都是编译时加载，因此需要在编译时刻就加载所有可能使用到的类，否则就会报错。

动态加载类的方法如下：

Class c = Class.forName("Framework.Reflact");
OtherClass otherclass =  c.newInstance()

这种方法通过类类型来创建对象。

Class还有很多其它的用途

public class ClassUtil {
    public static void printClassInfos(Object object){
        Class cls = object.getClass();
        System.out.println("Class name is :"+ cls.getName());
//        一个成员方法就是方法类的对象
        Method[] methods = cls.getMethods();//获取所有public方法，包括父类继承而来的。
        Method[] declaredMethods = cls.getDeclaredMethods();//获取自己声明的方法
        for (Method method : methods) {
            System.out.println(method.getName());
        }
        System.out.println("======================>");
//       成员变量也是对象
        Field[] fields = cls.getFields();//获取所有public成员变量信息。
        for (Field field:fields){
            System.out.println(field.getType());
            System.out.println(field.getName());
        }
        System.out.println("======================>");
//        构造函数也是对象
        Constructor[] constructors = cls.getConstructors();
        for(Constructor constructor: constructors){
            System.out.println(Arrays.toString(constructor.getParameterTypes()));
        }

    }
}

方法的反射

反射过程：
获取某个方法
method.invoke(对象，参数)

public class ReflectDemo {
    public static void main(String args[]){
//        获取类的信息
        A a1 = new A();
        Class cls = a1.getClass();
//        获取类的方法
        try {
//            Method method = cls.getMethod("print",new Class[]{int.class,int.class});
            Method method = cls.getMethod("print",int.class,int.class);

//            方法的反射操作：用method对象来调用方法。
//            原本操作为a1.print(10,20)
            method.invoke(a1,10,20);
        } catch (Exception 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.toLowerCase());
    }
}

可以通过反射来绕过泛型约束：

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

        list2.add("abc");
//        list2.add(20);错误的

        Class c1 = list1.getClass();
        Class c2 = list2.getClass();

        System.out.println(c1 == c2);
//        True,说明编译后的集合是去泛型的。

        try {
            Method m = c2.getMethod("add",Object.class);
            m.invoke(list2,100);
            System.out.println(list2);//[abc,100]
        } catch (Exception e) {
            e.printStackTrace();
        }