Java基础之—反射（非常重要）

灰太狼 2022-05-16 09:41 152阅读 0赞

# 反射是框架设计的灵魂 #

**（使用的前提条件：必须先得到代表的字节码的Class，Class类用于表示.class文件（字节码））**

# 一、反射的概述 #

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

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

**以上的总结就是什么是反射**

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

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

（其实：一个类中这些成员方法、构造方法、在加入类中都有一个类来描述）

如图是类的正常加载过程：反射的原理在与class对象。

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

![20170513133210763][]

其中这个Class对象很特殊。我们先了解一下这个Class类

# 二、查看Class类在java中的api详解（1.7的API） #

如何阅读java中的api详见java基础之——String字符串处理

![20170513135521667][]

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

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

没有公共的构造方法，方法共有64个太多了。下面用到哪个就详解哪个吧

![20170513144141409][]

# 三、反射的使用（这里使用Student类做演示） #

先写一个Student类。

## 1、获取Class对象的三种方式 ##

### 1.1 Object ——> getClass();   1.2 任何数据类型（包括基本数据类型）都有一个“静态”的class属性   1.3 通过Class类的静态方法：forName（String  className）(常用) ###

其中1.1是因为Object类中的getClass方法、因为所有类都继承Object类。从而调用Object类来获取

![20170513145317647][]

1.  `package fanshe;`
2.  `/**`
3.  `* 获取Class对象的三种方式`
4.  `* 1 Object ——> getClass();`
5.  `* 2 任何数据类型（包括基本数据类型）都有一个“静态”的class属性`
6.  `* 3 通过Class类的静态方法：forName（String className）(常用)`
7.  `*`
8.  `*/`
9.  `public class Fanshe {`
10. `public static void main(String[] args) {`
11. `//第一种方式获取Class对象`
12. `Student stu1 = new Student();//这一new 产生一个Student对象，一个Class对象。`
13. `Class stuClass = stu1.getClass();//获取Class对象`
14. `System.out.println(stuClass.getName());`
15.  
16. `//第二种方式获取Class对象`
17. `Class stuClass2 = Student.class;`
18. `System.out.println(stuClass == stuClass2);//判断第一种方式获取的Class对象和第二种方式获取的是否是同一个`
19.  
20. `//第三种方式获取Class对象`
21. `try {`
22. `Class stuClass3 = Class.forName("fanshe.Student");//注意此字符串必须是真实路径，就是带包名的类路径，包名.类名`
23. `System.out.println(stuClass3 == stuClass2);//判断三种方式是否获取的是同一个Class对象`
24. `} catch (ClassNotFoundException e) {`
25. `e.printStackTrace();`
26. `}`
27.  
28. `}`
29. `}`

## 注意：在运行期间，一个类，只有一个Class对象产生。 ##

三种方式常用第三种，第一种对象都有了还要反射干什么。第二种需要导入类的包，依赖太强，不导包就抛编译错误。一般都第三种，一个字符串可以传入也可写在配置文件中等多种方法。

## 2、通过反射获取构造方法并使用： ##

student类：

1.  `package fanshe;`
2.   
3.  `public class Student {`
4.   
5.  `//---------------构造方法-------------------`
6.  `//（默认的构造方法）`
7.  `Student(String str){`
8.  `System.out.println("(默认)的构造方法 s = " + str);`
9.  `}`
10.  
11. `//无参构造方法`
12. `public Student(){`
13. `System.out.println("调用了公有、无参构造方法执行了。。。");`
14. `}`
15.  
16. `//有一个参数的构造方法`
17. `public Student(char name){`
18. `System.out.println("姓名：" + name);`
19. `}`
20.  
21. `//有多个参数的构造方法`
22. `public Student(String name ,int age){`
23. `System.out.println("姓名："+name+"年龄："+ age);//这的执行效率有问题，以后解决。`
24. `}`
25.  
26. `//受保护的构造方法`
27. `protected Student(boolean n){`
28. `System.out.println("受保护的构造方法 n = " + n);`
29. `}`
30.  
31. `//私有构造方法`
32. `private Student(int age){`
33. `System.out.println("私有的构造方法 年龄："+ age);`
34. `}`
35.  
36. `}`

