Java反射

Java反射

1.Java反射机制概述

Reflection（反射）是被视为动态语言的关键，反射机制允许程序在执行期借助于Reflection API取得任何类的内部信息，并能直接操作任意对象的内部属性及方法。
加载完类之后，在堆内存的方法区中就产生了一个class类型的对象（一个类只有一个Class对象），这个对象就包含了完整的类的结构信息。我们可以通过这个对象看到类的结构。这个对象就像一面镜子，透过这个镜子看到类的结构，所以，我们形象的称之为:反射。

Java反射机制提供的功能
    >在运行时判断任意一个对象所属的类
    >在运行时构造任意一个类的对象
    >在运行时判断任意一个类所具有的成员变量和方法
    >在运行时获取泛型信息
    >在运行时调用任意一个对象的成员变量和方法
    >在运行时处理注解
    >生成动态代理

public class Person {
    private String name;
    public int age;
    public Person(){}

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    private Person(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
    public void show(){
        System.out.println("我是一个人");
    }
    private String shownation(String nation){
        System.out.println("我的国籍是"+nation);
        return nation;
    }
}

public class ReflectionTest {
    //在Person类外部，不可以通过Person类的对象调用其内部私有结构。比如:私有的属性、方法 、构造器
    @Test
    public void test(){
        Person tom = new Person("Tom", 20);
        System.out.println(tom);
        tom.show();
    }
    @Test
    public void test2() throws Exception {
        //通过反射创建Person类的对象
        Class<Person> clazz = Person.class;
        Constructor<Person> person = clazz.getConstructor(String.class,int.class);
        Person tom = person.newInstance("Tom", 20);
        System.out.println(tom);//Person{name='Tom', age=20}
        //通过反射，调用对象指定的属性和方法
        Field age = clazz.getDeclaredField("age");
        age.set(tom, 10);
        System.out.println(tom.toString());//Person{name='Tom', age=10}

        Method show = clazz.getDeclaredMethod("show");
        show.invoke(tom);//我是一个人

        //通过反射，可以调用Person类的私有结构
        //调用私有的构造器
        Constructor<Person> constructor = clazz.getDeclaredConstructor(String.class);
        constructor.setAccessible(true);
        Person ben = constructor.newInstance("Ben");
        System.out.println(ben);//Person{name='Ben', age=0}

        //调用私有的属性
        Field name = clazz.getDeclaredField("name");
        name.setAccessible(true);
        name.set(ben, "ben2");
        System.out.println(ben);//Person{name='ben2', age=0}

        //调用私有的方法
        Method method = clazz.getDeclaredMethod("shownation", String.class);
        method.setAccessible(true);
        method.invoke(ben, "中国");//我的国籍是中国
    }
}

2.Class类的理解

类的加载过程：

程序经过javac.exe命令以后，会生成一个或多个字节码文件（.class结尾），接着我们使用java.exe命令对某个字节码文件进行解释运行。相当于将某个字节码文件加载到内存中。此过程就称为类的加载，加载到内存中的类，我们就称为运行时类，此运行时类，就作为Class的一个实例。

CLass的实例就对应着一个运行时类。加载到内存中的运行时类，会缓存一定的时间。在此时间之内，我们可以通过不同的方式来获取此运行时类。

//    获取Class实例的方式
    @Test
    public void test3() throws ClassNotFoundException {
//        调用运行时类的属性
        Class<Person> clazz = Person.class;
        System.out.println(clazz);
// 用运行时类的对象调用getClass()
        Person person = new Person();
        Class<? extends Person> aClass = person.getClass();
        System.out.println(aClass);
//调用Class的方法forName（String   classpath）
        Class<?> aClass1 = Class.forName("com.taiyuan.java04.Person");
        System.out.println(aClass1);
//使用类的加载器classLoader   (了解)
        ClassLoader classLoader = ReflectionTest.class.getClassLoader();
        Class<?> aClass2 = classLoader.loadClass("com.taiyuan.java04.Person");
        System.out.println(aClass2);
    }

哪些类型可以有Class对象?

1. class: 外部类，成员(成员内部类，静态内部类)，局部内部类，匿名内部类
2. interface:接口
3. []:数组
4. enum:枚举
5. annotation:注解@interface
6. primitive type:基本数据类型(
7. void

3.类的加载与ClassLoader的理解

当程序主动使用某个类时，如果该类还未被加载到内存中，则系统会通过如下三个步骤来对该类进行初始化。

类加载器的作用:

1. 类加载的作用:将class文件字节码内容加载到内存中，并将这些静态数据转换成方法区的运行时数据结构，然后在堆中生成一个代表这个类的java.lang.Class对象，作为方法区中类数据的访问入口。
2. 类缓存:标准的JavaSE类加载器可以按要求查找类，但一旦某个类被加载到类加载器中，它将维持加载(缓存）一段时间。不过JVM垃圾回收机制可以回收这些Class对象。

4.创建运行时类的对象

@Test
public void test1() throws IllegalAccessException, InstantiationException {
    Class clazz = Person.class;
    /**
         * newInstance():调用此方法，创建对应的运行时类的对象。内部调用了运行时类的空参构造器。
         * 要想此方法正常的创建运行时类的对象，要求：
         * 1. 运行时类必须提供空参的构造器
         * 2. 空参的构造器的访问权限的够，通常设置为public
         *
         *在javabean中要求提供一个public的空参构造器。原因:
         *	1.便于通过反射，创建运行时类的对象
		 *	2.便于子类继承此运行时类时，默认调用super()时，保证父类有此构造器
         */
    Object obj = clazz.newInstance();
    System.out.println(obj);
}

5.调用运行时类的指定结构

获取运行时类的属性

    @Test
    public void test1() throws Exception {
		//调用运行时类中指定的属性
        Class<Person> aClass = Person.class;
        Person person = aClass.newInstance();
		//只能获得public权限的属性（一般不用）
        Field age = aClass.getField("age");
        //设置当前属性的值
		//set()∶参数1:指明设置哪个对象的属性参数2:将此属性值设置为多少
        age.set(person,10);
		//获取当前属性的值get（）
        int i = (int) age.get(person);
        System.out.println(i);
    }

 @Test
    public void test2() throws Exception {
		//创建运行时类的实例
        Class<Person> aClass = Person.class;
        Person person = aClass.newInstance();
		//获取运行时类的指定变量名的属性
        Field name = aClass.getDeclaredField("name");
		//保证当前属性可以访问
        name.setAccessible(true);
        name.set(person,"Tom");
        System.out.println(name.get(person));
    }

获取运行时类的方法

    @Test
    public void test3() throws Exception {
        Class<Person> aClass = Person.class;
        Person person = aClass.newInstance();
        //调用指定的某个方法
        //getDeclaredMethod   （方法名，形参列表）
        Method method = aClass.getDeclaredMethod("shownation", String.class);
        //保证当前方法可以访问
        method.setAccessible(true);
        // 调用invoke(方法的调用者，给形参赋值的实参) 方法
        Object china = method.invoke(person, "China");
        //invoke() 的返回值即为对应类中调用方法的返回值
        System.out.println(china);

        System.out.println("***********如何调用静态犯法？******************");
        Method show = aClass.getDeclaredMethod("show");
        show.setAccessible(true);
		//Object invoke = show.invoke(Person.class);
        Object invoke = show.invoke(person.getClass() );
        System.out.println(invoke);
    }