一、場景：在實際的專案開發中，我們常常會遇到這樣的問題，實現一個功能有多重方法或策略。

比如商場中計算價格的方法：

1、商場中沒有活動，那麼收費就是原價；

2、商場中有活動，打8折；

3、商場中有活動，滿300件100；

這三個中計算價格的方法就是三種策略。我們在不適用設計模式的情況下，就只能用if...else...獲取switch..case..來判斷使用哪一中計算方法，如下程式碼塊：

/**
* 增加打折功能，在客戶端增加一個折扣下拉選，打8折、7折、5折
 * @param price 單價
 * @param count 數量
 * @param discount 折扣
 * @return
 */
public Double calculation2(Double price,Double count,String discount){
Double result=0D;
if(price==null || count==null){
return result;
}
switch (discount) {
case "打8折":
result=price*count*0.8;
break;
case "打7折":
result=price*count*0.7;
break;
case "打5折":
result=price*count*0.5;
break;
default:
result=price*count;
break;
}
return result;
}
 

這樣寫可以實現搞活動的功能，但是這樣寫程式碼屬於硬編碼，如果商場中不搞活動了或者新增加了一種活動規則，我們就需要重寫程式碼，擴充套件性不好，因此考慮使用策略模式。

二、策略模式

2.1 定義

策略模式(Strategy)定義了演算法家族，分別封裝起來，讓它們之間可以互相替換，此模式讓演算法的變化，不會影響到使用演算法的客戶。

2.2 結構

2.3 商場搞活動程式碼實現

（1）、抽象演算法類，抽象出了計算價格的演算法。

abstract class CushSuper {
	public abstract double attachMoney(double money);
}

（2）、具體演算法1，正常收費

public class CushNormal extends CushSuper{
	@Override
	public double attachMoney(double money) {
		return money;
	}
}
 

（3）、具體演算法2，打折收費

public class CushRebate extends CushSuper{

	private double cushRebate=1d;
	public CushRebate(String moneyRebate) {
		this.cushRebate=Double.parseDouble(moneyRebate);
	}
	
	/*
	 * <p>折扣收費 </p>   
	 * @param money
	 * @return  
	 */
	@Override
	public double attachMoney(double money) {
		double result=money*cushRebate;
		return result;
	}

}
 

（4）、具體演算法3，滿減收費

public class CushReturn extends CushSuper{
	
	private double cushContidion=0d;
	private double cushReturn=0;
	public CushReturn(String cushContidion,String cushReturn) {
		this.cushContidion=Double.parseDouble(cushContidion);
		this.cushReturn=Double.parseDouble(cushReturn);
	}
	
	/*
	 * <p>滿減收費 </p>   
	 * @param money
	 * @return   
	 */
	@Override
	public double attachMoney(double money) {
		double result=money-Math.floor(money/cushContidion)*cushReturn;
		return result;
	}

}

（5）、context上下文，維護一個對Strategy物件的引用。

public class CushContxt {

	private CushSuper cushSuper;
	public CushContxt(CushSuper cushSuper) {
		this.cushSuper=cushSuper;
	}
	
	public double getResult(double money){
		return cushSuper.attachMoney(money);
	}
}

（6）、客戶端使用

public class Test {
	public static void main(String[] args) {
		double price=10d;
		double count=3d;
		
		//計算總價
		Double money=price*count;
		//獲取輸入框中的型別
//		String type="正常收費";
		String type="打8折";
//		String type="打5折";
//		String type="滿300減100";
		CushContxt content=null;
		switch (type) {
		case "正常收費":
			content=new CushContxt(new CushNormal());
			break;
		case "打8折":
			content=new CushContxt(new CushRebate("0.8"));
			break;
		case "打5折":
			content=new CushContxt(new CushRebate("0.5"));
			break;
		case "滿300減100":
			content=new CushContxt(new CushReturn("300","100"));
			break;
		}
		if(content!=null){
			System.out.println(content.getResult(money));
		}	
	}
}

至此，策略模式的解釋已經結束，可以看出以上程式碼的優缺點：

優點：1、演算法可以自由切換。 2、避免使用多重條件判斷。 3、擴充套件性好。

