记录生活中的点点滴滴

0%

Java基础--反射

反射是框架设计的灵魂

(使用的前提条件:必须先得到代表的字节码的Class,Class类用于表示.class文件(字节码))

反射的概述

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

要想解剖一个类,必须先要获取到该类的字节码文件对象。而解剖使用的就是Class类中的方法.所以先要获取到每一个字节码文件对应的Class类型的对象

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

例如:一个类有:成员变量、方法、构造方法、包等等信息,利用反射技术可以对一个类进行解剖,把个个组成部分映射成一个个对象。

​ (其实:一个类中这些成员方法、构造方法、在加入类中都有一个类来描述)

熟悉一下加载的时候:Class对象的由来是将class文件读入内存,并为之创建一个Class对象

Class类

查看Class类在java中的api详解(1.7的API):

Class 类的实例表示正在运行的 Java 应用程序中的类和接口。也就是jvm中有N多的实例每个类都有该Class对象。(包括基本数据类型)

Class 没有公共构造方法。Class 对象是在加载类时由 Java 虚拟机以及通过调用类加载器中的defineClass 方法自动构造的。也就是这不需要我们自己去处理创建,JVM已经帮我们创建好了

有64个方法,如下

反射的使用

先写一个Student类,借助其来做讲解:

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
public class Student {
private int id;
private String name;

public void read(){
System.out.println("读书....");
}

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

public int getId() {
return id;
}

public void setId(int id) {
this.id = id;
}

public String getName() {
return name;
}

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

public Student(int id, String name) {
this.id = id;
this.name = name;
}

public Student() {
}

private Student(int id){
this.id = id;
System.out.println("私有构造方法执行...");
}

public static void main(String[] args) {
System.out.println("main方法执行...");
}
}

获取Class对象的三种方式

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
@Test
public void Test1() throws Exception {
//第一种方式获取class
Student stu1 = new Student();
Class<? extends Student> stuClass1 = stu1.getClass();

//第二种方式获取class
Class<Student> studClass2 = Student.class;

//比较这两种class是否一样
System.out.println(stuClass1 == studClass2); //true

//第三种方式获取class
Class<?> stuClass3 = Class.forName("cn.gs.ch5extend.Student");
System.out.println(stuClass1 == stuClass3); //true
}

在运行期间,一个类,只有一个Class对象产生

三种方式常用第三种

  • 第一种对象都有了还要反射干什么

  • 第二种需要导入类的包,依赖太强,不导包就抛编译错误

  • 般都第三种,一个字符串可以传入也可写在配置文件中等多种方法

通过反射获取构造方法并调用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
@Test
public void Test2() throws Exception{
Class<?> stuClass = Class.forName("cn.gs.ch5extend.Student");

System.out.println("-------------获取所有公共构造方法--------------");
Constructor<?>[] constructors1 = stuClass.getConstructors();
for (Constructor c : constructors1) {
System.out.println(c);
}

System.out.println("-------------获取所有构造方法--------------");
Constructor<?>[] constructors2 = stuClass.getDeclaredConstructors();
for (Constructor c : constructors2) {
System.out.println(c);
}

System.out.println("------------获取私有构造方法并暴力执行----------");
Constructor<?> con = stuClass.getDeclaredConstructor(int.class);
con.setAccessible(true);//暴力访问
Object o = con.newInstance(11);
System.out.println(o);
}

输出结果:

1
2
3
4
5
6
7
8
9
10
-------------获取所有公共构造方法--------------
public cn.gs.ch5extend.Student(int,java.lang.String)
public cn.gs.ch5extend.Student()
-------------获取所有构造方法--------------
public cn.gs.ch5extend.Student(int,java.lang.String)
private cn.gs.ch5extend.Student(int)
public cn.gs.ch5extend.Student()
------------获取私有构造方法并暴力执行----------
私有构造方法执行...
Student{id=11, name='null'}

