爲何會有Comparable與Comparator接口? 引入策略模式

引入

• 你們先考慮一個場景, 有一個整形數組, 咱們但願經過調用一個工具類的排序方法就能對該數組進行排序. 請看下面的代碼:

public class Strategy {
    public static void main(String[] args) {
        int[] arr = {5, 3, 1, 7, 2};
        new DataSorter().sort(arr);//調用工具類進行排序
        for(int i = 0; i < arr.length; i++){
            System.out.println(arr[i]);
        }
    }
}

class DataSorter{//用於排序的工具類
    public void sort(int[] arr){//調用sort方法進行排序, 此處使用冒泡排序
        for(int i = arr.length - 1; i > 0; i--){
            for(int j = 0; j < i; j++){
                if(arr[j] > arr[j + 1])
                    swap(arr, j, j  + 1);
            }
        }
    }

    private void swap(int[] arr, int i, int j){
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }
}
複製代碼

 

Comparable接口的前因後果

• 經過上面的代碼, 咱們可以輕易地對整形數組進行排序, 那麼若是如今有了新需求, 須要對浮點類型數據進行排序, 排序工具類應該如何作呢?
• 或許你會想, 不如就新添加一個排序方法, 方法的參數類型爲float類型, 把int類型數組的排序算法複製一遍不就能夠了嗎?
• 那若是我繼續追問, 若是如今要對一隻貓進行排序, 那應該怎麼作呢? 貓的類以下

class Cat{
    private int age;//貓的年齡
    private int weight;//貓的體重

    //get / set 方法...
}
複製代碼

• 你也許會順着原來的思路回答, 照樣copy一份排序的算法, 修改方法參數, 而後在比較的地方指定比較貓的年齡或體重不就能夠了嗎?

public void sort(Cat[] arr){//以貓數組做爲參數
    for(int i = arr.length - 1; i > 0; i--){
        for(int j = 0; j < i; j++){
            if(arr[j].getAge() > arr[j + 1].getAge())//根據貓的年齡做比較
                swap(arr, j, j  + 1);
        }
    }
}
複製代碼

• 但仔細想一想, 若是還要繼續比較小狗, 小雞, 小鴨等各類對象, 那麼這個排序工具類的代碼量豈不是變得很大? 爲了能讓排序算法的可重用性高一點, 咱們但願排序工具中的sort()方法能夠對任何調用它的對象進行排序.
• 你可能會想: 到對任何對象都能排序, 把sort()方法的參數改成Object類型不久能夠了嘛. 這個方向是對的, 可是問題是, 當拿到兩個Object類型對象, 應該根據什麼規則進行比較呢?
• 這個時候咱們天然而然地就但願調用工具類進行排序的對象自己就具有本身的比較法則, 這樣在排序的時候就能直接調用對象的排序法則進行排序了.
• 咱們把比較法則抽象爲Comparable接口, 凡是要進行比較的類都要實現Comparable接口, 而且定義本身的比較法則, 也就是CompareTo()方法.
• 這樣當咱們在封裝工具時, 就能夠直接對實現了Comparable接口的對象進行比較, 不用擔憂比較的細節了.

public class Strategy {
public class Strategy {
    public static void main(String[] args) {
// Integer[] arr = {5, 3, 1, 7, 2};//注意這裏把int改成Integer, Integer是Object的子類
        Cat[] arr = {new Cat(3, 3), new Cat(1, 1), new Cat(5, 5)};
        DataSorter ds = new DataSorter();
        ds.sort(arr);
        for(int i = 0; i < arr.length; i++){
            System.out.println(arr[i]);
        }
    }
}
}

class DataSorter{//用於排序的工具類
    public void sort(Object[] arr){//參數類型爲Object
        for(int i = arr.length - 1; i > 0; i--){
            for(int j = 0; j < i; j++){
                Comparable c1 = (Comparable) arr[j];//先轉爲Comparable類型
                Comparable c2 = (Comparable) arr[j + 1];
                if(c1.CompareTo(c2) == 1)//調用CompareTo()進行比較, 不關心具體的實現
                    swap(arr, j, j  + 1);
            }
        }
    }

    private void swap(Object[] arr, int i, int j){
        Object temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }
}

class Cat implements Comparable{
    private int age;
    private int weight;

    @Override
    public int CompareTo(Object o) {
        if(o instanceof Cat){//先判斷傳入的是不是Cat類對象, 不是則拋異常
            Cat c = (Cat) o;
            if(this.age > c.age) return 1;
            else if (this.age < c.age) return -1;
            else return 0;
        }
        throw null == o ? new NullPointerException() : new ClassCastException();
    }

    // get / set ...
    //toString() ...
}

interface Comparable{
    public int CompareTo(Object o);
}
複製代碼

 

引入Comparator接口