共有6个构造方法；

测试类：

1.  `package fanshe;`
2.   
3.  `import java.lang.reflect.Constructor;`
4.   
5.   
6.  `/*`
7.  `* 通过Class对象可以获取某个类中的：构造方法、成员变量、成员方法；并访问成员；`
8.  `*`
9.  `* 1.获取构造方法：`
10. `* 1).批量的方法：`
11. `* public Constructor[] getConstructors()：所有"公有的"构造方法`
12. `public Constructor[] getDeclaredConstructors()：获取所有的构造方法(包括私有、受保护、默认、公有)`
13.  
14. `* 2).获取单个的方法，并调用：`
15. `* public Constructor getConstructor(Class... parameterTypes):获取单个的"公有的"构造方法：`
16. `* public Constructor getDeclaredConstructor(Class... parameterTypes):获取"某个构造方法"可以是私有的，或受保护、默认、公有；`
17. `*`
18. `* 调用构造方法：`
19. `* Constructor-->newInstance(Object... initargs)`
20. `*/`
21. `public class Constructors {`
22.  
23. `public static void main(String[] args) throws Exception {`
24. `//1.加载Class对象`
25. `Class clazz = Class.forName("fanshe.Student");`
26.  
27.  
28. `//2.获取所有公有构造方法`
29. `System.out.println("**********************所有公有构造方法*********************************");`
30. `Constructor[] conArray = clazz.getConstructors();`
31. `for(Constructor c : conArray){`
32. `System.out.println(c);`
33. `}`
34.  
35.  
36. `System.out.println("************所有的构造方法(包括：私有、受保护、默认、公有)***************");`
37. `conArray = clazz.getDeclaredConstructors();`
38. `for(Constructor c : conArray){`
39. `System.out.println(c);`
40. `}`
41.  
42. `System.out.println("*****************获取公有、无参的构造方法*******************************");`
43. `Constructor con = clazz.getConstructor(null);`
44. `//1>、因为是无参的构造方法所以类型是一个null,不写也可以：这里需要的是一个参数的类型，切记是类型`
45. `//2>、返回的是描述这个无参构造函数的类对象。`
46.  
47. `System.out.println("con = " + con);`
48. `//调用构造方法`
49. `Object obj = con.newInstance();`
50. `// System.out.println("obj = " + obj);`
51. `// Student stu = (Student)obj;`
52.  
53. `System.out.println("******************获取私有构造方法，并调用*******************************");`
54. `con = clazz.getDeclaredConstructor(char.class);`
55. `System.out.println(con);`
56. `//调用构造方法`
57. `con.setAccessible(true);//暴力访问(忽略掉访问修饰符)`
58. `obj = con.newInstance('男');`
59. `}`
60.  
61. `}`

后台输出：

1.  `**********************所有公有构造方法*********************************`
2.  `public fanshe.Student(java.lang.String,int)`
3.  `public fanshe.Student(char)`
4.  `public fanshe.Student()`
5.  `************所有的构造方法(包括：私有、受保护、默认、公有)***************`
6.  `private fanshe.Student(int)`
7.  `protected fanshe.Student(boolean)`
8.  `public fanshe.Student(java.lang.String,int)`
9.  `public fanshe.Student(char)`
10. `public fanshe.Student()`
11. `fanshe.Student(java.lang.String)`
12. `*****************获取公有、无参的构造方法*******************************`
13. `con = public fanshe.Student()`
14. `调用了公有、无参构造方法执行了。。。`
15. `******************获取私有构造方法，并调用*******************************`
16. `public fanshe.Student(char)`
17. `姓名：男`

**调用方法：**

1.获取构造方法：

1).批量的方法：  
public Constructor\[\] getConstructors()：所有"公有的"构造方法  
            public Constructor\[\] getDeclaredConstructors()：获取所有的构造方法(包括私有、受保护、默认、公有)  
       
  2).获取单个的方法，并调用：  
