JAVA基础——反射机制

1.反射（reflection）

在 Java 程序中许多对象在运行是都会出现两种类型：编译时类型和运行时类型。 编译时的类型由
声明对象时实用的类型来决定，运行时的类型由实际赋值给对象的类型决定 。

例如： Person p = new Student();

编译的时候类型为Person，运行时类型为Student。

2.反射的基本方法

反射 API 用来生成 JVM 中的类、接口或则对象的信息。

1. Class 类：反射的核心类，可以获取类的属性，方法等信息。
2. Field 类：Java.lang.reflec 包中的类，表示类的成员变量，可以用来获取和设置类之中的属性
   值。
3. Method 类： Java.lang.reflec 包中的类，表示类的方法，它可以用来获取类中的方法信息或
   者执行方法。
4. Constructor 类： Java.lang.reflec 包中的类，表示类的构造方法。

3、实践一下：

1. 首先定义一个Person类

public class Person {

    private String name;
    public int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
        System.out.println("有参构造函数");
    }

    private Person(String name){
        this.name = name;
    }

    public Person() {
        System.out.println("无参构造函数");
    }

    public void show(){
        System.out.println("公有方法");
    }

    private String showNation(String nation){
        System.out.println("我的国籍是："+nation);
        return nation;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

创建测试类

 @Test
    public void test2() throws IllegalAccessException, InvocationTargetException, InstantiationException, NoSuchMethodException, NoSuchFieldException {
        //.class是对Class的实例
        Class clazz = Person.class;
        System.out.println(clazz.getName());  //返回class类所表示的实体（类、接口、数组类、基本类）的名称
        //1.通过反射，创建Person对象
        Constructor constructor = clazz.getConstructor(String.class, int.class);
        Object obj = constructor.newInstance("张三",20);
        Person person =(Person)obj;
        System.out.println(person.toString());

        //2.通过反射，调用对象指定的属性和方法
        //调用属性
        Field age= clazz.getField("age");  //针对公有属性
        age.set(person,22);
        System.out.println(person.toString());

        //调用方法
        Method show =clazz.getDeclaredMethod("show");
        show.invoke(person);  //执行方法

        System.out.println("**************************************");

		//通过反射获取所有属性和方法，包含注解
	/**	Field[] fields = clazz.getDeclaredFields();
		 for (Field field : fields) {
		 if (field.isAnnotationPresent(注解类名.class)) {
		 注解类名 annot= (注解类名) field.getAnnotation(注解类名.class);
		 System.out.println(annot.toString());
		 }
*/

        //3.通过反射，调用类的私有结构，例如：私有属性，私有方法，私有构造器
        //调用私有属性
        Field name = clazz.getDeclaredField("name");
        name.setAccessible(true);   //设置属性可以进行访问
        name.set(person,"王五");
        System.out.println(person);

        //调用私有构造器
        Constructor cons = clazz.getDeclaredConstructor(String.class);
        cons.setAccessible(true);
        Person p1 = (Person)cons.newInstance("老六");  //构造器返回的是该Class的一个实例
        System.out.println(p1);

        //调用私有方法
        Method showNation = clazz.getDeclaredMethod("showNation",String.class);  //先写方法名，再写参数类型
        showNation.setAccessible(true);
        showNation.invoke(person,"中国");

        //invoke（） 返回的类型是方法的返回类型
        String str = (String) showNation.invoke(person,"中国");
        System.out.println(str);


    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

3.获取Class的实例方式

1、调用某个对象的 getClass()方法
Person p=new Person();
Class clazz=p.getClass();
2、调用某个类的 class 属性来获取该类对应的 Class 对象
Class clazz=Person.class;
3、使用 Class 类中的 forName()静态方法(最安全/性能最好)
Class clazz=Class.forName("类的全路径"); (最常用)
1
2
3
4
5
6
7

思考？

1.什么时候使用反射？

如果在编译的时候不确定需要实例化哪个对象时，可以使用反射。
1

2.反射机制与面向对象中的封装性矛盾吗？如何看待？

不矛盾。封装性是建议使用者调用一些已经写好的方法和属性；反射是可以调用类中的所用属性和方法，如果对于封装好的方法和属性不是很好，就可以调用该类生成一个新的对象。 反射的特征是动态的，
1

3.java.lang.Class类的理解

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