Java反射在类中的应用：通过反射访问构造函数（方法）

缺乏、安全感 2021-12-17 16:39 291阅读 0赞

为了能够**动态获取**对象构造方法的信息，首先需要通过下列方法之一创建一个 `Constructor` 类型的对象或者数组。

*  getConstructors()
 *  getConstructor(Class<?>…parameterTypes)
 *  getDeclaredConstructors()
 *  getDeclaredConstructor(Class<?>...parameterTypes)

如果是访问指定的构造方法，需要根据该构造方法的入口参数的类型来访问。例如，访问一个入口参数类型依次为 int 和 String 类型的构造方法，下面的两种方式均可以实现。

1.  objectClass.getDeclaredConstructor(int.class,String.class);
2.  objectClass.getDeclaredConstructor(new Class\[\]\{int.class,String.class\});

创建的每个 Constructor 对象表示一个构造方法，然后利用 Constructor 对象的方法操作构造方法。Constructor 类的常用方法如表 1 所示。

<table>  表1 Constructor类的常用方法  
 <tbody> 
  <tr> 
   <th>方法名称</th> 
   <th>说明</th> 
  </tr> 
  <tr> 
   <td>isVarArgs()</td> 
   <td>查看该构造方法是否允许带可变数量的参数，如果允许，返回 true，否则返回<br> false</td> 
  </tr> 
  <tr> 
   <td>getParameterTypes()</td> 
   <td>按照声明顺序以 Class 数组的形式获取该构造方法各个参数的类型</td> 
  </tr> 
  <tr> 
   <td>getExceptionTypes()</td> 
   <td>以 Class 数组的形式获取该构造方法可能抛出的异常类型</td> 
  </tr> 
  <tr> 
   <td>newInstance(Object … initargs)</td> 
   <td>通过该构造方法利用指定参数创建一个该类型的对象，如果未设置参数则表示<br> 采用默认无参的构造方法</td> 
  </tr> 
  <tr> 
   <td>setAccessiable(boolean flag)</td> 
   <td>如果该构造方法的权限为 private，默认为不允许通过反射利用&nbsp;netlnstance()<br> 方法创建对象。如果先执行该方法，并将入口参数设置为&nbsp;true，则允许创建对<br> 象</td> 
  </tr> 
  <tr> 
   <td>getModifiers()</td> 
   <td>获得可以解析出该构造方法所采用修饰符的整数</td> 
  </tr> 
 </tbody> 
</table>

通过 java.lang.reflect.Modifier 类可以解析出 getMocMers() 方法的返回值所表示的修饰符信息。在该类中提供了一系列用来解析的静态方法，既可以查看是否被指定的修饰符修饰，还可以字符串的形式获得所有修饰符。表 2 列出了 Modifier 类的常用静态方法。

<table>  表2 Modifier类的常用方法  
 <tbody> 
  <tr> 
   <th>静态方法名称</th> 
   <th colspan="2">说明</th> 
  </tr> 
  <tr> 
   <td>isStatic(int mod)</td> 
   <td colspan="2">如果使用 static 修饰符修饰则返回 true，否则返回 false</td> 
  </tr> 
  <tr> 
   <td>isPublic(int mod)</td> 
   <td colspan="2">如果使用 public 修饰符修饰则返回 true，否则返回 false</td> 
  </tr> 
  <tr> 
   <td>isProtected(int mod)</td> 
   <td colspan="2">如果使用 protected 修饰符修饰则返回 true，否则返回 false</td> 
  </tr> 
  <tr> 
   <td>isPrivate(int mod)</td> 
   <td colspan="2">如果使用 private 修饰符修饰则返回 true，否则返回 false</td> 
  </tr> 
  <tr> 
   <td>isFinal(int mod)</td> 
   <td colspan="2">如果使用 final 修饰符修饰则返回 true，否则返回 false</td> 
  </tr> 
  <tr> 
   <td>toString(int mod)</td> 
   <td colspan="2">以字符串形式返回所有修饰符</td> 
  </tr> 
 </tbody> 
</table>

例如，下列代码判断对象 con 所代表的构造方法是否被 public 修饰，以及以字符串形式获取该构造方法的所有修饰符。

1.  int modifiers=con.getModifiers(); //获取构造方法的修饰符整数
2.  boolean isPubiic=Modifier.isPublic(modifiers); //判断修饰符整数是否为
3.  public string ailModifSers=Modifier.toString(modifiers);

例 1

下面通过一个案例来演示如何调用 Constructor 类的方法获取构造方法的信息。  
  
(1) 首先创建一个 Book 类表示图书信息。在该类中声明一个 String 型变量表示图书名称，两个 int 型变量分别表示图书编号和价格，并提供 3 个构造方法。  
  
