编程思想之回调

原文:http://blog.csdn.net/luoweifu/article/details/41465289

 

回调的原理、实现与应用》一文中已经初步讲了回调的原理和应用,并就一个实际需求用函数的方式实现了回调应用。但回调并不仅限于回调函数,可以有很多不同的现实方式。回调与其说是一种技术,不如说是一种编程思想,我们在各种计算机语言中都能看到它的踪影。我们以《回调的原理、实现与应用》一文中提到的需求为例,看看C++、JavaScript、Java等各种语言下回调的实现方式。

有一Person类,有年龄(age),体重(weight),身高(height)三个属性。现要对Person的一组对象进行排序,但并没有确定根据什么规则来排序,有时需要根据年龄进行排序,有时需要根据身高进行排序,有时可能是根据身高和体重的综合情况来排序,还有可能……

 

JavaScript的实现

 

[javascript] view plaincopyprint?在CODE上查看代码片派生到我的代码片
 
  1. <script type="text/javascript">  
  2.           
  3.         //定义一个Person类  
  4.         function Person(_age, _weight, _height)  
  5.         {  
  6.             this.age = _age;  
  7.             this.weight = _weight;  
  8.             this.height = _height;  
  9.         }  
  10.           
  11.         //定义Person类的一个方法  
  12.         Person.prototype.showInfo = function() {  
  13.           document.write("age: " + this.age + "  weight: " + this.weight + "  heigt:" + this.height);  
  14.         };  
  15.           
  16.         //persons为Array数组  
  17.         function sortPerson(persons, funcCompare)  
  18.         {  
  19.             var flag = false;  
  20.             //判断persons是否为数组,判断funcCompare是否为回调 函数  
  21.             flag = (persons instanceof Array) && (funcCompare instanceof Function);  
  22.             if(flag)  
  23.             {  
  24.                 var n = persons.length;  
  25.                 for(var i = 0; i < n-1; i ++)  
  26.                 {  
  27.                     for(var j = 0; j < n-i-1; j ++)  
  28.                     {  
  29.                         if(funcCompare(persons[j], persons[j+1]) > 0)  
  30.                         {  
  31.                             var temp = persons[j];  
  32.                             persons[j] = persons[j+1];  
  33.                             persons[j+1] = temp;  
  34.                         }  
  35.                     }  
  36.                 }  
  37.                 flag = true;  
  38.             }  
  39.             return flag;  
  40.         }  
  41.   
  42.         //根据年龄比较两个Person对象  
  43.         function compareByAge(person1, person2)  
  44.         {  
  45.             return person1.age - person2.age;  
  46.         }  
  47.   
  48.         //根据身高比较两个Person对象  
  49.         function compareByHeight(person1, person2)  
  50.         {  
  51.             return person1.height - person2.height;  
  52.         }  
  53.           
  54.         //在页面上显示Person数组的信息  
  55.         function showPersonArray(persons)  
  56.         {  
  57.             var size = persons.length;  
  58.             for(i = 0; i < size; i ++)  
  59.             {  
  60.                 persons[i].showInfo();  
  61.                 document.write("<br>");  
  62.             }  
  63.         }  
  64.           
  65.     </script>  


 

 

调用:

 

[javascript] view plaincopyprint?在CODE上查看代码片派生到我的代码片
 
  1. <script type="text/javascript">  
  2.     var persons = new Array();  
  3.     persons[0] = new Person(2, 54.5, 0.82);  
  4.     persons[1] = new Person(31, 74.5, 1.80);  
  5.     persons[2] = new Person(54, 44.5, 1.59);  
  6.     persons[3] = new Person(23, 62.0, 1.78);  
  7.     persons[4] = new Person(16, 45.7, 1.60);  
  8.     document.writeln("before sort:<br>");  
  9.     showPersonArray(persons);  
  10.     sortPerson(persons, compareByAge);  
  11.     document.writeln("finished sort by age:<br>");  
  12.     showPersonArray(persons);  
  13.     sortPerson(persons, compareByHeight);  
  14.     document.writeln("finished sort by Height:<br>");  
  15.     showPersonArray(persons);  
  16. </script>  


 

 

当然,你也可以在调用sortPerson的时候定义一个匿名的回调函数。一种更优雅的书写方式如下:

 

  1. //根据年龄排序  
  2. sortPerson(persons, function(person1, person2){  
  3.     return person1.age - person2.age;  
  4. });  
  5. //根据身高排序  
  6. sortPerson(persons, function(person1, person2){  
  7.     return person1.height - person2.height;  
  8. });  


 

 

JavaScript中Array的sort方法应用的就是这个原理:

arrayObject.sort(sortby)

参数

描述

sortby

可选。规定排序顺序。必须是函数。

 

想更多地了解JavaScript中回调的实现和技术要点,请看下一章《理解和使用 JavaScript 中的回调函数

 

 

Java的实现

Java中没有像C++这样的函数指针,所以不能将一个函数通过参数传递给另一个函数。因此Java中没有回调函数,但仍然可以有回调的机制。Java是一种纯面向对象的语言,它的回调可以通过面向对象的特性实现。

依然采用Person的例子,用Java实现回调。如下:

 ICompare接口:

 

  1. public interface ICompare {  
  2.     public int comparable(ICompare obj);  
  3. }  

 

 

Person类:

 

  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. }  


测试:

 

 

  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发起的。

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

 

以“八仙过海”彰显回调之精髓

 

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

 

图片来源:昵图网

 

  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. }  

 

 

结果如下:

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

 

在面向对象的语言中,回调则是通过接口或抽象类来实现的,我们把实现这种接口的类成为回调类,回调类的对象成为回调对象。对于像C++这样的兼容了过程特性的对象语言,不仅提供了回调对象、回调方法等特性,也能兼容过程语言的回调函数机制。

上面这个例子中Immortal是一个接口,doMagic就是你要实现的回调方法,在调用crossingSea方法时实现的匿名的Magic类是称为回调类,Immortal中的private Magic magic;称为回调对象。传递了这个接口的对象也就传递了这个回调函数的实现,也就是实现了回调。

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

 

恰当地使用回调,有以下的作用:

 

      避免重复代码 

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

      增强代码的可维护性

      增强代码的可读性

      有更多定制的功能

posted @ 2015-01-07 22:59  思维与睿智  阅读(955)  评论(0编辑  收藏  举报