1 package com.lzw;
 2
 3 public class Example_01 {
 4     String s;
 5     int i, i2, i3;
 6     private Example_01() {
 7     }
 8     protected Example_01(String s, int i) {
 9         this.s = s;
10         this.i = i;
11     }
12     public Example_01(String... strings) throws NumberFormatException {
13         if (0 < strings.length)
14             i = Integer.valueOf(strings[0]);
15         if (1 < strings.length)
16             i2 = Integer.valueOf(strings[1]);
17         if (2 < strings.length)
18             i3 = Integer.valueOf(strings[2]);
19     }
20     public void print() {
21         System.out.println("s=" + s);
22         System.out.println("i=" + i);
23         System.out.println("i2=" + i2);
24         System.out.println("i3=" + i3);
25     }
26 }

 1 package com.lzw;
 2
 3 import java.lang.reflect.*;
 4
 5 public class Main_01 {
 6
 7     public static void main(String[] args) {
 8
 9         Example_01 example = new Example_01("10", "20", "30");
10         Class<? extends Example_01> exampleC = example.getClass();
11
12         Constructor[] declaredConstructors = exampleC.getDeclaredConstructors();
13         for (int i = 0; i < declaredConstructors.length; i++) {
14             Constructor<?> constructor = declaredConstructors[i];
15             System.out.println("查看是否允许带有可变数量的参数：" + constructor.isVarArgs());
16             System.out.println("该构造方法的入口参数类型依次为：");
17             Class[] parameterTypes = constructor.getParameterTypes();
18             for (int j = 0; j < parameterTypes.length; j++) {
19                 System.out.println(" " + parameterTypes[j]);
20             }
21             System.out.println("该构造方法可能抛出的异常类型为：");
22             Class[] exceptionTypes = constructor.getExceptionTypes();
23             for (int j = 0; j < exceptionTypes.length; j++) {
24                 System.out.println(" " + exceptionTypes[j]);
25             }
26             Example_01 example2 = null;
27             while (example2 == null) {
28                 try {
29                     if (i == 2)
30                         example2 = (Example_01) constructor.newInstance();
31                     else if (i == 1)
32                         example2 = (Example_01) constructor.newInstance("7", 5);
33                     else {
34                         Object[] parameters = new Object[] { new String[] {
35                                 "100", "200", "300" } };
36                         example2 = (Example_01) constructor
37                                 .newInstance(parameters);
38                     }
39                 } catch (Exception e) {
40                     System.out.println("在创建对象时抛出异常，下面执行setAccessible()方法");
41                     constructor.setAccessible(true);
42                 }
43             }
44             if(example2!=null){
45             example2.print();
46             System.out.println();
47             }
48         }
49
50     }
51
52 }

