非常全面的讲解java反射

妖狐艹你老母 2022-05-25 04:30 181阅读 0赞

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

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

# 一、反射的概述 #

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

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

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

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

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

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

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

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

![20170513133210763][]

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

# 二、查看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][]

\[java\]  [view plain][]   [copy][view plain]

1. <span style="font-size:18px;">**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类：

\[java\]  [view plain][]   [copy][view plain]

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个构造方法；

测试类：

\[java\]  [view plain][]   [copy][view plain]

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. \}

后台输出：

\[java\]  [view plain][]   [copy][view plain]

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类：

\[java\]  [view plain][]   [copy][view plain]

1. <span style="font-size:14px;">**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. \}

测试类：

\[java\]  [view plain][]   [copy][view plain]

1. <span style="font-size:14px;">**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.     \}<span style="font-size:18px;">  
57.

后台输出：

\[java\]  [view plain][]   [copy][view plain]

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类：

\[java\]  [view plain][]   [copy][view plain]

1. <span style="font-size:14px;">**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.

测试类：

\[java\]  [view plain][]   [copy][view plain]

1. <span style="font-size:14px;">**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.

控制台输出：

\[java\]  [view plain][]   [copy][view plain]

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);//

控制台输出：

\[java\]  [view plain][]   [copy][view plain]

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

## 5、反射main方法 ##

student类：

\[java\]  [view plain][]   [copy][view plain]

1. <span style="font-size:14px;">**package** fanshe.main;  
2.   
3. **public** **class** Student \{  
4.   
5.     **public** **static** **void** main(String\[\] args) \{  
6.         System.out.println("main方法执行了。。。");  
7.     \}  
8. \}  
9.

测试类：

\[java\]  [view plain][]   [copy][view plain]

1. <span style="font-size:14px;">**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. \}<span style="font-size:18px;">  
31.

控制台输出：

main方法执行了。。。

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

student类：

\[java\]  [view plain][]   [copy][view plain]

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

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

\[java\]  [view plain][]   [copy][view plain]

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

测试类：

\[java\]  [view plain][]   [copy][view plain]

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类：

\[java\]  [view plain][]   [copy][view plain]

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

配置文件更改为：

\[java\]  [view plain][]   [copy][view plain]

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

控制台输出：

is show2();

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

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

测试类：

\[java\]  [view plain][]   [copy][view plain]

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/20220525/cc8e650827f74bb59fcb15266a92bd84.png
[20170513135521667]: /images/20220525/39379d2670514037a012a7bc9d6e55fa.png
[20170513144141409]: /images/20220525/80bc584629e649bab53e38d2bf5d35f3.png
[20170513145317647]: /images/20220525/c82dd57578244a47ade9434b66917cbb.png
[view plain]: https://blog.csdn.net/sinat_38259539/article/details/71799078#