public Constructor getConstructor(Class... parameterTypes):获取单个的"公有的"构造方法：  
public Constructor getDeclaredConstructor(Class... parameterTypes):获取"某个构造方法"可以是私有的，或受保护、默认、公有；  
  
  调用构造方法：

Constructor-->newInstance(Object... initargs)

2、newInstance是 Constructor类的方法（管理构造函数的类）

api的解释为：

newInstance(Object... initargs)  
           使用此 `Constructor` 对象表示的构造方法来创建该构造方法的声明类的新实例，并用指定的初始化参数初始化该实例。

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

## 3、获取成员变量并调用 ##

student类：

1.  `package fanshe.field;`
2.   
3.  `public class Student {`
4.  `public Student(){`
5.   
6.  `}`
7.  `//**********字段*************//`
8.  `public String name;`
9.  `protected int age;`
10. `char sex;`
11. `private String phoneNum;`
12.  
13. `@Override`
14. `public String toString() {`
15. `return "Student [name=" + name + ", age=" + age + ", sex=" + sex`
16. `+ ", phoneNum=" + phoneNum + "]";`
17. `}`
18.  
19.  
20. `}`

测试类：

1.  `package fanshe.field;`
2.  `import java.lang.reflect.Field;`
3.  `/*`
4.  `* 获取成员变量并调用：`
5.  `*`
6.  `* 1.批量的`
7.  `* 1).Field[] getFields():获取所有的"公有字段"`
8.  `* 2).Field[] getDeclaredFields():获取所有字段，包括：私有、受保护、默认、公有；`
9.  `* 2.获取单个的：`
10. `* 1).public Field getField(String fieldName):获取某个"公有的"字段；`
11. `* 2).public Field getDeclaredField(String fieldName):获取某个字段(可以是私有的)`
12. `*`
13. `* 设置字段的值：`
14. `* Field --> public void set(Object obj,Object value):`
15. `* 参数说明：`
16. `* 1.obj:要设置的字段所在的对象；`
17. `* 2.value:要为字段设置的值；`
18. `*`
19. `*/`
20. `public class Fields {`
21.  
22. `public static void main(String[] args) throws Exception {`
23. `//1.获取Class对象`
24. `Class stuClass = Class.forName("fanshe.field.Student");`
25. `//2.获取字段`
26. `System.out.println("************获取所有公有的字段********************");`
27. `Field[] fieldArray = stuClass.getFields();`
28. `for(Field f : fieldArray){`
29. `System.out.println(f);`
30. `}`
31. `System.out.println("************获取所有的字段(包括私有、受保护、默认的)********************");`
32. `fieldArray = stuClass.getDeclaredFields();`
33. `for(Field f : fieldArray){`
34. `System.out.println(f);`
35. `}`
36. `System.out.println("*************获取公有字段**并调用***********************************");`
37. `Field f = stuClass.getField("name");`
38. `System.out.println(f);`
39. `//获取一个对象`
40. `Object obj = stuClass.getConstructor().newInstance();//产生Student对象--》Student stu = new Student();`
41. `//为字段设置值`
42. `f.set(obj, "刘德华");//为Student对象中的name属性赋值--》stu.name = "刘德华"`
43. `//验证`
44. `Student stu = (Student)obj;`
45. `System.out.println("验证姓名：" + stu.name);`
46.  
47.  
48. `System.out.println("**************获取私有字段****并调用********************************");`
49. `f = stuClass.getDeclaredField("phoneNum");`
50. `System.out.println(f);`
51. `f.setAccessible(true);//暴力反射，解除私有限定`
52. `f.set(obj, "18888889999");`
53. `System.out.println("验证电话：" + stu);`
54.  
55. `}`
56. `}`
57.

后台输出：