Book 类的最终代码如下：

1.  public class Book
2.  \{
3.  String name; //图书名称
4.  int id,price; //图书编号和价格
5.  //空的构造方法
6.  private Book()\{\}
7.  //带两个参数的构造方法
8.  protected Book(String \_name,int \_id)
9.  \{
10. this.name=\_name;
11. this.id=\_id;
12. \}
13. //带可变参数的构造方法
14. public Book(String...strings)throws NumberFormatException
15. \{
16. if(0<strings.length)
17. id=Integer.valueOf(strings\[0\]);
18. if(1<strings.length)
19. price=Integer.valueOf(strings\[1\]);
20. \}
21. //输出图书信息
22. public void print()
23. \{
24. System.out.println("name="+name);
25. System.out.println("id="+id);
26. System.out.println("price="+price);
27. \}
28. \}

(2) 编写测试类 Test01，在该类的 main() 方法中通过反射访问 Book 类中的所有构造方法，并将该构造方法是否带可变类型参数、入口参数类型和可能拋出的异常类型信息输出到控制台。  
  
Test01 类的代码如下：

1.  import java.lang.reflect.Constructor;
2.  public class Test01
3.  \{
4.  public static void main(String\[\] args)
5.  \{
6.  //获取动态类Book
7.  Class book=Book.class;
8.  //获取Book类的所有构造方法
9.  Constructor\[\] declaredContructors=book.getDeclaredConstructors();
10. //遍历所有构造方法
11. for(int i=0;i<declaredContructors.length;i++)
12. \{
13. Constructor con=declaredContructors\[i\];
14. //判断构造方法的参数是否可变
15. System.out.println("查看是否允许带可变数量的参数："+con.isVarArgs());
16. System.out.println("该构造方法的入口参数类型依次为：");
17. //获取所有参数类型
18. Class\[\] parameterTypes=con.getParameterTypes();
19. for(int j=0;j<parameterTypes.length;j++)
20. \{
21. System.out.println(" "+parameterTypes\[j\]);
22. \}
23. System.out.println("该构造方法可能拋出的异常类型为：");
24. //获取所有可能拋出的异常类型
25. Class\[\] exceptionTypes=con.getExceptionTypes();
26. for(int j=0;j<exceptionTypes.length;j++)
27. \{
28. System.out.println(" "+parameterTypes\[j\]);
29. \}
30. //创建一个未实例化的Book类实例
31. Book book1=null;
32. while(book1==null)
33. \{
34. try
35. \{ //如果该成员变量的访问权限为private，则拋出异常
36. if(i==1)
37. \{
38. //通过执行带两个参数的构造方法实例化book1
39. book1=(Book)con.newInstance("[Java][] 教程",10);
40. \}
41. else if(i==2)
42. \{
43. //通过执行默认构造方法实例化book1
44. book1=(Book)con.newInstance();
45. \}
46. else
47. \{
48. //通过执行可变数量参数的构造方法实例化book1
49. Object\[\] parameters=new Object\[\]\{new String\[\]\{"100","200"\}\};
50. book1=(Book)con.newInstance(parameters);
51. \}
52. \}
53. catch(Exception e)
54. \{
55. System.out.println("在创建对象时拋出异常，下面执行 setAccessible() 方法");
56. con.setAccessible(true); //设置允许访问 private 成员
57. \}
58. \}
59. book1.print();
60. System.out.println("=============================\\n");
61. \}
62. \}
63. \}

(3) 运行测试类 Test01，当通过反射访问默认构造方法 Book() 时，将看到如下所示的输出。

查看是否允许带可变数量的参数：false
    该构造方法的入口参数类型依次为：
    该构造方法可能抛出的异常类型为：
    在创建对象时抛出异常，下面执行setAccessible()方法
    name=null
    id=0
    price=0
    =============================

当通过反射访问两个参数的构造方法 Book(String\_name,int\_id) 时，将看到如下所示的输出。

查看是否允许带可变数量的参数：false
    该构造方法的入口参数类型依次为：
    class java.lang.String
    int
    该构造方法可能抛出的异常类型为：
    在创建对象时抛出异常，下面执行setAccessible()方法
    name=null
    id=0
    price=0
    =============================

当通过反射访问可变参数数量的构造方法 Book(String...strings) 时，将看到如下所示的输出。

查看是否允许带可变数量的参数：true
    该构造方法的入口参数类型依次为：
    class java.lang.String;
    该构造方法可能抛出的异常类型为：
    class java.lang.String;
    在创建对象时抛出异常，下面执行setAccessible()方法
    name=null
    id=0
    price=0
    =============================

[Java]: http://c.biancheng.net/java/