• 相信看了上面的Comparable接口來由, 你們會感受整個設計又美好了一些, 可是其中還有漏洞. 咱們在Cat類的CompareTo()方法中, 對貓的比較策略是寫死的, 如今咱們按貓的年齡比較大小, 若是哪天咱們想按照貓的體重比較大小, 又要去修改源碼了. 有沒有擴展性更好的設計?
• 咱們可讓用戶本身定義一個比較器類, 對象能夠根據用戶指定的比較器比較大小.
• 整個邏輯是: 若是這個對象須要進行比較, 那麼它必須實現Comparable接口, 可是它具體是怎麼比較的, 則經過具體的Comparator比較器進行比較.
• 固然這裏少不了多態, 咱們首先要定義一個比較器接口Comparator, 用戶的比較器須要實現Comparator接口, 下面上代碼:

public class Strategy {
    public static void main(String[] args) {
        Cat[] arr = {new Cat(3, 3), new Cat(1, 1), new Cat(5, 5)};
        DataSorter ds = new DataSorter();
        ds.sort(arr);
        for(int i = 0; i < arr.length; i++){
            System.out.println(arr[i]);
        }
    }
}

class DataSorter{//用於排序的工具類
    public void sort(Object[] arr){//參數類型爲Object
        for(int i = arr.length - 1; i > 0; i--){
            for(int j = 0; j < i; j++){
                Comparable c1 = (Comparable) arr[j];//先轉爲Comparable類型
                Comparable c2 = (Comparable) arr[j + 1];
                if(c1.CompareTo(c2) == 1)//背後已經轉換爲使用Comparator的定義的規則進行比較
                    swap(arr, j, j  + 1);
            }
        }
    }

    private void swap(Object[] arr, int i, int j){
        Object temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }
}

class Cat implements Comparable{
    private int age;
    private int weight;
    private Comparator comparator = new CatAgeComparator();//默認持有年齡比較器

    @Override
    public int CompareTo(Object o) {
        return comparator.Compare(this, o);//調用比較器比較而不是直接在此寫比較法則
    }

    // get / set / toString ...
}

interface Comparable{
    public int CompareTo(Object o);
}

interface Comparator{
    public int Compare(Object o1, Object o2);
}

//用戶本身定義的, 按照貓的年齡比較大小的比較器
class CatAgeComparator implements Comparator{
    @Override
    public int Compare(Object o1, Object o2) {
        Cat c1 = (Cat) o1;
        Cat c2 = (Cat) o2;
        if(c1.getAge() > c2.getAge()) return 1;
        else if(c1.getAge() < c2.getAge()) return -1;
        else return 0;
    }
}

//按照貓的體重比較大小的比較器
class CatWeightComparator implements Comparator{
    @Override
    public int Compare(Object o1, Object o2) {
        Cat c1 = (Cat) o1;
        Cat c2 = (Cat) o2;
        if(c1.getWeight() > c2.getWeight()) return 1;
        else if(c1.getWeight() < c2.getWeight()) return -1;
        else return 0;
    }
}
複製代碼

 

什麼是策略模式?

• 在上面的例子中, 咱們本身定義了Comparable接口和Comparator接口, 其實這兩個接口都是Java自帶的, 經過上面的代碼示例, 想必你們也應該知道了爲何會有這兩個接口.
• 其實Comparable定義的就是一種比較的策略, 這裏的策略你能夠理解爲一個功能, 然而策略有了, 咱們還須要有具體的策略實現, 因而便有了Comparator接口.

 

• 這裏再舉一個例子方便你們理解.
• 如今有一個坦克小遊戲, 坦克要可以發射炮彈, 那麼咱們能夠認爲發射炮彈就是一種策略, 可是具體到發送什麼炮彈, 這能夠由具體的策略實現.
• 到GitHub上看看該坦克遊戲
• 首先定義發射炮彈這種策略

public interface Fire {
    public void fire();//發射炮彈的策略
}
複製代碼

• 爲了實現發射炮彈這種策略, 定義策略的具體實現, 也就是定義發射炮彈動做

public interface FireAction {
    public void fireAction(Tank tank);
}
複製代碼

• 坦克想要發送炮彈必須實現Fire()接口, 並且坦克擁有發射炮彈的動做, 至於動做的具體實現, 這裏默認給出只發射一顆炮彈的動做.

public class Tank implements TankHitListener, Fire {
    //省略各類屬性方法...
    private FireAction fireAction = new NormalFireAction();//默認動做是隻發射一顆炮彈
    
    @Override
    public void fire() {
        fireAction.fireAction(this);
    }
    
    //...
複製代碼

使用了策略模式有什麼好處?

• 以上面的坦克遊戲爲例, 當把發射炮彈定義爲一種策略後, 能發射炮彈的對象就不僅坦克一個了, 若是遊戲中有機關, 可讓機關也實現fire()接口, 得到發射炮彈的能力.
• 並且在定義策略後咱們能夠根據策略給出不一樣的實現方式, 比方說坦克發射炮彈的動做是每次只發射一顆炮彈, 而機關是每次向八個方向發射一顆炮彈. 很是靈活.
• 結束