1.  `************获取所有公有的字段********************`
2.  `public java.lang.String fanshe.field.Student.name`
3.  `************获取所有的字段(包括私有、受保护、默认的)********************`
4.  `public java.lang.String fanshe.field.Student.name`
5.  `protected int fanshe.field.Student.age`
6.  `char fanshe.field.Student.sex`
7.  `private java.lang.String fanshe.field.Student.phoneNum`
8.  `*************获取公有字段**并调用***********************************`
9.  `public java.lang.String fanshe.field.Student.name`
10. `验证姓名：刘德华`
11. `**************获取私有字段****并调用********************************`
12. `private java.lang.String fanshe.field.Student.phoneNum`
13. `验证电话：Student [name=刘德华, age=0, sex=`

由此可见

调用字段时：需要传递两个参数：

Object obj = stuClass.getConstructor().newInstance();//产生Student对象--》Student stu = new Student();  
//为字段设置值  
f.set(obj, "刘德华");//为Student对象中的name属性赋值--》stu.name = "刘德华"

第一个参数：要传入设置的对象，第二个参数：要传入实参

## 4、获取成员方法并调用 ##

student类：

1.  `package fanshe.method;`
2.   
3.  `public class Student {`
4.  `//**************成员方法***************//`
5.  `public void show1(String s){`
6.  `System.out.println("调用了：公有的，String参数的show1(): s = " + s);`
7.  `}`
8.  `protected void show2(){`
9.  `System.out.println("调用了：受保护的，无参的show2()");`
10. `}`
11. `void show3(){`
12. `System.out.println("调用了：默认的，无参的show3()");`
13. `}`
14. `private String show4(int age){`
15. `System.out.println("调用了，私有的，并且有返回值的，int参数的show4(): age = " + age);`
16. `return "abcd";`
17. `}`
18. `}`
19.

测试类：

1.  `package fanshe.method;`
2.   
3.  `import java.lang.reflect.Method;`
4.   
5.  `/*`
6.  `* 获取成员方法并调用：`
7.  `*`
8.  `* 1.批量的：`
9.  `* public Method[] getMethods():获取所有"公有方法"；（包含了父类的方法也包含Object类）`
10. `* public Method[] getDeclaredMethods():获取所有的成员方法，包括私有的(不包括继承的)`
11. `* 2.获取单个的：`
12. `* public Method getMethod(String name,Class<?>... parameterTypes):`
13. `* 参数：`
14. `* name : 方法名；`
15. `* Class ... : 形参的Class类型对象`
16. `* public Method getDeclaredMethod(String name,Class<?>... parameterTypes)`
17. `*`
18. `* 调用方法：`
19. `* Method --> public Object invoke(Object obj,Object... args):`
20. `* 参数说明：`
21. `* obj : 要调用方法的对象；`
22. `* args:调用方式时所传递的实参；`
23.  
24. `):`
25. `*/`
26. `public class MethodClass {`
27.  
28. `public static void main(String[] args) throws Exception {`
29. `//1.获取Class对象`
30. `Class stuClass = Class.forName("fanshe.method.Student");`
31. `//2.获取所有公有方法`
32. `System.out.println("***************获取所有的”公有“方法*******************");`
33. `stuClass.getMethods();`
34. `Method[] methodArray = stuClass.getMethods();`
35. `for(Method m : methodArray){`
36. `System.out.println(m);`
37. `}`
38. `System.out.println("***************获取所有的方法，包括私有的*******************");`
39. `methodArray = stuClass.getDeclaredMethods();`
40. `for(Method m : methodArray){`
41. `System.out.println(m);`
42. `}`
43. `System.out.println("***************获取公有的show1()方法*******************");`
44. `Method m = stuClass.getMethod("show1", String.class);`
45. `System.out.println(m);`
46. `//实例化一个Student对象`
47. `Object obj = stuClass.getConstructor().newInstance();`
48. `m.invoke(obj, "刘德华");`
49.  
50. `System.out.println("***************获取私有的show4()方法******************");`
51. `m = stuClass.getDeclaredMethod("show4", int.class);`
52. `System.out.println(m);`
53. `m.setAccessible(true);//解除私有限定`
54. `Object result = m.invoke(obj, 20);//需要两个参数，一个是要调用的对象（获取有反射），一个是实参`
55. `System.out.println("返回值：" + result);`
56.  
57.  
58. `}`
59. `}`
60.

