回調的原理實現與應用

轉自：http://blog.csdn.net/luoweifu/article/details/41465289

《回調的原理、實現與應用》一文中已經初步講了回調的原理和應用，並就一個實際需求用函數的方式實現了回調應用。但回調並不僅限於回調函數，可以有很多不同的現實方式。回調與其說是一種技術，不如說是一種編程思想，我們在各種計算機語言中都能看到它的蹤影。我們以《回調的原理、實現與應用》一文中提到的需求爲例，看看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("把陰陽玉板在海面上一字兒排開，猶如腳踏竹排迎激流穿巨浪");
            }
        });
    }

}

結果如下：

鐵柺李將葫蘆變成條葫蘆大船過海...
張果老將毛驢變成一隻小黑驢過海...
何仙姑將荷葉往海面上一鋪，躬身往上一躍，漂浮而去過海...
韓湘子將玉簫往水中一擲，化作一根浮木，站在上面過海...
呂洞賓把黃龍寶劍投入海中，寶劍化作一隻小船載着他過海...
藍采和將百花籃變成五彩船悠哉遊哉坐上彩船過海...
漢鍾離有一把芭蕉扇，他來了一個鯉魚大翻 身，躺在扇子上悠閒自得地隨波飄蕩過海...

是不是很有趣？對，就是這麼一個有有趣的例子，卻淋漓盡致地表現了Java中回調的精髓，你可以反覆地體會。上面這個例子在設計模式中也叫觀察者模式，大家在別的地方看它的用法就不要再覺得陌生了哦！

 

恰當地使用回調，有以下的作用：

 

      避免重複代碼 

      在你需要更多的通用功能的地方更好地實現抽象(可處理各種類型的對象和變量)。

      增強代碼的可維護性

      增強代碼的可讀性

      有更多定製的功能