編程思想之回調
《回調的原理、實現與應用》一文中已經初步講了回調的原理和應用，並就一個實際需求用函數的方式實現了回調應用。但回調並不僅限於回調函數，可以有很多不同的現實方式。回調與其說是一種技術，不如說是一種編程思想，我們在各種計算機語言中都能看到它的蹤影。我們以《回調的原理、實現與應用》一文中提到的需求爲例，看看C++、JavaScript、Java等各種語言下回調的實現方式。
有一Person類，有年齡(age),體重(weight),身高(height)三個屬性。現要對Person的一組對象進行排序，但並沒有確定根據什麼規則來排序，有時需要根據年齡進行排序，有時需要根據身高進行排序，有時可能是根據身高和體重的綜合情況來排序，還有可能……
JavaScript的實現
<script type="text/javascript">
//定義一個Person類
function Person(_age, _weight, _height)
{
this.age = _age;
this.weight = _weight;
this.height = _height;
}
//定義Person類的一個方法
Person.prototype.showInfo = function() {
document.write("age: " + this.age + " weight: " + this.weight + " heigt:" + this.height);
};
//persons爲Array數組
function sortPerson(persons, funcCompare)
{
var flag = false;
//判斷persons是否爲數組，判斷funcCompare是否爲回調 函數
flag = (persons instanceof Array) && (funcCompare instanceof Function);
if(flag)
{
var n = persons.length;
for(var i = 0; i < n-1; i ++)
{
for(var j = 0; j < n-i-1; j ++)
{
if(funcCompare(persons[j], persons[j+1]) > 0)
{
var temp = persons[j];
persons[j] = persons[j+1];
persons[j+1] = temp;
}
}
}
flag = true;
}
return flag;
}
//根據年齡比較兩個Person對象
function compareByAge(person1, person2)
{
return person1.age - person2.age;
}
//根據身高比較兩個Person對象
function compareByHeight(person1, person2)
{
return person1.height - person2.height;
}
//在頁面上顯示Person數組的信息
function showPersonArray(persons)
{
var size = persons.length;
for(i = 0; i < size; i ++)
{
persons[i].showInfo();
document.write("<br>");
}
}
</script>
調用：
<script type="text/javascript">
var persons = new Array();
persons[0] = new Person(2, 54.5, 0.82);
persons[1] = new Person(31, 74.5, 1.80);
persons[2] = new Person(54, 44.5, 1.59);
persons[3] = new Person(23, 62.0, 1.78);
persons[4] = new Person(16, 45.7, 1.60);
document.writeln("before sort:<br>");
showPersonArray(persons);
sortPerson(persons, compareByAge);
document.writeln("finished sort by age:<br>");
showPersonArray(persons);
sortPerson(persons, compareByHeight);
document.writeln("finished sort by Height:<br>");
showPersonArray(persons);
</script>
當然，你也可以在調用sortPerson的時候定義一個匿名的回調函數。一種更優雅的書寫方式如下：
//根據年齡排序
sortPerson(persons, function(person1, person2){
return person1.age - person2.age;
});
//根據身高排序
sortPerson(persons, function(person1, person2){
return person1.height - person2.height;
});
JavaScript中Array的sort方法應用的就是這個原理：
arrayObject.sort(sortby)
|
參數 |
描述 |
|
sortby |
可選。規定排序順序。必須是函數。 |
想更多地瞭解JavaScript中回調的實現和技術要點，請看下一章《理解和使用 JavaScript 中的回調函數》
Java的實現
Java中沒有像C++這樣的函數指針，所以不能將一個函數通過參數傳遞給另一個函數。因此Java中沒有回調函數，但仍然可以有回調的機制。Java是一種純面向對象的語言，它的回調可以通過面向對象的特性實現。
依然採用Person的例子，用Java實現回調。如下：
ICompare接口：
public interface ICompare {
public int comparable(ICompare obj);
}
Person類：
public class Person implements ICompare {
private int age;
private float height;
private float weight;
public Person(int age, float height, float weight) {
super();
this.age = age;
this.height = height;
this.weight = weight;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public float getHeight() {
return height;
}
public void setHeight(float height) {
this.height = height;
}
public float getWeight() {
return weight;
}
public void setWeight(float weight) {
this.weight = weight;
}
@Override
public int comparable(ICompare obj) {
Person p = (Person)obj;
return this.age - p.age;
}
}
測試：
public class CallBackTest {
public static void Sort(ICompare[] objs) {
int n = objs.length;
for(int i = 0; i < n-1; i ++) {
for(int j = 0; j < n-i-1; j ++) {
if(objs[j].comparable(objs[j + 1]) > 0)
{
ICompare temp = objs[j];
objs[j] = objs[j + 1];
objs[j + 1] = temp;
}
}
}
}
public static void showArray(Person persons[]){
for(int i = 0; i < persons.length; i ++) {
System.out.println("age:" + persons[i].getAge() + " weight:" + persons[i].getWeight() + " height:" + persons[i].getWeight());
}
}
/**
* @param args
*/
public static void main(String[] args) {
Person[] persons = new Person[]{
new Person(2, 54.5f, 0.82f),
new Person(31, 74.5f, 1.80f),
new Person(54, 44.5f, 1.59f),
new Person(23, 62.0f, 1.78f),
new Person(16, 45.7f, 1.60f)
};
System.out.println("before sort:");
showArray(persons);
Sort(persons);
System.out.println("after sort:");
showArray(persons);
}
}
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發起的。
同步調用是最簡單的，異步調用一般是在回調的基礎上實現的。所以瞭解“回調”的機制是至關重要的。
以“八仙過海”彰顯回調之精髓
我們再來看一個例子，用程序模擬“八仙過海，各顯神通”。
圖片來源：暱圖網
package callback;
/**
* 接口 魔法(神通)
* @author luoweifu
*
*/
interface Magic {
public void doMagic();
}
/**
* 神仙類
* @author luoweifu
*
*/
class Immortal {
private String name;
private Magic magic;
public Immortal(String name) {
super();
this.name = name;
}
public Immortal(String name, Magic magic) {
super();
this.name = name;
this.magic = magic;
}
public void SetMagic(Magic magic) {
this.magic = magic;
}
public String getName() {
return name;
}
public void crossingSea(Magic magic) {
this.magic = magic;
System.out.print(name);
magic.doMagic();
System.out.println("過海...");
}
}
public class crossingSea {
/**
* 八仙過海，各顯神通
* @param args
*/
public static void main(String[] args) {
Immortal tieGuaiLi = new Immortal("鐵柺李");
tieGuaiLi.crossingSea(new Magic() {
public void doMagic() {
System.out.print("將葫蘆變成條葫蘆大船");
}
});
Immortal zhangGuoLao = new Immortal("張果老");
zhangGuoLao.crossingSea(new Magic() {
public void doMagic() {
System.out.print("將毛驢變成一隻小黑驢");
}
});
Immortal heXianGu = new Immortal("何仙姑");
heXianGu.crossingSea(new Magic() {
public void doMagic() {
System.out.print("將荷葉往海面上一鋪，躬身往上一躍，漂浮而去");
}
});
Immortal hanXiangzi = new Immortal("韓湘子");
hanXiangzi.crossingSea(new Magic() {
public void doMagic() {
System.out.print("將玉簫往水中一擲，化作一根浮木，站在上面");
}
});
Immortal liDongBin = new Immortal("呂洞賓");
liDongBin.crossingSea(new Magic() {
public void doMagic() {
System.out.print("把黃龍寶劍投入海中，寶劍化作一隻小船載着他");
}
});
Immortal lanCaiHe = new Immortal("藍采和");
lanCaiHe.crossingSea(new Magic() {
public void doMagic() {
System.out.print("將百花籃變成五彩船悠哉遊哉坐上彩船");
}
});
Immortal hanZhongLi = new Immortal("漢鍾離");
hanZhongLi.crossingSea(new Magic() {
public void doMagic() {
System.out.print("有一把芭蕉扇，他來了一個鯉魚大翻 身，躺在扇子上悠閒自得地隨波飄蕩");
}
});
Immortal caoGuoJiu = new Immortal("曹國舅");
caoGuoJiu.crossingSea(new Magic() {
public void doMagic() {
System.out.print("把陰陽玉板在海面上一字兒排開，猶如腳踏竹排迎激流穿巨浪");
}
});
}
}
結果如下：
鐵柺李將葫蘆變成條葫蘆大船過海...
張果老將毛驢變成一隻小黑驢過海...
何仙姑將荷葉往海面上一鋪，躬身往上一躍，漂浮而去過海...
韓湘子將玉簫往水中一擲，化作一根浮木，站在上面過海...
呂洞賓把黃龍寶劍投入海中，寶劍化作一隻小船載着他過海...
藍采和將百花籃變成五彩船悠哉遊哉坐上彩船過海...
漢鍾離有一把芭蕉扇，他來了一個鯉魚大翻 身，躺在扇子上悠閒自得地隨波飄蕩過海...
在面向對象的語言中，回調則是通過接口或抽象類來實現的，我們把實現這種接口的類成爲回調類，回調類的對象成爲回調對象。對於像C++這樣的兼容了過程特性的對象語言，不僅提供了回調對象、回調方法等特性，也能兼容過程語言的回調函數機制。
上面這個例子中Immortal是一個接口，doMagic就是你要實現的回調方法，在調用crossingSea方法時實現的匿名的Magic類是稱爲回調類，Immortal中的private Magic magic;稱爲回調對象。傳遞了這個接口的對象也就傳遞了這個回調函數的實現，也就是實現了回調。
是不是很有趣？對，就是這麼一個有有趣的例子，卻淋漓盡致地表現了Java中回調的精髓，你可以反覆地體會。上面這個例子在設計模式中也叫策略模式，大家在別的地方看它的用法就不要再覺得陌生了哦！
恰當地使用回調，有以下的作用：
避免重複代碼
在你需要更多的通用功能的地方更好地實現抽象(可處理各種類型的對象和變量)。
增強代碼的可維護性
增強代碼的可讀性
有更多定製的功能