控制台输出：

1.  `***************获取所有的”公有“方法*******************`
2.  `public void fanshe.method.Student.show1(java.lang.String)`
3.  `public final void java.lang.Object.wait(long,int) throws java.lang.InterruptedException`
4.  `public final native void java.lang.Object.wait(long) throws java.lang.InterruptedException`
5.  `public final void java.lang.Object.wait() throws java.lang.InterruptedException`
6.  `public boolean java.lang.Object.equals(java.lang.Object)`
7.  `public java.lang.String java.lang.Object.toString()`
8.  `public native int java.lang.Object.hashCode()`
9.  `public final native java.lang.Class java.lang.Object.getClass()`
10. `public final native void java.lang.Object.notify()`
11. `public final native void java.lang.Object.notifyAll()`
12. `***************获取所有的方法，包括私有的*******************`
13. `public void fanshe.method.Student.show1(java.lang.String)`
14. `private java.lang.String fanshe.method.Student.show4(int)`
15. `protected void fanshe.method.Student.show2()`
16. `void fanshe.method.Student.show3()`
17. `***************获取公有的show1()方法*******************`
18. `public void fanshe.method.Student.show1(java.lang.String)`
19. `调用了：公有的，String参数的show1(): s = 刘德华`
20. `***************获取私有的show4()方法******************`
21. `private java.lang.String fanshe.method.Student.show4(int)`
22. `调用了，私有的，并且有返回值的，int参数的show4(): age = 20`
23. `返回值：abcd`

由此可见：

m = stuClass.getDeclaredMethod("show4", int.class);//调用制定方法（所有包括私有的），需要传入两个参数，第一个是调用的方法名称，第二个是方法的形参类型，切记是类型。  
System.out.println(m);  
m.setAccessible(true);//解除私有限定  
Object result = m.invoke(obj, 20);//需要两个参数，一个是要调用的对象（获取有反射），一个是实参  
System.out.println("返回值：" + result);//

控制台输出：

其实这里的成员方法：在模型中有属性一词，就是那些setter（）方法和getter()方法。还有字段组成，这些内容在内省中详解

## 5、反射main方法 ##

student类：

1.  `package fanshe.main;`
2.   
3.  `public class Student {`
4.   
5.  `public static void main(String[] args) {`
6.  `System.out.println("main方法执行了。。。");`
7.  `}`
8.  `}`
9.

测试类：

1.  `package fanshe.main;`
2.   
3.  `import java.lang.reflect.Method;`
4.   
5.  `/**`
6.  `* 获取Student类的main方法、不要与当前的main方法搞混了`
7.  `*/`
8.  `public class Main {`
9.   
10. `public static void main(String[] args) {`
11. `try {`
12. `//1、获取Student对象的字节码`
13. `Class clazz = Class.forName("fanshe.main.Student");`
14.  
15. `//2、获取main方法`
16. `Method methodMain = clazz.getMethod("main", String[].class);//第一个参数：方法名称，第二个参数：方法形参的类型，`
17. `//3、调用main方法`
18. `// methodMain.invoke(null, new String[]{"a","b","c"});`
19. `//第一个参数，对象类型，因为方法是static静态的，所以为null可以，第二个参数是String数组，这里要注意在jdk1.4时是数组，jdk1.5之后是可变参数`
20. `//这里拆的时候将 new String[]{"a","b","c"} 拆成3个对象。。。所以需要将它强转。`
21. `methodMain.invoke(null, (Object)new String[]{"a","b","c"});//方式一`
22. `// methodMain.invoke(null, new Object[]{new String[]{"a","b","c"}});//方式二`
23.  
24. `} catch (Exception e) {`
25. `e.printStackTrace();`
26. `}`
27.  
28.  
29. `}`
30. `}`
31.

控制台输出：

main方法执行了。。。

## 6、反射方法的其它使用之---通过反射运行配置文件内容 ##