缺點：1、客戶端必須知道所有的策略類，並自己決定由那個策略類。   2、策略類會很多。

解決這個缺點方法：策略+簡單工廠

三、策略+簡單工廠

為了解決客戶端必須知道所有的策略類，並自己決定由那個策略類這個缺點，可以使用策略+工廠模式。

改進CushContext類如下：

public class CushContext {
	
	CushSuper cushSuper=null;
	public CushContext(String type) {
		switch (type) {
		case "正常收費":
			cushSuper=new CushNormal();
			break;
		case "打8折":
			cushSuper=new CushRebate("0.8");
			break;
		case "打5折":
			cushSuper=new CushRebate("0.5");
			break;
		case "滿300減100":
			cushSuper=new CushReturn("300","100");
			break;	
		}
	}
	
	public double getResult(double money){
		return cushSuper.attachMoney(money);
	}
}

客戶端改為：

public class Test {
	//使用策略模式+簡單工廠模式實現
	public static void main(String[] args) {
		double price=10d;
		double count=3d;
		
		//計算總價
		Double money=price*count;
		//獲取輸入框中的型別
		String type1="正常收費";
		String type2="打8折";
		String type3="打5折";
		String type4="滿300減100";
		CushContext content=new CushContext(type1);
		//正常收費
		System.out.println(content.getResult(money));
		//打8折
		CushContext content2=new CushContext(type2);
		System.out.println(content2.getResult(money));
		//打5折
		CushContext content3=new CushContext(type3);
		System.out.println(content3.getResult(money));
		//滿300減100
		CushContext content4=new CushContext(type4);
		System.out.println(content4.getResult(money));
		
	}
}

優點：解決了需要在客戶端判斷使用那個實現的缺點；

缺點：在cashContext中用到了swith,也就是說，如果我們需要增加一種演算法，比如"滿200減50"，就必須更改cashContext中的switch程式碼。

解決方法：策略+簡單工廠+反射

四、策略+簡單工廠+反射

改進CushContext類如下：

public class CushContext {
	
	 private static final String[] CUSH_CLASS_NAME = {  
        "main.java.celue.celue5.CushNormal",  
        "main.java.celue.celue5.CushRebate",  
        "main.java.celue.celue5.CushReturn"
    }; 
	
	CushSuper cushSuper=null;
	public CushContext(String type,Class[] paramsType, Object[] parmas) {
		int type2=Integer.parseInt(type);
		try {
			Class<?> clazz=Class.forName(CUSH_CLASS_NAME[type2]);
			Constructor<?> constructor=clazz.getConstructor(paramsType);
			this.cushSuper=(CushSuper)constructor.newInstance(parmas);
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		} catch (NoSuchMethodException e) {
			e.printStackTrace();
		} catch (SecurityException e) {
			e.printStackTrace();
		} catch (InstantiationException e) {
			e.printStackTrace();
		} catch (IllegalAccessException e) {
			e.printStackTrace();
		} catch (IllegalArgumentException e) {
			e.printStackTrace();
		} catch (InvocationTargetException e) {
			e.printStackTrace();
		}
	}
	
	public double getResult(double money){
		return cushSuper.attachMoney(money);
	}
}

客戶端改進：

public class Test {
	public static void main(String[] args) {
		double price=100d;
		double count=3d;
		//計算總價
		Double money=price*count;
		
		//正常收費
		Class[] paramTypes = {}; 
		Object[] params = {}; 
		CushContext context=new CushContext("0",paramTypes,params);
		System.out.println(context.getResult(money));
		//打8折
		Class[] paramTypes2 = {String.class}; 
		Object[] params2 = {"0.8"}; 
		CushContext context2=new CushContext("1",paramTypes2,params2);
		System.out.println(context2.getResult(money));
		//打5折
		Class[] paramTypes3 = {String.class}; 
		Object[] params3 = {"0.5"}; 
		CushContext context3=new CushContext("1",paramTypes3,params3);
		System.out.println(context3.getResult(money));
		//滿300減100
		Class[] paramTypes4 = {String.class,String.class}; 
		Object[] params4 = {"300","100"}; 
		CushContext context4=new CushContext("2",paramTypes4,params4);
		System.out.println(context4.getResult(money));
	}
}