策略模式（strategy）

策略模式定義了一系列演算法，並將每個演算法封裝起來，使他們可以相互替換，且演算法的變化不會影響到使用演算法的客戶。

        一種方法是 需要設計一個介面，為一系列實現類提供統一的方法，多個實現類實現該介面，設計一個抽象類（可有可無，屬於輔助類），提供輔助函式，關係圖如下：

圖中ICalculator提供同意的方法，AbstractCalculator是輔助類，提供輔助方法，接下來，依次實現下每個類：

首先統一介面：

1. publicinterface ICalculator {  
2.     publicint calculate(String exp);  
3. }  

輔助類：

1. publicabstractclass AbstractCalculator {  
2.     publicint[] split(String exp,String opt){  
3.         String array[] = exp.split(opt);  
4.         int arrayInt[] = newint[2];  
5.         arrayInt[0] = Integer.parseInt(array[0]);  
6.         arrayInt[1] = Integer.parseInt(array[1]);  
7.         return
    arrayInt;  
8.     }  
9. }  

三個實現類：

1. publicclass Plus extends AbstractCalculator implements ICalculator {  
2.     @Override
3.     publicint calculate(String exp) {  
4.         int arrayInt[] = split(exp,"\\+");  
5.         return arrayInt[0]+arrayInt[1];  
6.     }  
7. }  

1. publicclass Minus extends AbstractCalculator 
   implements ICalculator {  
2.     @Override
3.     publicint calculate(String exp) {  
4.         int arrayInt[] = split(exp,"-");  
5.         return arrayInt[0]-arrayInt[1];  
6.     }  
7. }  

1. publicclass Multiply extends AbstractCalculator implements ICalculator {  
2.     @Override
3.     publicint calculate(String exp) {  
4.         int arrayInt[] = split(exp,"\\*");  
5.         return arrayInt[0]*arrayInt[1];  
6.     }  
7. }  

簡單的測試類：

1. publicclass StrategyTest {  
2.     publicstaticvoid main(String[] args) {  
3.         String exp = "2+8";  
4.         ICalculator cal = new Plus();  
5.         int result = cal.calculate(exp);  
6.         System.out.println(result);  
7.     }  
8. }  

輸出：10

另一種方法是 定義一個抽象策略類，定義所有支援的演算法的公共介面；具體策略類封裝所有的演算法或行為，繼承於抽象類；新增一個輔助類來維護隊抽象類的引用（可有可無）。 關係圖如下：

抽象演算法類，Strategy類，定義所有支援的演算法的公共介面

        public abstract class Strategy{
     		 //演算法方法
     		 public abstract void AlgorithmInterface();
	}

public class ConcreteStrategyA extends  Strategy{
          //演算法A實現方法
          @Override
          public void AlgorithmInterface(){
                //演算法A的實現
          }
}

public class ConcreteStrategyB extends  Strategy{
          //演算法B實現方法
          @Override
          public void AlgorithmInterface(){
                //演算法B的實現
          }
}

public class ConcreteStrategyC extends  Strategy{
          //演算法C實現方法
          @Override
          public void AlgorithmInterface(){
                //演算法C的實現
          }
}

public class Context{
        Strategy strategy;
        public Context(Strategy strategy){
              this.strategy=strategy;
        }
        public void ContextInterface(){
                 strategy.AlgorithmInterface();
        }
}

1. publicclass StrategyTest {  
2.     publicstaticvoid main(String[] args) {  
3. Context context;
4.         context=new Context(new ConcreteStrategyA());
5.         context.ContextInterface();
6. context=new Context(new ConcreteStrategyB());
7.         context.ContextInterface();
8.         .......
9.     }