java回调思想

1. public class Person implements ICompare {  
2.       
3.     private int age;  
4.     private float height;  
5.     private float weight;  
6.       
7.     public Person(int age, float height, float weight) {  
8.         super();  
9.         this.age = age;  
10.         this.height = height;  
11.         this.weight = weight;  
12.     }  
13.   
14.     public int getAge() {  
15.         return age;  
16.     }  
17.   
18.     public void setAge(int age) {  
19.         this.age = age;  
20.     }  
21.   
22.     public float getHeight() {  
23.         return height;  
24.     }  
25.   
26.     public void setHeight(float height) {  
27.         this.height = height;  
28.     }  
29.   
30.     public float getWeight() {  
31.         return weight;  
32.     }  
33.   
34.     public void setWeight(float weight) {  
35.         this.weight = weight;  
36.     }  
37.   
38.     @Override  
39.     public int comparable(ICompare obj) {  
40.         Person p = (Person)obj;  
41.         return this.age - p.age;  
42.     }  
43.   
44. }  

测试：

[java]  view plain copy print ?

1. public class CallBackTest {  
2.   
3.     public static void Sort(ICompare[] objs) {  
4.         int n = objs.length;  
5.         for(int i = 0; i < n-1; i ++) {  
6.             for(int j = 0; j < n-i-1; j ++) {  
7.                 if(objs[j].comparable(objs[j + 1]) > 0)  
8.                 {  
9.                     ICompare temp = objs[j];  
10.                     objs[j] = objs[j + 1];  
11.                     objs[j + 1] = temp;  
12.                 }  
13.             }  
14.         }  
15.     }  
16.       
17.     public static void showArray(Person persons[]){  
18.         for(int i = 0; i < persons.length; i ++) {  
19.             System.out.println("age:" + persons[i].getAge() + "  weight:" + persons[i].getWeight() + "  height:" + persons[i].getWeight());  
20.         }  
21.     }  
22.       
23.     /** 
24.      * @param args 
25.      */  
26.     public static void main(String[] args) {  
27.         Person[] persons = new Person[]{  
28.                 new Person(2, 54.5f, 0.82f),  
29.                 new Person(31, 74.5f, 1.80f),  
30.                 new Person(54, 44.5f, 1.59f),  
31.                 new Person(23, 62.0f, 1.78f),  
32.                 new Person(16, 45.7f, 1.60f)  
33.         };  
34.         System.out.println("before sort:");  
35.         showArray(persons);  
36.         Sort(persons);  
37.         System.out.println("after sort:");  
38.         showArray(persons);  
39.     }  
40.   
41. }  

java.util.Arrays中的Sort就用到了这种技术，从Java的API中可以看出：

public static void sort(Object[] a)

根据元素的自然顺序，对指定对象数组按升序进行排序。数组中的所有元素都必须实现 Comparable 接口。此外，数组中的所有元素都必须是可相互比较的（也就是说，对于数组中的任何 e1 和 e2 元素而言，e1.compareTo(e2) 不得抛出 ClassCastException）。

 

 

回调之编程思想

在软件模块调用中，主要有三种机制：同步调用，异步调用和回调。

同步调用是调用方（A）call被调用方（B）的接口，并等待B处理完给出一个回执后A才继续执行，这期间是“阻塞”的。

异步调用是调用方（A）call被调用方（B）的接口后，不等待B执行完，且B在被调用后会直接回执A。

回调是调用方（A）call被调用方（B）时，B也回调（callback）被调用方，双方互调接口，只不过call动作是由A发起的。

同步调用是最简单的，异步调用一般是在回调的基础上实现的。所以了解“回调”的机制是至关重要的。

 

我们再来看一个例子，用程序模拟“八仙过海，各显神通”。

 

[java]  view plain copy print ?

