策略模式與簡單工廠模式的結合使用

　　Java設計模式中的策略模式（Strategy Patten）定義了一組算法，將每一個算法都封裝起來，而且可以使它們之間能夠相互替換，在客戶端調用它們時能夠互不影響。

策略模式主要由三個角色組成

一、抽象策略角色：一般是一個接口或抽象類實現，咱們的具體策略類就是繼承或實現這個抽象角色。

二、具體策略角色：咱們在這些類中寫策略和算法，繼承或實現抽象策略角色。

三、環境角色：環境角色中擁有一個抽象策略角色的引用，供客戶端調用，該角色把客戶端跟策略類的實現分離。

從上面的三個策略模式的角色中，咱們就大概能夠知道策略模式的編寫步驟,這裏以實現簡單的四則運算爲例。

一、定義抽象策略角色，也就是定義一個公共的抽象類（也能夠是接口）

 1 package strategy;
 2 /**
 3  * 
 4  * @author CIACs
 5  *定義抽象策略角色
 6  */
 7 public abstract class Strategy {
 8     //定義抽象策略的方法
 9     public abstract int strategy(int a,int b);
10 
11 }

二、編寫策略類，該類實現上面定義的抽象類

 1 package strategy;
 2 /**
 3  * 
 4  * @author CIACs
 5  * AddStrategy
 6  */
 7 public class AddStrategy extends Strategy {
 8     //定義實現加法的策略方法
 9     public int strategy(int a, int b)
10     {
11         return a+b;
12     }
13 
14 }

 1 package strategy;
 2 /**
 3  * 
 4  * @author CIACs
 5  *    SubStrategy
 6  */
 7 public class SubStrategy extends Strategy {
 8     //定義減法的策略方法
 9     public int strategy(int a, int b)
10     {
11         return a-b;
12     }
13 
14 }

 1 package strategy;
 2 /**
 3  * 
 4  * @author CIACs
 5  *    MultiplyStrategy
 6  */
 7 public class MultiplyStrategy extends Strategy {
 8     //定義乘法的策略方法
 9     public int strategy(int a,int b)
10     {
11         return a*b;
12     }
13 }

 1 package strategy;
 2 /**
 3  * 
 4  * @author CIACs
 5  *    DivStrategy
 6  */
 7 public class DivStrategy extends Strategy {
 8     //定義除法的策略方法，這裏爲了簡單就不考慮除數爲零的狀況了
 9     public int strategy(int a,int b)
10     {
11         return a/b;
12     }
13 }

三、編寫環境角色，其中持有一個抽象策略類的引用

 1 package strategy;
 2 /**
 3  * 
 4  * @author CIACs
 5  *    Context
 6  */
 7 public class Context {
 8     //持有抽象策略角色的引用，用於客戶端調用
 9     private Strategy strategy;
10     //得到策略類
11     public Strategy getStrategy() {
12         return strategy;
13     }
14     //設置所需策略
15     public void setStrategy(Strategy strategy) {
16         this.strategy = strategy;
17         
18     }
19     //根據設置的策略類返回對應的結果
20     public int getResult(int a,int b)
21     {
22         return strategy.strategy(a, b);
23     }
24 
25 }

四、編寫客戶端

 1 package strategy;
 2 /**
 3  * 
 4  * @author CIACs
 5  *    Client
 6  */
 7 public class Client {
 8     public static void main(String[] args) {
 9         
10         Context context = new Context();
11         
12         int result;
13         
14         context.setStrategy(new SubStrategy());
15         
16         result = context.getResult(9, 3);
17         
18         System.out.println("sub: "+result);
19         
20         context.setStrategy(new AddStrategy());
21         
22         result =context.getResult(9, 3);
23         
24         System.out.println("add: "+result);
25         
26         context.setStrategy(new DivStrategy());
27         
28         result = context.getResult(9, 3);
29         
30         System.out.println("div: "+result);
31         
32         context.setStrategy(new MultiplyStrategy());
33         
34         result = context.getResult(9, 3);
35         
36         System.out.println("mul: "+result);
37     }
38 }

 

輸出結果：

上面只是用到策略模式，下面加上簡單工廠模式

工廠類

 1 package strategy;
 2 /**
 3  * 
 4  * @author CIACs
 5  *    Factory
 6  */
 7 public class Factory {
 8     public Strategy createStrategy(String str)
 9     {
10         if("AddStrategy".equalsIgnoreCase(str))
11         {
12             return new AddStrategy();
13         }
14         else
15             if("SubStrategy".equalsIgnoreCase(str))
16             {
17                 return new SubStrategy();
18             }
19             else
20                 if("DivStrategy".equalsIgnoreCase(str))
21                 {
22                     return new DivStrategy();
23                 }
24                 else
25                     if("MultiplyStrategy".equalsIgnoreCase(str))
26                     {
27                         return new MultiplyStrategy();
28                     }
29                     else
30                         return null;
31     }
32 
33 }

客戶端類

 1 package strategy;
 2 /**
 3  * 
 4  * @author CIACs
 5  *    Client
 6  */
 7 public class Client {
 8     public static void main(String[] args) {
 9      
10         Context context = new Context();
11         int result;
12         Strategy strategy;
13         Factory fac = new Factory();
14         strategy = fac.createStrategy("AddStrategy");
15         context.setStrategy(strategy);
16             result = context.getResult(9, 3);
17         System.out.println(result);
18     }
19 }

輸出結果：

固然這裏的工廠類中的if-else的使用是不太好的，簡單工廠模式把生成策略類與客戶端分離。

總結：

　　策略模式使開發人員可以開發出不少可替換的組件，而組件間是弱鏈接的，體現了代碼的可重用行，弱鏈接也爲之後開發新的組件打下了基礎，具備較強的可擴展性，易於維護。策略模式是對算法的封裝，它把算法的責任和算法自己分割開，委派給別的對象管理。客戶端決定應該使用什麼策略，所以客戶端須要理解全部具體策略類之間的區別，這也增長了客戶端的使用難度。