java 之 反射
反射是个什么东西，就是探测一个类或者接口等等这些东西的内部构造，比如知道某个类都有什么构造方法，或者有什么成员变量（你没有他们的源代码）。
也可以在程序运行时，动态的改变程序内部结构，而不是编译时。
1 import java.lang.reflect.Constructor;
2 import java.lang.reflect.Field;
3 import java.lang.reflect.Method;
4
5 public class Test {
6 static int step = 0;
7
8 // 只要这个类被加载，就会执行一下静态内容，不管你有没有创建实例！
9 static {
10 System.out.println(++step + ":Test的static内容");
11 }
12
13 public Test() {
14 System.out.println(++step + ":Test的构造方法");
15 }
16
17 /**
18 * @param args
19 * @throws ClassNotFoundException
20 */
21 public static void main(String[] args) throws ClassNotFoundException {
22 // TODO Auto-generated method stub
23 System.out.println(++step + ":main的第一行");
24
25 Test test = new Test();
26
27 // 首先看怎样使用反射，Class类
28 Class<?> c1;
29
30 // 两种方法获得Class对象
31 // 第一种方法，已经有了这种类的对象，那么通过getClass即可获得
32 c1 = (test.new Lexus("凌志")).getClass(); // 对于实例化一个内部类的匿名对象，使用它上层类的实例.new就行了
33
34 System.out.println();
35 System.out.println("类名:" + c1.getName());
36
37 // 获取内部所有有属性
38 Field[] fs = c1.getFields();
39 System.out.println("\t+属性:");
40 for (Field f : fs) {
41 System.out.println("\t-" + f.toGenericString());
42 }
43
44 // 获取私有的字段
45 fs = c1.getDeclaredFields();
46 System.out.println("\t+私有属性:");
47 for (Field f : fs) {
48 System.out.println("\t-" + f.toGenericString());
49 }
50
51 // 获取构造方法
52 Constructor[] cts = c1.getConstructors();
53 System.out.println("\t+构造方法:");
54 for (Constructor c : cts) {
55 System.out.println("\t-" + c.toGenericString());
56 }
57
58 // 获取所有方法
59 Method[] mds = c1.getMethods();
60 System.out.println("\t+方法:");
61 for (Method m : mds) {
62 System.out.println("\t-" + m.toGenericString());
63 }
64
65 // 获取超类
66 Class su = c1.getSuperclass();
67 System.out.println();
68 System.out.println("类名:" + su.getName());
69 // 获取内部所有非私有属性
70 fs = c1.getFields();
71
72 for (Field f : fs) {
73 System.out.println("\t-" + f.toGenericString());
74 }
75
76 // ------------------------------------------//
77 // 第二种方法获取class;
78 c1 = Class.forName("Test$Lexus"); // 内部类，不不是用.表示，而是用美元表示！
79 System.out.println("\n" + c1.getName());
80
81 }
82
83 // 机动车抽象内部类
84 public abstract class Auto {
85 public String name;
86
87 public void setName(String name) {
88 this.name = name;
89 }
90
91 public Auto(String name) {
92 setName(name);
93 }
94
95 // 启动
96 public abstract void start();
97
98 // 熄火
99 public abstract void stop();
100
101 @Override
102 public String toString() {
103 return name;
104
105 }
106
107 }
108
109 // 内部接口，特技车辆
110 public interface Sport {
111 // 特技驾驶
112 public void specialRun(String run);
113 }
114
115 // 一辆原厂Lexus，继承于机动车Auto
116 public class Lexus extends Auto {
117 private String nothing = "nothing";
118
119 public Lexus(String name) {
120 super(name);
121 }
122
123 @Override
124 public void start() {
125 // TODO Auto-generated method stub
126 System.out.println("->发动");
127
128 }
129
130 @Override
131 public void stop() {
132 // TODO Auto-generated method stub
133 System.out.println("->熄火");
134 }
135
136 }
137
138 // 运动版
139 public class LexusSport extends Lexus implements Sport {
140
141 public LexusSport(String name) {
142 super(name);
143 // TODO Auto-generated constructor stub
144 }
145
146 // 特种驾驶
147 @Override
148 public void specialRun(String run) {
149 // TODO Auto-generated method stub
150 System.out.println("->" + run);
151 }
152
153 }
154
155 }
2 import java.lang.reflect.Field;
3 import java.lang.reflect.Method;
4
5 public class Test {
6 static int step = 0;
7
8 // 只要这个类被加载，就会执行一下静态内容，不管你有没有创建实例！
9 static {
10 System.out.println(++step + ":Test的static内容");
11 }
12
13 public Test() {
14 System.out.println(++step + ":Test的构造方法");
15 }
16
17 /**
18 * @param args
19 * @throws ClassNotFoundException
20 */
21 public static void main(String[] args) throws ClassNotFoundException {
22 // TODO Auto-generated method stub
23 System.out.println(++step + ":main的第一行");
24
25 Test test = new Test();
26
27 // 首先看怎样使用反射，Class类
28 Class<?> c1;
29
30 // 两种方法获得Class对象
31 // 第一种方法，已经有了这种类的对象，那么通过getClass即可获得
32 c1 = (test.new Lexus("凌志")).getClass(); // 对于实例化一个内部类的匿名对象，使用它上层类的实例.new就行了
33
34 System.out.println();
35 System.out.println("类名:" + c1.getName());
36
37 // 获取内部所有有属性
38 Field[] fs = c1.getFields();
39 System.out.println("\t+属性:");
40 for (Field f : fs) {
41 System.out.println("\t-" + f.toGenericString());
42 }
43
44 // 获取私有的字段
45 fs = c1.getDeclaredFields();
46 System.out.println("\t+私有属性:");
47 for (Field f : fs) {
48 System.out.println("\t-" + f.toGenericString());
49 }
50
51 // 获取构造方法
52 Constructor[] cts = c1.getConstructors();
53 System.out.println("\t+构造方法:");
54 for (Constructor c : cts) {
55 System.out.println("\t-" + c.toGenericString());
56 }
57
58 // 获取所有方法
59 Method[] mds = c1.getMethods();
60 System.out.println("\t+方法:");
61 for (Method m : mds) {
62 System.out.println("\t-" + m.toGenericString());
63 }
64
65 // 获取超类
66 Class su = c1.getSuperclass();
67 System.out.println();
68 System.out.println("类名:" + su.getName());
69 // 获取内部所有非私有属性
70 fs = c1.getFields();
71
72 for (Field f : fs) {
73 System.out.println("\t-" + f.toGenericString());
74 }
75
76 // ------------------------------------------//
77 // 第二种方法获取class;
78 c1 = Class.forName("Test$Lexus"); // 内部类，不不是用.表示，而是用美元表示！
79 System.out.println("\n" + c1.getName());
80
81 }
82
83 // 机动车抽象内部类
84 public abstract class Auto {
85 public String name;
86
87 public void setName(String name) {
88 this.name = name;
89 }
90
91 public Auto(String name) {
92 setName(name);
93 }
94
95 // 启动
96 public abstract void start();
97
98 // 熄火
99 public abstract void stop();
100
101 @Override
102 public String toString() {
103 return name;
104
105 }
106
107 }
108
109 // 内部接口，特技车辆
110 public interface Sport {
111 // 特技驾驶
112 public void specialRun(String run);
113 }
114
115 // 一辆原厂Lexus，继承于机动车Auto
116 public class Lexus extends Auto {
117 private String nothing = "nothing";
118
119 public Lexus(String name) {
120 super(name);
121 }
122
123 @Override
124 public void start() {
125 // TODO Auto-generated method stub
126 System.out.println("->发动");
127
128 }
129
130 @Override
131 public void stop() {
132 // TODO Auto-generated method stub
133 System.out.println("->熄火");
134 }
135
136 }
137
138 // 运动版
139 public class LexusSport extends Lexus implements Sport {
140
141 public LexusSport(String name) {
142 super(name);
143 // TODO Auto-generated constructor stub
144 }
145
146 // 特种驾驶
147 @Override
148 public void specialRun(String run) {
149 // TODO Auto-generated method stub
150 System.out.println("->" + run);
151 }
152
153 }
154
155 }
返回：
1:Test的static内容 //首先，main是在Test类中，Test类被加载到内存中，并初始化，但还没有被实例化
2:main的第一行 //开始运行了
3:Test的构造方法 //这时，Test才被创建一个实例
类名:Test$Lexus
+属性:
-public java.lang.String Test$Auto.name
+私有属性:
-private java.lang.String Test$Lexus.nothing
-final Test Test$Lexus.this$0
+构造方法:
-public Test$Lexus(Test,java.lang.String)
+方法:
-public void Test$Lexus.start()
-public void Test$Lexus.stop()
-public java.lang.String Test$Auto.toString()
-public void Test$Auto.setName(java.lang.String)
-public final native void java.lang.Object.wait(long) throws java.lang.InterruptedException
-public final void java.lang.Object.wait() throws java.lang.InterruptedException
-public final void java.lang.Object.wait(long,int) throws java.lang.InterruptedException
-public boolean java.lang.Object.equals(java.lang.Object)
-public native int java.lang.Object.hashCode()
-public final native java.lang.Class<?> java.lang.Object.getClass()
-public final native void java.lang.Object.notify()
-public final native void java.lang.Object.notifyAll()
类名:Test$Auto
-public java.lang.String Test$Auto.name
Test$Lexus //这是使用Class的静态方法获得的class对象，注意的是，如果是包含关系用的是美元$，而不是dot.
2:main的第一行 //开始运行了
3:Test的构造方法 //这时，Test才被创建一个实例
类名:Test$Lexus
+属性:
-public java.lang.String Test$Auto.name
+私有属性:
-private java.lang.String Test$Lexus.nothing
-final Test Test$Lexus.this$0
+构造方法:
-public Test$Lexus(Test,java.lang.String)
+方法:
-public void Test$Lexus.start()
-public void Test$Lexus.stop()
-public java.lang.String Test$Auto.toString()
-public void Test$Auto.setName(java.lang.String)
-public final native void java.lang.Object.wait(long) throws java.lang.InterruptedException
-public final void java.lang.Object.wait() throws java.lang.InterruptedException
-public final void java.lang.Object.wait(long,int) throws java.lang.InterruptedException
-public boolean java.lang.Object.equals(java.lang.Object)
-public native int java.lang.Object.hashCode()
-public final native java.lang.Class<?> java.lang.Object.getClass()
-public final native void java.lang.Object.notify()
-public final native void java.lang.Object.notifyAll()
类名:Test$Auto
-public java.lang.String Test$Auto.name
Test$Lexus //这是使用Class的静态方法获得的class对象，注意的是，如果是包含关系用的是美元$，而不是dot.
上面的示例，说明如何探查一个类的面目，下面我们知道了要探查类的内部结构，就开始去做一些有意义的事了什么是有意义的事？我们探查一个类，不只是看看这么简单吧。。。。
1 import java.lang.reflect.Constructor;
2 import java.lang.reflect.Field;
3 import java.lang.reflect.InvocationTargetException;
4 import java.lang.reflect.Method;
5
6 public class Test {
7 static int step = 0;
8
9 public Test() {
10 System.out.println("Test的构造方法被调用");
11 }
12
13 /**
14 * @param args
15 * @throws ClassNotFoundException
16 * @throws NoSuchFieldException
17 * @throws SecurityException
18 * @throws IllegalAccessException
19 * @throws IllegalArgumentException
20 * @throws NoSuchMethodException
21 * @throws InvocationTargetException
22 */
23 public static void main(String[] args) throws ClassNotFoundException, SecurityException, NoSuchFieldException, IllegalArgumentException, IllegalAccessException, NoSuchMethodException, InvocationTargetException {
24 // TODO Auto-generated method stub
25 Test.LexusSport ls=new Test().new LexusSport("凌志超级运动版");
26 System.out.println();
27 //获取实例ls的Class
28 Class<?> lc=ls.getClass();
29 System.out.println(lc.toString());
30
31 //获取字段名为name的字段
32 Field f=lc.getField("name");
33 //获取Test.LexusSport的实例ls的字段值
34 System.out.println(f.toGenericString()+":"+f.get(ls));
35
36 //我们现在通过对象改变一下字段值
37 ls.setName("运动版");
38 System.out.println("通过对象改变值："+ls);
39 System.out.println(f.toGenericString()+":"+f.get(ls));
40
41 //现在通过反射，来改变字段的值
42 f.set(ls, "凌志");
43 System.out.println("通过反射改变值："+ls);
44 System.out.println(f.toGenericString()+":"+f.get(ls));
45
46
47 //下面我们来通过反射执行方法
48 Method m=lc.getMethod("setName", String.class); //第二参数是可变参数
49 System.out.println("\n\n"+m.toGenericString());
50
51 //通过反射调用这个方法
52 m.invoke(ls, "汽车");
53 System.out.println("通过反射调用方法："+ls);
54 System.out.println(f.toGenericString()+":"+f.get(ls));
55 }
56
57 // 机动车抽象内部类
58 public abstract class Auto {
59 public String name;
60
61 public void setName(String name) {
62 this.name = name;
63 }
64
65 public Auto(String name) {
66 System.out.println("Auto的构造方法被调用");
67 setName(name);
68 }
69
70 // 启动
71 public abstract void start();
72
73 // 熄火
74 public abstract void stop();
75
76 @Override
77 public String toString() {
78 return name;
79
80 }
81
82 }
83
84 // 内部接口，特技车辆
85 public interface Sport {
86 // 特技驾驶
87 public void specialRun(String run);
88 }
89
90 // 一辆原厂Lexus，继承于机动车Auto
91 public class Lexus extends Auto {
92 private String nothing = "nothing";
93
94 public Lexus(String name) {
95 super(name);
96 System.out.println("Lexus的构造方法被调用");
97
98 }
99
100 @Override
101 public void start() {
102 // TODO Auto-generated method stub
103 System.out.println("->发动");
104
105 }
106
107 @Override
108 public void stop() {
109 // TODO Auto-generated method stub
110 System.out.println("->熄火");
111 }
112
113 }
114
115 // 运动版
116 public class LexusSport extends Lexus implements Sport {
117
118 public LexusSport(String name) {
119 super(name);
120 System.out.println("LexusSport的构造方法被调用");
121
122 // TODO Auto-generated constructor stub
123 }
124
125 // 特种驾驶
126 @Override
127 public void specialRun(String run) {
128 // TODO Auto-generated method stub
129 System.out.println("->" + run);
130 }
131
132 }
133
134 }
2 import java.lang.reflect.Field;
3 import java.lang.reflect.InvocationTargetException;
4 import java.lang.reflect.Method;
5
6 public class Test {
7 static int step = 0;
8
9 public Test() {
10 System.out.println("Test的构造方法被调用");
11 }
12
13 /**
14 * @param args
15 * @throws ClassNotFoundException
16 * @throws NoSuchFieldException
17 * @throws SecurityException
18 * @throws IllegalAccessException
19 * @throws IllegalArgumentException
20 * @throws NoSuchMethodException
21 * @throws InvocationTargetException
22 */
23 public static void main(String[] args) throws ClassNotFoundException, SecurityException, NoSuchFieldException, IllegalArgumentException, IllegalAccessException, NoSuchMethodException, InvocationTargetException {
24 // TODO Auto-generated method stub
25 Test.LexusSport ls=new Test().new LexusSport("凌志超级运动版");
26 System.out.println();
27 //获取实例ls的Class
28 Class<?> lc=ls.getClass();
29 System.out.println(lc.toString());
30
31 //获取字段名为name的字段
32 Field f=lc.getField("name");
33 //获取Test.LexusSport的实例ls的字段值
34 System.out.println(f.toGenericString()+":"+f.get(ls));
35
36 //我们现在通过对象改变一下字段值
37 ls.setName("运动版");
38 System.out.println("通过对象改变值："+ls);
39 System.out.println(f.toGenericString()+":"+f.get(ls));
40
41 //现在通过反射，来改变字段的值
42 f.set(ls, "凌志");
43 System.out.println("通过反射改变值："+ls);
44 System.out.println(f.toGenericString()+":"+f.get(ls));
45
46
47 //下面我们来通过反射执行方法
48 Method m=lc.getMethod("setName", String.class); //第二参数是可变参数
49 System.out.println("\n\n"+m.toGenericString());
50
51 //通过反射调用这个方法
52 m.invoke(ls, "汽车");
53 System.out.println("通过反射调用方法："+ls);
54 System.out.println(f.toGenericString()+":"+f.get(ls));
55 }
56
57 // 机动车抽象内部类
58 public abstract class Auto {
59 public String name;
60
61 public void setName(String name) {
62 this.name = name;
63 }
64
65 public Auto(String name) {
66 System.out.println("Auto的构造方法被调用");
67 setName(name);
68 }
69
70 // 启动
71 public abstract void start();
72
73 // 熄火
74 public abstract void stop();
75
76 @Override
77 public String toString() {
78 return name;
79
80 }
81
82 }
83
84 // 内部接口，特技车辆
85 public interface Sport {
86 // 特技驾驶
87 public void specialRun(String run);
88 }
89
90 // 一辆原厂Lexus，继承于机动车Auto
91 public class Lexus extends Auto {
92 private String nothing = "nothing";
93
94 public Lexus(String name) {
95 super(name);
96 System.out.println("Lexus的构造方法被调用");
97
98 }
99
100 @Override
101 public void start() {
102 // TODO Auto-generated method stub
103 System.out.println("->发动");
104
105 }
106
107 @Override
108 public void stop() {
109 // TODO Auto-generated method stub
110 System.out.println("->熄火");
111 }
112
113 }
114
115 // 运动版
116 public class LexusSport extends Lexus implements Sport {
117
118 public LexusSport(String name) {
119 super(name);
120 System.out.println("LexusSport的构造方法被调用");
121
122 // TODO Auto-generated constructor stub
123 }
124
125 // 特种驾驶
126 @Override
127 public void specialRun(String run) {
128 // TODO Auto-generated method stub
129 System.out.println("->" + run);
130 }
131
132 }
133
134 }
返回：
Test的构造方法被调用
Auto的构造方法被调用
Lexus的构造方法被调用
LexusSport的构造方法被调用
//这里顺便了解到，每个对象是从基类开始初始化的
class Test$LexusSport
public java.lang.String Test$Auto.name:凌志超级运动版
通过对象改变值：运动版
public java.lang.String Test$Auto.name:运动版
通过反射改变值：凌志
public java.lang.String Test$Auto.name:凌志
public void Test$Auto.setName(java.lang.String)
通过反射调用方法：汽车
public java.lang.String Test$Auto.name:汽车
Auto的构造方法被调用
Lexus的构造方法被调用
LexusSport的构造方法被调用
//这里顺便了解到，每个对象是从基类开始初始化的
class Test$LexusSport
public java.lang.String Test$Auto.name:凌志超级运动版
通过对象改变值：运动版
public java.lang.String Test$Auto.name:运动版
通过反射改变值：凌志
public java.lang.String Test$Auto.name:凌志
public void Test$Auto.setName(java.lang.String)
通过反射调用方法：汽车
public java.lang.String Test$Auto.name:汽车
调用构造方法，就不写了，也就是Class的这个方法调用了构造方法后，返回的是一个新建了的对象的引用，也就是句柄，和new 一个对象效果一样。
现在，我们窥探了Class反射，用在什么地方呢？？
很多回答是框架，怎么回事呢？
网上的回答都弱爆了。我的拙见：
框架就好像一套智能建筑物的框架，承重的框架当然给你提供好了，你给里面砌墙装潢去，想怎么折腾怎么折腾。那么和反射有什么呢？
比如，有一个框架，你往里面砌一堵墙，你的墙名字（类名）是“碳纤维墙”，你这样告诉他“我在一层的最左边砌一堵碳纤维墙”，他就会为你找碳纤维，并把这堵墙放到你期望的位置，他如何实现呢？首先分析你的话语，他必须要找到碳纤维并做成墙，翻译成基本的java语言，就是“new CarbonWall”，java没有提供根据字符串来判断类名，然后new的语句吧，这就需要用到映射了，Class.forName("CarbonWall")，然后调用构造函数。。。。。。。。然后。。。然后。。。。。
现在，就恍然大悟了，原来每个大楼框架的对面都有一面很大的镜子，框架无法看清自己每个楼层的东西，因为他的头在最上面啊，刚好java提供了这面镜子让框架能看清自己，就是反射了。
除了框架，还有些应用，看代码：
1 import java.lang.reflect.Constructor;
2 import java.lang.reflect.Field;
3 import java.lang.reflect.InvocationTargetException;
4 import java.lang.reflect.Method;
5 import java.lang.reflect.Type;
6 import java.util.List;
7
8 public class Test {
9 static int step = 0;
10
11
12 /**
13 * @param args
14 * @throws ClassNotFoundException
15 * @throws NoSuchFieldException
16 * @throws SecurityException
17 * @throws IllegalAccessException
18 * @throws IllegalArgumentException
19 * @throws NoSuchMethodException
20 * @throws InvocationTargetException
21 */
22 public static void main(String[] args) throws ClassNotFoundException, SecurityException, NoSuchFieldException, IllegalArgumentException, IllegalAccessException, NoSuchMethodException, InvocationTargetException {
23 // TODO Auto-generated method stub
24 //现在要举行汽车运动会，一大堆车报名参加
25 Test.LexusSport car1=new Test().new LexusSport("凌志超级运动版 1");
26 Test.LexusSport car2=new Test().new LexusSport("凌志超级运动版 2");
27 Test.Lexus car3=new Test().new Lexus("凌志 3");
28 Test.Moto car4=new Test().new Moto("哈雷4");
29
30 //现在所有车辆进入竞技场
31 Auto[] arena=new Auto[4];
32 arena[0]=car1;
33 arena[1]=car2;
34 arena[2]=car3;
35 arena[3]=car4;
36
37
38
39
40 //一声令下
41 System.out.println("开始：");
42 for(int i=0;i<arena.length;i++){
43 arena[i].start();
44 }
45 System.out.println("\n\n");
46
47 //现在开始表演特技，两轮着地
48
49 //问题出来了，Lexus没有实现sport接口，它不可能两轮着地
50 //而moto摩托两轮着地无意义，他本来就是两个轮子着地
51 //但是，现在命令全场的车都两轮着地，每个类都实现一个方法来判断能否两轮着地吗？
52 //上面复杂了，这时，反射上场！
53 for(int i=0;i<arena.length;i++){
54 //获取所有的实现的接口的数组
55 Type[] ts=arena[i].getClass().getGenericInterfaces();
56 for(Type t:ts){
57 //遍历已经实现的接口，倘若有Sport的接口，则通过反射调用specialRun方法
58 if(t.toString().equals("interface Test$Sport")){
59 arena[i].getClass().getMethod("specialRun", String.class).invoke(arena[i], "两轮着地！");
60 break;
61 }
62 }
63
64 }
65
66 //好了，比赛结束！
67 System.out.println("\n\n");
68 for(int i=0;i<arena.length;i++){
69 arena[i].stop();
70 }
71
72
73 }
74
75 // 机动车抽象内部类
76 public abstract class Auto {
77 public String name;
78
79 public void setName(String name) {
80 this.name = name;
81 }
82
83 public Auto(String name) {
84 setName(name);
85 }
86
87 // 启动
88 public abstract void start();
89
90 // 熄火
91 public abstract void stop();
92
93 @Override
94 public String toString() {
95 return name;
96
97 }
98
99 }
100
101 // 内部接口，特技车辆
102 public interface Sport {
103 // 特技驾驶
104 public void specialRun(String run);
105 }
106
107 // 一辆原厂Lexus，继承于机动车Auto
108 public class Lexus extends Auto {
109
110 public Lexus(String name) {
111 super(name);
112
113 }
114
115 @Override
116 public void start() {
117 // TODO Auto-generated method stub
118 System.out.println(this+"->用钥匙发动");
119
120 }
121
122 @Override
123 public void stop() {
124 // TODO Auto-generated method stub
125 System.out.println(this+"->熄火");
126 }
127
128 }
129
130 // 运动版
131 public class LexusSport extends Lexus implements Sport {
132
133 public LexusSport(String name) {
134 super(name);
135
136 // TODO Auto-generated constructor stub
137 }
138
139 // 特种驾驶
140 @Override
141 public void specialRun(String run) {
142 // TODO Auto-generated method stub
143 System.out.println(this+"->" + run);
144 }
145
146 }
147
148 //摩托车
149 public class Moto extends Auto{
150
151 public Moto(String name) {
152 super(name);
153 // TODO Auto-generated constructor stub
154 }
155
156
157 @Override
158 public void start() {
159 // TODO Auto-generated method stub
160 System.out.println(this+"->用脚发动");
161 }
162
163 @Override
164 public void stop() {
165 // TODO Auto-generated method stub
166 System.out.println(this+"->熄火");
167 }
168
169 }
170
171 }
2 import java.lang.reflect.Field;
3 import java.lang.reflect.InvocationTargetException;
4 import java.lang.reflect.Method;
5 import java.lang.reflect.Type;
6 import java.util.List;
7
8 public class Test {
9 static int step = 0;
10
11
12 /**
13 * @param args
14 * @throws ClassNotFoundException
15 * @throws NoSuchFieldException
16 * @throws SecurityException
17 * @throws IllegalAccessException
18 * @throws IllegalArgumentException
19 * @throws NoSuchMethodException
20 * @throws InvocationTargetException
21 */
22 public static void main(String[] args) throws ClassNotFoundException, SecurityException, NoSuchFieldException, IllegalArgumentException, IllegalAccessException, NoSuchMethodException, InvocationTargetException {
23 // TODO Auto-generated method stub
24 //现在要举行汽车运动会，一大堆车报名参加
25 Test.LexusSport car1=new Test().new LexusSport("凌志超级运动版 1");
26 Test.LexusSport car2=new Test().new LexusSport("凌志超级运动版 2");
27 Test.Lexus car3=new Test().new Lexus("凌志 3");
28 Test.Moto car4=new Test().new Moto("哈雷4");
29
30 //现在所有车辆进入竞技场
31 Auto[] arena=new Auto[4];
32 arena[0]=car1;
33 arena[1]=car2;
34 arena[2]=car3;
35 arena[3]=car4;
36
37
38
39
40 //一声令下
41 System.out.println("开始：");
42 for(int i=0;i<arena.length;i++){
43 arena[i].start();
44 }
45 System.out.println("\n\n");
46
47 //现在开始表演特技，两轮着地
48
49 //问题出来了，Lexus没有实现sport接口，它不可能两轮着地
50 //而moto摩托两轮着地无意义，他本来就是两个轮子着地
51 //但是，现在命令全场的车都两轮着地，每个类都实现一个方法来判断能否两轮着地吗？
52 //上面复杂了，这时，反射上场！
53 for(int i=0;i<arena.length;i++){
54 //获取所有的实现的接口的数组
55 Type[] ts=arena[i].getClass().getGenericInterfaces();
56 for(Type t:ts){
57 //遍历已经实现的接口，倘若有Sport的接口，则通过反射调用specialRun方法
58 if(t.toString().equals("interface Test$Sport")){
59 arena[i].getClass().getMethod("specialRun", String.class).invoke(arena[i], "两轮着地！");
60 break;
61 }
62 }
63
64 }
65
66 //好了，比赛结束！
67 System.out.println("\n\n");
68 for(int i=0;i<arena.length;i++){
69 arena[i].stop();
70 }
71
72
73 }
74
75 // 机动车抽象内部类
76 public abstract class Auto {
77 public String name;
78
79 public void setName(String name) {
80 this.name = name;
81 }
82
83 public Auto(String name) {
84 setName(name);
85 }
86
87 // 启动
88 public abstract void start();
89
90 // 熄火
91 public abstract void stop();
92
93 @Override
94 public String toString() {
95 return name;
96
97 }
98
99 }
100
101 // 内部接口，特技车辆
102 public interface Sport {
103 // 特技驾驶
104 public void specialRun(String run);
105 }
106
107 // 一辆原厂Lexus，继承于机动车Auto
108 public class Lexus extends Auto {
109
110 public Lexus(String name) {
111 super(name);
112
113 }
114
115 @Override
116 public void start() {
117 // TODO Auto-generated method stub
118 System.out.println(this+"->用钥匙发动");
119
120 }
121
122 @Override
123 public void stop() {
124 // TODO Auto-generated method stub
125 System.out.println(this+"->熄火");
126 }
127
128 }
129
130 // 运动版
131 public class LexusSport extends Lexus implements Sport {
132
133 public LexusSport(String name) {
134 super(name);
135
136 // TODO Auto-generated constructor stub
137 }
138
139 // 特种驾驶
140 @Override
141 public void specialRun(String run) {
142 // TODO Auto-generated method stub
143 System.out.println(this+"->" + run);
144 }
145
146 }
147
148 //摩托车
149 public class Moto extends Auto{
150
151 public Moto(String name) {
152 super(name);
153 // TODO Auto-generated constructor stub
154 }
155
156
157 @Override
158 public void start() {
159 // TODO Auto-generated method stub
160 System.out.println(this+"->用脚发动");
161 }
162
163 @Override
164 public void stop() {
165 // TODO Auto-generated method stub
166 System.out.println(this+"->熄火");
167 }
168
169 }
170
171 }
返回：
开始：
凌志超级运动版 1->用钥匙发动
凌志超级运动版 2->用钥匙发动
凌志 3->用钥匙发动
哈雷4->用脚发动
凌志超级运动版 1->两轮着地！
凌志超级运动版 2->两轮着地！
//摩托车不用强调，显而易见的，两轮
凌志超级运动版 1->熄火
凌志超级运动版 2->熄火
凌志 3->熄火
哈雷4->熄火
凌志超级运动版 1->用钥匙发动
凌志超级运动版 2->用钥匙发动
凌志 3->用钥匙发动
哈雷4->用脚发动
凌志超级运动版 1->两轮着地！
凌志超级运动版 2->两轮着地！
//摩托车不用强调，显而易见的，两轮
凌志超级运动版 1->熄火
凌志超级运动版 2->熄火
凌志 3->熄火
哈雷4->熄火
这个例子是什么设计模式？
在《Thingking in Java 4th》中的例子是，是画布，意思是，在画布上有多个图形，现在要旋转每个图像，三角形四方形等实现了旋转接口，圆形旋转没有意义，难道要让圆形也实现旋转接口么？不用，用反射就行了。和上面基本差不多。