调用方法:

  1. 获取构造方法

    1. 批量的方法
      public Constructor[] getConstructors():**所有”公有的”构造方法

      public Constructor[] getDeclaredConstructors():获取所有的构造方法**(包括私有、受保护、默认、公有)

    2. 获取单个的方法
      public Constructor getConstructor(Class… parameterTypes):获取单个的”公有的”构造方法
      public Constructor getDeclaredConstructor(Class… parameterTypes):获取”某个构造方法”可以是私有的,或受保护、默认、公有

  2. 调用构造方法

    Constructor–>newInstance(Object… initargs)

    newInstance是 Constructor类的方法(管理构造函数的类)

    api的解释为:

    newInstance(Object... initargs)

    ``Constructor` 对象表示的构造方法来创建该构造方法的声明类的新实例,并用指定的初始化参数初始化该实例。

    它的返回值是T类型,所以newInstance是创建了一个构造方法的声明类的新实例对象。并为之调用

通过反射获取成员变量并调用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
@Test
public void Test3() throws Exception {
Class<?> stuClass = Class.forName("cn.gs.ch5extend.Student");

System.out.println("----------------获取所有字段--------------");
Field[] fields = stuClass.getDeclaredFields();
for (Field f : fields) {
System.out.println(f);
}
System.out.println("----------设置私有暴力访问并为赋值-------------");
Field f = stuClass.getDeclaredField("name");
f.setAccessible(true);//暴力访问
//获取一个对象
Object stu = stuClass.getConstructor().newInstance();
f.set(stu,"刘德华");//为Student对象中的name属性赋值--》stu.name = "刘德华"
Student s = (Student) stu;
System.out.println(s.getName());
}

输出结果:

1
2
3
4
5
----------------获取所有字段--------------
private int cn.gs.ch5extend.Student.id
private java.lang.String cn.gs.ch5extend.Student.name
----------设置私有暴力访问并为赋值-------------
刘德华

获取成员变量并调用:

  1. 批量的

    1) Field[] getFields():获取所有的”公有字段”

    2) Field[] getDeclaredFields():获取所有的字段(包括:私有、受保护、默认、公有)

  2. 单个的

    1) Field getField(String fieldName):获取某个”公有的”字段

    2) Field getDeclaredField(String fieldName):获取某个字段(可以是私有的)

  3. 设置字段的值

    Field –> public void set(Object obj,Object value):

    参数说明:

    • obj:要设置的字段所在的对象
    • value:要为字段设置的值

通过反射获取成员方法并调用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
@Test
public void Test4() throws Exception {
Class<?> stuClass = Class.forName("cn.gs.ch5extend.Student");

System.out.println("----------------获取所有方法--------------");
Method[] methods = stuClass.getDeclaredMethods();
for (Method m : methods) {
System.out.println(m);
}
System.out.println("-----------");
Method read = stuClass.getMethod("read");
//获取一个对象
Object stu = stuClass.getConstructor().newInstance();
read.invoke(stu);//调用方法
}

输出结果:

1
2
3
4
5
6
7
8
9
10
----------------获取所有方法--------------
public static void cn.gs.ch5extend.Student.main(java.lang.String[])
public java.lang.String cn.gs.ch5extend.Student.toString()
public java.lang.String cn.gs.ch5extend.Student.getName()
public void cn.gs.ch5extend.Student.read()
public void cn.gs.ch5extend.Student.setName(java.lang.String)
public int cn.gs.ch5extend.Student.getId()
public void cn.gs.ch5extend.Student.setId(int)
-----------
读书....

获取成员方法并调用:

  1. 批量的、单量的和上面一样

  2. 调用方法:

    Method –> public Object invoke(Object obj,Object… args)

    参数说明:

    • obj : 要调用方法的对象
    • args:调用方式时所传递的实参

通过反射获取main方法并使用

1
2
3
4
5
6
7
8
@Test
public void Test5() throws Exception{
Class<?> stuClass = Class.forName("cn.gs.ch5extend.Student");

System.out.println("--------------获取main方法--------------");
Method main = stuClass.getMethod("main", String[].class);
main.invoke(null,(Object) new String[]{"a","b"});
}

输出结果:

1
2
--------------获取main方法--------------
main方法执行...

通过反射运行配置文件内容

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
@Test
public void Test6() throws Exception {
//通过Properties类读取txt配置文件
Properties properties = new Properties();
FileReader fileReader = new FileReader("src/cn/gs/ch5extend/pro.txt");
properties.load(fileReader);
fileReader.close();
//获取className和method字段
String className = properties.getProperty("className");
String method = properties.getProperty("method");

//通过反射获取实例并执行方法
Class<?> stuClass = Class.forName(className);
Method m = stuClass.getMethod(method);
m.invoke(stuClass.getConstructor().newInstance());
}

输出结果:

1
读书....

通过反射越过泛型检查

泛型用在编译期,编译过后泛型擦除(消失掉),所以是可以通过反射越过泛型检查的

例如:有一个String泛型的集合,怎样能向这个集合中添加一个Integer类型的值?

1
2
3
4
5
6
7
8
9
10
11
@Test
public void Test7() throws Exception {
ArrayList<String> list = new ArrayList<>();
list.add("aaa");
list.add("bbb");

Method add = list.getClass().getMethod("add", Object.class);
add.invoke(list,100);

System.out.println(list);
}

输出结果:

1
[aaa, bbb, 100]