student类：

1.  `public class Student {`
2.  `public void show(){`
3.  `System.out.println("is show()");`
4.  `}`
5.  `}`

配置文件以txt文件为例子（pro.txt）：

1.  `className = cn.fanshe.Student`
2.  `methodName = show`

测试类：

1.  `import java.io.FileNotFoundException;`
2.  `import java.io.FileReader;`
3.  `import java.io.IOException;`
4.  `import java.lang.reflect.Method;`
5.  `import java.util.Properties;`
6.   
7.  `/*`
8.  `* 我们利用反射和配置文件，可以使：应用程序更新时，对源码无需进行任何修改`
9.  `* 我们只需要将新类发送给客户端，并修改配置文件即可`
10. `*/`
11. `public class Demo {`
12. `public static void main(String[] args) throws Exception {`
13. `//通过反射获取Class对象`
14. `Class stuClass = Class.forName(getValue("className"));//"cn.fanshe.Student"`
15. `//2获取show()方法`
16. `Method m = stuClass.getMethod(getValue("methodName"));//show`
17. `//3.调用show()方法`
18. `m.invoke(stuClass.getConstructor().newInstance());`
19.  
20. `}`
21.  
22. `//此方法接收一个key，在配置文件中获取相应的value`
23. `public static String getValue(String key) throws IOException{`
24. `Properties pro = new Properties();//获取配置文件的对象`
25. `FileReader in = new FileReader("pro.txt");//获取输入流`
26. `pro.load(in);//将流加载到配置文件对象中`
27. `in.close();`
28. `return pro.getProperty(key);//返回根据key获取的value值`
29. `}`
30. `}`

控制台输出：

is show()

**需求：**  
当我们升级这个系统时，不要Student类，而需要新写一个Student2的类时，这时只需要更改pro.txt的文件内容就可以了。代码就一点不用改动

要替换的student2类：

1.  `public class Student2 {`
2.  `public void show2(){`
3.  `System.out.println("is show2()");`
4.  `}`
5.  `}`

配置文件更改为：

1.  `className = cn.fanshe.Student2`
2.  `methodName = show2`

控制台输出：

is show2();

## 7、反射方法的其它使用之---通过反射越过泛型检查 ##

泛型用在编译期，编译过后泛型擦除（消失掉）。所以是可以通过反射越过泛型检查的

测试类：

1.  `import java.lang.reflect.Method;`
2.  `import java.util.ArrayList;`
3.   
4.  `/*`
5.  `* 通过反射越过泛型检查`
6.  `*`
7.  `* 例如：有一个String泛型的集合，怎样能向这个集合中添加一个Integer类型的值？`
8.  `*/`
9.  `public class Demo {`
10. `public static void main(String[] args) throws Exception{`
11. `ArrayList<String> strList = new ArrayList<>();`
12. `strList.add("aaa");`
13. `strList.add("bbb");`
14.  
15. `// strList.add(100);`
16. `//获取ArrayList的Class对象，反向的调用add()方法，添加数据`
17. `Class listClass = strList.getClass(); //得到 strList 对象的字节码 对象`
18. `//获取add()方法`
19. `Method m = listClass.getMethod("add", Object.class);`
20. `//调用add()方法`
21. `m.invoke(strList, 100);`
22.  
23. `//遍历集合`
24. `for(Object obj : strList){`
25. `System.out.println(obj);`
26. `}`
27. `}`
28. `}`

控制台输出：

aaa  
bbb  
100

//反射就总结到这，下面的内省章节也和反射有关，可以算是反射的高级使用吧，如果有兴趣，可以继续查看总结的内省部分。

[20170513133210763]: /images/20220516/e52c0cab45df416aa54b84e2b48072c8.png
[20170513135521667]: /images/20220516/b4ea7f2c18f24278bbd654769e5ef8fc.png
[20170513144141409]: /images/20220516/ab4577eaf9944cac8c0ef8295154b5d1.png
[20170513145317647]: /images/20220516/b885227e8ef04ee09867662f8e17e6f3.png