策略模式-有解無憂

基本介紹
策略模式
JDK-Arrays的應用

基本介紹

策略模式的策略，該怎么理解呢？在我看來，就是在面對不同的場景，采取不一樣的處理方式
策略模式屬于行為型模式，大多應用于動態在一個物件的多種行為進行切換的場景，
意圖：定義一系列的演算法,把它們一個個封裝起來，并且使它們可相互替換，以避免在多種演算法相似的場景下，使用過多的 if...else 所帶來的復雜和難以維護
注意：當一個系統的策略多于四個，就需要考慮使用混合模式，解決策略類膨脹的問題

假設有一家游戲公司，委托我們開發一款模擬鴨子池塘的游戲，該公司的主要產品是一種可以模擬展示多種會游泳和嘎嘎叫的鴨子的游戲，它們要求在設計鴨子時盡量貼近生活，保持真實性，

他們的最初始的設計如下：

鴨子的抽象類

public abstract class Duck {

	public Duck() {}

	public abstract void display();// 顯示鴨子資訊

	public void quack() {
		System.out.println("鴨子嘎嘎叫");
	}

	public void swim() {
		System.out.println("鴨子會游泳");
	}

	public void fly() {
		System.out.println("鴨子會飛翔");
	}

}

北京鴨

public class PekingDuck extends Duck {

	@Override
	public void display() {
		System.out.println("北京鴨");
	}
	
	/**
	 * 由于北京鴨不會飛翔，因此需要重寫fly
	 */
	@Override
	public void fly(){
		System.out.println("北京鴨不會飛翔");
	}
	
}

玩具鴨

public class ToyDuck extends Duck {

	@Override
	public void display() {
		System.out.println("玩具鴨");
	}

	@Override
	public void quack() {
		System.out.println("玩具鴨不能叫~~~");
	}

	@Override
	public void fly() {
		System.out.println("玩具鴨不會飛翔~~");
	}

}

野鴨

public class WildDuck extends Duck {

	@Override
	public void display() {
		System.out.println("這是野鴨");
	}

}

利用繼承來復用鴨子的各個行為，初衷是好的，但是沒有真正將鴨子的各個行為拆分，只是簡單的復用，就會有很多問題，
當我們需要新添加一類鴨子，若其父類的抽象方法不滿足當前物件時，我們就需要重寫以覆寫父類的抽象方法，這就違背了里式替換原則且擴展性欠缺，

策略模式

剛剛我們也說了，策略模式主要應用動態在一個物件的多種行為進行切換的場景
那我們開始重新構建模擬鴨子的這款游戲吧，我們想一想能不能把鴨子的各種行為抽出來再跟鴨子進行組合, 這樣在面對不同的鴨子時進行組裝即可

鴨子的抽象類

public abstract class Duck {
	
	//屬性,策略介面
	FlyBehavior flyBehavior;
	
	
	public Duck() {}

	public abstract void display();// 顯示鴨子資訊

	public void quack() {
		System.out.println("鴨子嘎嘎叫");
	}

	public void swim() {
		System.out.println("鴨子會游泳");
	}

	public void fly() {
		if(flyBehavior != null){
		      flyBehavior.fly();
		}
	}

}

飛行行為

public interface FlyBehavior {
	
	void fly();
	
}

行為-飛的好

public class GoodFlyBehavior implements FlyBehavior {

	@Override
	public void fly() {
		System.out.println("飛翔技術高超");
	}

}

行為-飛的一般

public class NormalFlyBehavior implements FlyBehavior {

	@Override
	public void fly() {
		System.out.println("飛翔技術一般");
	}

}

行為-不會飛

public class NoFlyBehavior implements FlyBehavior {

	@Override
	public void fly() {
		System.out.println("不會飛翔");
	}

}

北京鴨

public class PekingDuck extends Duck {
      
        public  PekingDuck(){
                //給鴨子賦予飛的一般的行為
		flyBehavior = new NormalFlyBehavior();
	}

	@Override
	public void display() {
		System.out.println("北京鴨");
	}
	
}

野鴨

public class WildDuck extends Duck {
	
	public  WildDuck() {
                //給鴨子賦予飛的好的行為
		flyBehavior = new GoodFlyBehavior();
	}
	
	@Override
	public void display() {
		System.out.println("這是野鴨");
	}

}

玩具鴨

public class ToyDuck extends Duck {
	
	public ToyDuck(){
                //給鴨子賦予不會飛的行為
		flyBehavior = new NoFlyBehavior();
	}
	
	@Override
	public void display() {
		System.out.println("玩具鴨");
	}

	@Override
	public void quack() {
		System.out.println("玩具鴨不能叫~~~");
	}

}

從上述的例子我們看出，將鴨子的各個行為組合到不同的鴨子中去，既增加了系統的彈性，也滿足了每個鴨子的特點，
鴨子會不會飛，飛的好不好根據不同的策略制定，
綜上： 策略模式提供了對“開閉原則”的完美支持，用戶可以在不修改原有系統的基礎上選擇演算法或行為，也可以靈活地增加新的演算法或行為

JDK-Arrays的應用

在jdk中， Arrays 的Comparator 就實作了策略模式

public class Arrays {
    public static <T> void sort(T[] a, Comparator<? super T> c) {
        if (c == null) {
            sort(a);
        } else {
            if (LegacyMergeSort.userRequested)
                legacyMergeSort(a, c);
            else
                TimSort.sort(a, 0, a.length, c, null, 0, 0);
        }
    }
}

public interface Comparator<T> {
    int compare(T o1, T o2);
}

我們測驗一下：

public class TestStrategy {
    public static void main(String[] args) {
        // 陣列
        Integer[] data = https://www.cnblogs.com/dwlovelife/p/{ 9, 1, 2, 8, 4, 3 };
        // 實作降序排序，回傳-1放左邊，1放右邊，0保持不變

        // 說明
        // 1. 實作了 Comparator 介面（策略介面） , 匿名類 物件 new Comparator(){..}
        // 2. 物件 new Comparator(){..} 就是實作了 策略介面 的物件
        // 3. public int compare(Integer o1, Integer o2){} 指定具體的處理方式
        Comparator comparator = new Comparator() {
            public int compare(Integer o1, Integer o2) {
                if (o1 > o2) {
                    return -1;
                } else {
                    return 1;
                }
            };
        };

        // 說明
        /*
         * public static  void sort(T[] a, Comparator<? super T> c) { if (c == null)
         * { sort(a); //默認方法 } else { if (LegacyMergeSort.userRequested)
         * legacyMergeSort(a, c); //使用策略物件c else // 使用策略物件c TimSort.sort(a, 0, a.length,
         * c, null, 0, 0); } }
         */
        // 方式1
        Arrays.sort(data, comparator);

        System.out.println(Arrays.toString(data)); // 降序排序

        // 方式2- 同時lambda 運算式實作 策略模式
        Integer[] data2 = { 19, 11, 12, 18, 14, 13 };

        Arrays.sort(data2, (var1, var2) -> {
            if (var1.compareTo(var2) > 0) {
                return -1;
            } else {
                return 1;
            }
        });

        System.out.println("data2=" + Arrays.toString(data2));

    }

}

轉載請註明出處，本文鏈接：https://www.uj5u.com/ruanti/3108.html

標籤：設計模式

上一篇：觀察者模式

下一篇：設計模式(10) 外觀模式