設計模式---策略模式

一. 概述

1. 策略模式（Strategy Pattern）中，定義算法族，分別封裝起來，讓他們之間可以互相替換，此模式讓算法的變化獨立於使用算法的客戶。
2. 這算法體現了幾個設計原則：
   第一、把變化的代碼從不變的代碼中分離出來；
   第二、針對接口編程而不是具體類（定義了策略接口）；
   第三、多用組合/聚合，少用繼承（客戶通過組合方式使用策略）。

• 原理類圖：
  
  從上圖可以看到，客戶context 有成員變量strategy或者其他的策略接口,至於需要使用到哪個策略，我們可以在構造器中指定.

二. 場景示例

• 編寫鴨子項目，具體要求如下:

1. 有各種鴨子(比如 野鴨、北京鴨、水鴨等， 鴨子有各種行爲，比如 叫、飛行等)
2. 顯示鴨子的信息

• 思路分析類圖：
  策略模式：分別封裝行爲接口，實現算法族，超類裏放行爲接口對象，在子類裏具體設定行爲對象。原則就是：分離變化部分，封裝接口，基於接口編程各種功能。此模式讓行爲的變化獨立於算法的使用者。
  
• 代碼實現：

public abstract class Duck {
	//屬性, 策略接口
	FlyBehavior flyBehavior;
	//其它屬性<->策略接口
	QuackBehavior quackBehavior;
	
	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 void setFlyBehavior(FlyBehavior flyBehavior) {
		this.flyBehavior = flyBehavior;
	}
	
	public void setQuackBehavior(QuackBehavior quackBehavior) {
		this.quackBehavior = quackBehavior;
	}
}

public interface FlyBehavior {
	void fly(); 
}

public interface QuackBehavior {
	void quack(); 
}

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

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

public class NoFlyBehavior implements FlyBehavior{
	@Override
	public void fly() {
		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("玩具鴨");
	}

	//需要重寫父類的所有方法
	public void quack() {
		System.out.println("玩具鴨不能叫~~");
	}
	
	public void swim() {
		System.out.println("玩具鴨不會游泳~~");
	}
}

public class PekingDuck extends Duck {
	//假如北京鴨可以飛翔，但是飛翔技術一般
	public PekingDuck() {
		flyBehavior = new BadFlyBehavior();
	}
	
	@Override
	public void display() {
		System.out.println("~~北京鴨~~~");
	}
}

public class Client {
	public static void main(String[] args) {
		WildDuck wildDuck = new WildDuck();
		wildDuck.fly();
		
		ToyDuck toyDuck = new ToyDuck();
		toyDuck.fly();
		
		PekingDuck pekingDuck = new PekingDuck();
		pekingDuck.fly();
		
		//動態改變某個對象的行爲, 北京鴨 不能飛
		pekingDuck.setFlyBehavior(new NoFlyBehavior());
		System.out.println("北京鴨的實際飛翔能力");
		pekingDuck.fly();
	}
}

三. 策略模式在JDK-Arrays 應用

• JDK的 Arrays 的Comparator就使用了策略模式

public class Strategy {
	public static void main(String[] args) {
		Integer[] data = { 9,1,2,8,4,3 };
		// 實現升序排序，返回-1放左邊，1放右邊，0保持不變
		Comparator<Integer> comparator = new Comparator<Integer>() {
			public int compare(Integer o1, Integer o2) {
				if(o1 > o2) {
					return 1;
				}else{
					return -1;
				}};
			};
		Arrays.sort(data, comparator);
		System.out.println(Arrays.toString(data));  
	}
}

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

public static <T> void sort(T[] a, Comparator<? super T> c) {
		if (c == null) { // c==null, 就按照自己的方法排序
			sort(a);
		} else {
		if (LegacyMergeSort.userRequested) 
			legacyMergeSort(a, c); //按照這個方式調用c
		else
			TimSort.sort(a, 0, a.length, c, null, 0, 0); //按照此方式調用c比較器
	}
}

• 策略模式的注意事項和細節

1. 策略模式的關鍵是：分析項目中變化部分與不變部分
2. 策略模式的核心思想是：多用組合/聚合 少用繼承；用行爲類組合，而不是行爲的繼承。更有彈性
3. 體現了“對修改關閉，對擴展開放”原則，客戶端增加行爲不用修改原有代碼，只要添加一種策略（或者行爲）即可，避免了使用多重轉移語句（if…else if…else）
4. 提供了可以替換繼承關係的辦法： 策略模式將算法封裝在獨立的Strategy類中使得你可以獨立於其Context改變它，使它易於切換、易於理解、易於擴展
5. 需要注意的是：每添加一個策略就要增加一個類，當策略過多是會導致類數目龐大