Java SE系列笔记——反射

前言

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

Java的反射机制允许编程人员在对类未知的情况下，获取类相关信息的方式变得更加多样灵活，调用类中相应方法，是Java增加其灵活性与动态性的一种机制。

图片摘自C语言中文网

关于Class

众所周知Java有个Object 类，是所有Java 类的继承根源，其内声明了数个应该在所有Java 类中被改写的方法：hashCode()、equals()、clone()、toString()、getClass()等。其中getClass()返回一个Class 对象。

Class类十分特殊。它和一般类一样继承自Object，其实体用以表达Java程序运行时的classes和interfaces，也用来表达enum、array、primitive Java types（boolean, byte, char, short, int, long, float,double）以及关键词void。当一个class被加载，或当加载器（classloader）的defineClass()被JVM调用，JVM 便自动产生一个Class对象。
如果您想借由“修改Java标准库源码”来观察Class对象的实际生成时机（例如在Class的constructor内添加一个println()），这样是行不通的！因为Class并没有public constructor。

Class是Reflection故事起源。针对任何您想探勘的类，唯有先为它产生一个Class对象，接下来才能经由后者唤起为数十多个的Reflection APIs。这些APIs将在稍后的探险活动中一一亮相。

上述为Class class片段。注意它的private Class() {}，意指不允许任何人经由编程方式产生Class object。是的，其object 只能由JVM 产生。

反射机制

Java 反射机制主要提供了以下功能，这些功能都位于java.lang.reflect包。

1. 在运行时判断任意一个对象所属的类。
2. 在运行时构造任意一个类的对象。
3. 在运行时判断任意一个类所具有的成员变量和方法。
4. 在运行时调用任意一个对象的方法。
5. 生成动态代理。

示例

Person类

public class Person {
	//私有属性
    private String name;
    public int age;
    //私有静态属性
    private static int id;

	public Person() {
    }
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    //私有构造器
	private Person(String name) {
        this.name = name;
    }
	//私有静态有参方法
    private static void pri(int i){
        System.out.println("你好"+i);
    }
	//set()get()toString()略
	
    public void show(){
        System.out.println("你好 我是一个人");
    }
	//私有有返回值有参方法
    private int prt(String str){
        System.out.println("我的国籍是："+str);
        return 5;
    }
}

• 反射之前new对象
  通过new关键字调用公开构造器造对象，且无法调用静态非静态私有属性和私有方法。

	//反射之前
    public void test(){
        Person p1 = new Person();
        //属性赋值
        p1.age = 10;
        System.out.println(p1);
        //调方法
        p1.show();
    }

• 利用反射之后

	//获取Class实例方式
    public void test() throws ClassNotFoundException {
        //方式一 调用运行时类的属性:class
        Class c1 = Person.class;
        System.out.println(c1);
        //方式二 调用运行时类对象的属性:getClass
        Person p1 = new Person();
        Class c2 = p1.getClass();
        System.out.println(c2);
        //方式三 调用Class静态方法 forName(String classPath)(常用)
        Class c3 = Class.forName("com.landlord.project.Person");
        System.out.println(c3);
        //方式四 使用类的加载器
        ClassLoader classLoader = ReflectionTest.class.getClassLoader();
        Class c4 = classLoader.loadClass("com.landlord.project.Person");
        System.out.println(c4);
    }

反射的强大！访问私有结构！

	//调用运行时类指定结构
    public void test() throws Exception {
        Class c = Class.forName("com.landlord.project.Person");
        //创建运行时类对象
        //空参构造器 权限要够 一般为public
        Person p = (Person)c.newInstance();
        
        //获取指定属性(不常用)
        Field age = c.getField("age");
        //获取修改之前当前属性值
        System.out.println(age.get(p));
        //设置当前属性值
        age.set(p,1001);
        //获取修改之后当前属性值
        System.out.println(age.get(p));

        //获取指定属性(常用)
        Field name = c.getDeclaredField("name");
        //保证当前属性可访问，关闭安全检查。
        name.setAccessible(true);
        //获取修改之前当前属性值
        System.out.println(name.get(p));
        //设置当前属性值
        name.set(p,"Kevin");
        //获取修改之后当前属性值
        System.out.println(name.get(p));

        //获取指定方法(常用)
        Method prt = c.getDeclaredMethod("prt",String.class);
        //保证当前方法可访问
        prt.setAccessible(true);
        System.out.println(prt.invoke(p, "李雷"));

        Method pri = c.getDeclaredMethod("pri",int.class);
        pri.setAccessible(true);
        //都可以，因为方法是静态的，不依附于对象
        pri.invoke(null, 4);
        pri.invoke(c, 4);
        pri.invoke(Person.class, 4);
        //任意对象
        pri.invoke(String.class, 4);

        //调任意指定构造器
        Constructor tom = c.getDeclaredConstructor(String.class);
        tom.setAccessible(true);
        Person person = (Person)tom.newInstance("Tom");
        System.out.println(person);
    }

• 获取类的任意结构

public void test5() throws ClassNotFoundException {
        Class clazz = Class.forName("com.landlord.project.Person");
        Class[] interfaces = clazz.getInterfaces();
        //获取该类所有实现的接口
        for (Class c : interfaces){
            System.out.println(c);
        }

        //获取类的所有属性字段 包括私有
        Field[] fields = clazz.getDeclaredFields();
        for (Field field : fields){
            System.out.println(field);
        }
        //获取该类所有构造器 包括私有
        Constructor[] constructors = clazz.getDeclaredConstructors();
        for (Constructor constructor : constructors){
            System.out.println(constructor);
        }
        //获取类的所有方法 包括私有
        Method[] methods = clazz.getDeclaredMethods();
        for (Method method : methods) {
            System.out.println(method);
        }
        //获取注解信息
        Annotation[] annotations = clazz.getAnnotations();
        for (Annotation annotation : annotations) {
            System.out.println(annotation);
        }
        //获取类所在包路径
        Package aPackage = clazz.getPackage();
        System.out.println(aPackage);

    }