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

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

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

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

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

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

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

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

package strategy;
/**
 * 
 * @author CIACs
 *定義抽象策略角色
 */
public abstract class Strategy {
    //定義抽象策略的方法
    public abstract int strategy(int a,int b);

}

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

package strategy;
/**
 * 
 * @author CIACs
 * AddStrategy
 */
public class AddStrategy extends Strategy {
    //定義實現加法的策略方法
    public int strategy(int a, int b)
    {
        return a+b;
    }

}

package strategy;
/**
 * 
 * @author CIACs
 *    SubStrategy
 */
public class SubStrategy extends Strategy {
    //定義減法的策略方法
    public int strategy(int a, int b)
    {
        return a-b;
    }

}

package strategy;
/**
 * 
 * @author CIACs
 *    MultiplyStrategy
 */
public class MultiplyStrategy extends Strategy {
    //定義乘法的策略方法
    public int strategy(int a,int b)
    {
        return a*b;
    }
}

package strategy;
/**
 * 
 * @author CIACs
 *    DivStrategy
 */
public class DivStrategy extends Strategy {
    //定義除法的策略方法，這里為了簡單就不考慮除數為零的情況了
    public int strategy(int a,int b)
    {
        return a/b;
    }
}

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

package strategy;
/**
 * 
 * @author CIACs
 *    Context
 */
public class Context {
    //持有抽象策略角色的引用，用於客戶端調用
    private Strategy strategy;
    //獲得策略類
    public Strategy getStrategy() {
        return strategy;
    }
    //設置所需策略
    public void setStrategy(Strategy strategy) {
        this.strategy = strategy;
        
    }
    //根據設置的策略類返回對應的結果
    public int getResult(int a,int b)
    {
        return strategy.strategy(a, b);
    }

}

4、編寫客戶端

package strategy;
/**
 * 
 * @author CIACs
 *    Client
 */
public class Client {
    public static void main(String[] args) {
        
        Context context = new Context();
        
        int result;
        
        context.setStrategy(new SubStrategy());
        
        result = context.getResult(9, 3);
        
        System.out.println("sub: "+result);
        
        context.setStrategy(new AddStrategy());
        
        result =context.getResult(9, 3);
        
        System.out.println("add: "+result);
        
        context.setStrategy(new DivStrategy());
        
        result = context.getResult(9, 3);
        
        System.out.println("div: "+result);
        
        context.setStrategy(new MultiplyStrategy());
        
        result = context.getResult(9, 3);
        
        System.out.println("mul: "+result);
    }
}

 

輸出結果：

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

工廠類

package strategy;
/**
 * 
 * @author CIACs
 *    Factory
 */
public class Factory {
    public Strategy createStrategy(String str)
    {
        if("AddStrategy".equalsIgnoreCase(str))
        {
            return new AddStrategy();
        }
        else
            if("SubStrategy".equalsIgnoreCase(str))
            {
                return new SubStrategy();
            }
            else
                if("DivStrategy".equalsIgnoreCase(str))
                {
                    return new DivStrategy();
                }
                else
                    if("MultiplyStrategy".equalsIgnoreCase(str))
                    {
                        return new MultiplyStrategy();
                    }
                    else
                        return null;
    }

}

客戶端類

package strategy;
/**
 * 
 * @author CIACs
 *    Client
 */
public class Client {
    public static void main(String[] args) {
     
        Context context = new Context();
        int result;
        Strategy strategy;
        Factory fac = new Factory();
        strategy = fac.createStrategy("AddStrategy");
        context.setStrategy(strategy);
            result = context.getResult(9, 3);
        System.out.println(result);
    }
}

輸出結果：

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

總結：

　　策略模式使開發人員能夠開發出很多可替換的組件，而組件間是弱連接的，體現了代碼的可重用行，弱連接也為以后開發新的組件打下了基礎，具有較強的可擴展性，易於維護。策略模式是對算法的封裝，它把算法的責任和算法本身分割開，委派給別的對象管理。客戶端決定應該使用什么策略，因此客戶端需要理解所有具體策略類之間的區別，這也增加了客戶端的使用難度。