1 mport java.lang.reflect.Constructor;
2 import java.lang.reflect.Method;
3
4
5 public class CallMethod {
6
7 public static void main(String[] args) throws Exception {
8 // 获取TestClass的Class对象
9 Class testClass = Class.forName(TestClass.class.getName());
10
11
12 // （1）使用Class对象的newInstance方法创建一个实例，这种方法用默认构造方法创建对象
13 TestClass objectA = (TestClass) testClass.newInstance();
14 System.out.println("Class的newInstance() 方法创建默认TestClass实例: "
15 + objectA.toString());
16 // （2）使用构造方法创建实例。这就可以使用带参数的构造方法创建实例了
17 Constructor[] cons = testClass.getDeclaredConstructors();
18 System.out.println("testClass有 " + cons.length + " 个构造方法");
19 Constructor con = null;
20 for (int i = 0; i < cons.length; i++) {
21 con = cons[i];
22 // 默认构造函数
23 if (con.getParameterTypes().length == 0) {
24 // 调用Constructor的newInstance方法创建实例
25 objectA = (TestClass) con.newInstance(null);
26 System.out
27 .println("Constructor 的 newInstance() 方法创建默认TestClass实例: "
28 + objectA.toString());
29 } else {
30 // 带参数的构造函数
31 objectA = (TestClass) con.newInstance(new Object[] {
32 new Integer(55), new Integer(88) });
33 System.out
34 .println("Constructor 的 newInstance() 方法创建带参数的TestClass实例: "
35 + objectA.toString());
36 }
37 }
38
39
40 // 获取所有方法
41 Method[] methods = testClass.getMethods();
42 // 获取某个特定的无参数的方法
43 Method saddMethod1 = testClass.getMethod("sadd", null);
44 Method addMethod1 = testClass.getMethod("add", null);
45 // 获取某个特定的有参数的方法
46 Method saddMethod2 = testClass.getMethod("sadd", new Class[] {
47 int.class, int.class });
48 Method addMethod2 = testClass.getMethod("add", new Class[] { int.class,
49 int.class });
50
51
52 // 调用不带参数的静态方法
53 int result = ((Integer) saddMethod1.invoke(null, null)).intValue();
54 System.out.println("调用不带参数的静态方法sadd: " + result);
55 // 调用带参数的静态方法
56 result = ((Integer) saddMethod2.invoke(null, new Object[] {
57 new Integer(30), new Integer(70) })).intValue();
58 System.out.println("调用带参数30, 70的静态方法sadd: " + result);
59
60
61 objectA = (TestClass) testClass.newInstance();
62 // 调用不带参数的实例方法
63 result = ((Integer) addMethod1.invoke(objectA, null)).intValue();
64 System.out.println("调用不带参数的实例方法add: " + result);
65 // 调用带参数的实例方法
66 result = ((Integer) addMethod2.invoke(objectA, new Object[] {
67 new Integer(130), new Integer(170) })).intValue();
68 System.out.println("调用带参数130, 170的实例方法add: " + result);
69
70 // 不能访问私有方法
71 // Method sub = testClass.getMethod("sub", null);
72 // System.out.println(sub.invoke(objectA, null));
73 }
74
75 // 测试类
76 class TestClass {
77 // 两个静态属性
78 static int sa = 100;
79 static int sb = 50;
80 // 两个实例属性
81 int a;
82 int b;
83 // 默认构造方法
84 public TestClass() {
85 this.a = 5;
86 this.b = 10;
87 }
88 // 带参数的构造方法
89 public TestClass(int a, int b) {
90 this.a = a;
91 this.b = b;
92 }
93
94 // 静态方法，实现add功能
95 public static int sadd() {
96 return sa + sb;
97 }
98 public static int sadd(int a, int b) {
99 return a + b;
100 }
101 // 实例方法，实现add功能
102 public int add() {
103 return this.a + this.b;
104 }
105 public int add(int a, int b) {
106 return a + b;
107 }
108 public String toString() {
109 return "a = " + this.a + "; b = " + this.b;
110 }
111 // 私有方法
112 private int sub() {
113 return this.a - this.b;
114 }
115 }
116 }