1. package callback;  
2.   
3. /** 
4.  * 接口 魔法(神通) 
5.  * @author luoweifu 
6.  * 
7.  */  
8. interface Magic {  
9.     public void doMagic();  
10. }  
11.   
12. /** 
13.  * 神仙类 
14.  * @author luoweifu 
15.  * 
16.  */  
17. class Immortal {  
18.     private String name;  
19.     private Magic magic;  
20.   
21.     public Immortal(String name) {  
22.         super();  
23.         this.name = name;  
24.     }  
25.   
26.     public Immortal(String name, Magic magic) {  
27.         super();  
28.         this.name = name;  
29.         this.magic = magic;  
30.     }  
31.   
32.     public void SetMagic(Magic magic) {  
33.         this.magic = magic;  
34.     }  
35.       
36.     public String getName() {  
37.         return name;  
38.     }  
39.   
40.     public void crossingSea(Magic magic) {  
41.         this.magic = magic;  
42.         System.out.print(name);  
43.         magic.doMagic();  
44.         System.out.println("过海...");  
45.     }  
46. }  
47.   
48. public class crossingSea {  
49.   
50.     /** 
51.      * 八仙过海，各显神通 
52.      * @param args 
53.      */  
54.     public static void main(String[] args) {  
55.         Immortal tieGuaiLi = new Immortal("铁拐李");  
56.         tieGuaiLi.crossingSea(new Magic() {  
57.             public void doMagic() {  
58.                 System.out.print("将葫芦变成条葫芦大船");  
59.             }  
60.         });  
61.           
62.         Immortal zhangGuoLao = new Immortal("张果老");  
63.         zhangGuoLao.crossingSea(new Magic() {  
64.             public void doMagic() {  
65.                 System.out.print("将毛驴变成一只小黑驴");  
66.             }  
67.         });  
68.           
69.         Immortal heXianGu = new Immortal("何仙姑");  
70.         heXianGu.crossingSea(new Magic() {  
71.             public void doMagic() {  
72.                 System.out.print("将荷叶往海面上一铺，躬身往上一跃，漂浮而去");  
73.             }  
74.         });  
75.           
76.         Immortal hanXiangzi = new Immortal("韩湘子");  
77.         hanXiangzi.crossingSea(new Magic() {  
78.             public void doMagic() {  
79.                 System.out.print("将玉箫往水中一掷，化作一根浮木，站在上面");  
80.             }  
81.         });  
82.           
83.         Immortal liDongBin = new Immortal("吕洞宾");  
84.         liDongBin.crossingSea(new Magic() {  
85.             public void doMagic() {  
86.                 System.out.print("把黄龙宝剑投入海中，宝剑化作一只小船载着他");  
87.             }  
88.         });  
89.           
90.         Immortal lanCaiHe = new Immortal("蓝采和");  
91.         lanCaiHe.crossingSea(new Magic() {  
92.             public void doMagic() {  
93.                 System.out.print("将百花篮变成五彩船悠哉游哉坐上彩船");  
94.             }  
95.         });  
96.           
97.         Immortal hanZhongLi = new Immortal("汉钟离");  
98.         hanZhongLi.crossingSea(new Magic() {  
99.             public void doMagic() {  
100.                 System.out.print("有一把芭蕉扇，他来了一个鲤鱼大翻 身，躺在扇子上悠闲自得地随波飘荡");  
101.             }  
102.         });  
103.           
104.         Immortal caoGuoJiu = new Immortal("曹国舅");  
105.         caoGuoJiu.crossingSea(new Magic() {  
106.             public void doMagic() {  
107.                 System.out.print("把阴阳玉板在海面上一字儿排开，犹如脚踏竹排迎激流穿巨浪");  
108.             }  
109.         });  
110.     }  
111.   
112. }  

结果如下：

铁拐李将葫芦变成条葫芦大船过海...
张果老将毛驴变成一只小黑驴过海...
何仙姑将荷叶往海面上一铺，躬身往上一跃，漂浮而去过海...
韩湘子将玉箫往水中一掷，化作一根浮木，站在上面过海...
吕洞宾把黄龙宝剑投入海中，宝剑化作一只小船载着他过海...
蓝采和将百花篮变成五彩船悠哉游哉坐上彩船过海...
汉钟离有一把芭蕉扇，他来了一个鲤鱼大翻 身，躺在扇子上悠闲自得地随波飘荡过海...

上面这个例子中Immortal是一个接口，doMagic就是你要实现的回调函数，传递了这个接口的对象也就传递了这个回调函数的实现，也就是实现了回调。

是不是很有趣？对，就是这么一个有有趣的例子，却淋漓尽致地表现了Java中回调的精髓，你可以反复地体会。上面这个例子在设计模式中也叫观察者模式，大家在别的地方看它的用法就不要再觉得陌生了哦！

 

恰当地使用回调，有以下的作用：

 

      避免重复代码 

      在你需要更多的通用功能的地方更好地实现抽象(可处理各种类型的对象和变量)。

      增强代码的可维护性

      增强代码的可读性

      有更多定制的功能