1 public class Example_02 {
2     int i;
3     public float f;
4     protected boolean b;
5     private String s;
6 }

 1 import java.lang.reflect.*;
 2 public class Main_02 {
 3     public static void main(String[] args) {
 4         Example_02 example = new Example_02();
 5         Class exampleC = example.getClass();
 6         // 获得所有成员变量
 7         Field[] declaredFields = exampleC.getDeclaredFields();
 8         for (int i = 0; i < declaredFields.length; i++) {
 9             Field field = declaredFields[i]; // 遍历成员变量
10             // 获得成员变量名称
11             System.out.println("名称为：" + field.getName());
12             Class fieldType = field.getType(); // 获得成员变量类型
13             System.out.println("类型为：" + fieldType);
14             boolean isTurn = true;
15             while (isTurn) {
16                 // 如果该成员变量的访问权限为private，则抛出异常，即不允许访问
17                 try {
18                     isTurn = false;
19                     // 获得成员变量值
20                     System.out.println("修改前的值为：" + field.get(example));
21                     // 判断成员变量的类型是否为int型
22                     if (fieldType.equals(int.class)) {
23                         System.out.println("利用方法setInt()修改成员变量的值");
24                         field.setInt(example, 168); // 为int型成员变量赋值
25                         // 判断成员变量的类型是否为float型
26                     } else if (fieldType.equals(float.class)) {
27                         System.out.println("利用方法setFloat()修改成员变量的值");
28                         // 为float型成员变量赋值
29                         field.setFloat(example, 99.9F);
30                         // 判断成员变量的类型是否为boolean型
31                     } else if (fieldType.equals(boolean.class)) {
32                         System.out.println("利用方法setBoolean()修改成员变量的值");
33                         // 为boolean型成员变量赋值
34                         field.setBoolean(example, true);
35                     } else {
36                         System.out.println("利用方法set()修改成员变量的值");
37                         // 可以为各种类型的成员变量赋值
38                         field.set(example, "MWQ");
39                     }
40                     // 获得成员变量值
41                     System.out.println("修改后的值为：" + field.get(example));
42                 } catch (Exception e) {
43                     System.out.println("在设置成员变量值时抛出异常，"
44                             + "下面执行setAccessible()方法！");
45                     field.setAccessible(true); // 设置为允许访问
46                     isTurn = true;
47                 }
48             }
49             System.out.println();
50         }
51     }
52 }

 1 package com.lzw;
 2
 3 public class Example_03 {
 4     static void staticMethod() {
 5         System.out.println("执行staticMethod()方法");
 6     }
 7
 8     public int publicMethod(int i) {
 9         System.out.println("执行publicMethod()方法");
10         return i * 100;
11     }
12
13     protected int protectedMethod(String s, int i)
14             throws NumberFormatException {
15         System.out.println("执行protectedMethod()方法");
16         return Integer.valueOf(s) + i;
17     }
18
19     private String privateMethod(String... strings) {
20         System.out.println("执行privateMethod()方法");
21         StringBuffer stringBuffer = new StringBuffer();
22         for (int i = 0; i < strings.length; i++) {
23             stringBuffer.append(strings[i]);
24         }
25         return stringBuffer.toString();
26     }
27 }

 1 package com.lzw;
 2
 3 import java.lang.reflect.*;
 4
 5 public class Main_03 {
 6     public static void main(String[] args) {
 7         Example_03 example = new Example_03();
 8         Class exampleC = example.getClass();
 9
10         // 获得所有方法
11         Method[] declaredMethods = exampleC.getDeclaredMethods();
12         for (int i = 0; i < declaredMethods.length; i++) {
13             Method method = declaredMethods[i]; // 遍历方法
14             System.out.println("名称为：" + method.getName()); // 获得方法名称
15             System.out.println("是否允许带有可变数量的参数：" + method.isVarArgs());
16             System.out.println("入口参数类型依次为：");
17             // 获得所有参数类型
18             Class[] parameterTypes = method.getParameterTypes();
19             for (int j = 0; j < parameterTypes.length; j++) {
20                 System.out.println(" " + parameterTypes[j]);
21             }
22             // 获得方法返回值类型
23             System.out.println("返回值类型为：" + method.getReturnType());
24             System.out.println("可能抛出的异常类型有：");
25             // 获得方法可能抛出的所有异常类型
26             Class[] exceptionTypes = method.getExceptionTypes();
27             for (int j = 0; j < exceptionTypes.length; j++) {
28                 System.out.println(" " + exceptionTypes[j]);
29             }
30             boolean isTurn = true;
31             while (isTurn) {
32                 // 如果该方法的访问权限为private，则抛出异常，即不允许访问
33                 try {
34                     isTurn = false;
35                     if("staticMethod".equals(method.getName()))
36                         method.invoke(example); // 执行没有入口参数的方法
37                     else if("publicMethod".equals(method.getName()))
38                         System.out.println("返回值为："
39                                 + method.invoke(example, 168)); // 执行方法
40                     else if("protectedMethod".equals(method.getName()))
41                         System.out.println("返回值为："
42                                 + method.invoke(example, "7", 5)); // 执行方法
43                     else if("privateMethod".equals(method.getName())) {
44                         Object[] parameters = new Object[] { new String[] {
45                                 "M", "W", "Q" } }; // 定义二维数组
46                         System.out.println("返回值为："
47                                 + method.invoke(example, parameters));
48                     }
49                 } catch (Exception e) {
50                     System.out.println("在执行方法时抛出异常，"
51                             + "下面执行setAccessible()方法！");
52                     method.setAccessible(true); // 设置为允许访问
53                     isTurn = true;
54                 }
55             }
56             System.out.println();
57         }
58     }
59 }