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

public abstract class Strategy {
    public abstract void AlgorithmInterface();
}
public class ConcreteStrategyA extends Strategy {
    @Override
    public void AlgorithmInterface() {
        System.out.println("ConcreteStrategyA的具體實現");
    }
}
public class ConcreteStrategyB extends Strategy {
    @Override
    public void AlgorithmInterface() {
        System.out.println("ConcreteStrategyB的具體實現");
    }
}
public class ConcreteStrategyC extends Strategy {
    @Override
    public void AlgorithmInterface() {
        System.out.println("ConcreteStrategyC的具體實現");
    }
}
public class Context {
    Strategy strategy;

    public Context(Strategy strategy) {
        this.strategy = strategy;
    }
    public void ContextInterface()
    {
        strategy.AlgorithmInterface();
    }
}
public class Main {
    public static void main(String[] args) {
        Context context=new Context(new ConcreteStrategyA());
        context.ContextInterface();
        Context context1=new Context(new ConcreteStrategyB());
        context1.ContextInterface();
        Context context2=new Context(new ConcreteStrategyC());
        context2.ContextInterface();
    }
}
 

上面的例子中，對於客戶端來說需要知道具體的ConcreteStrategyA,ConcreteStrategyB,ConcreteStrategyC,這樣並不好

為了解決這個問題，可以將客戶端的一部分轉移到Context中實現

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

public abstract class Strategy {
    public abstract void AlgorithmInterface();
}
public class ConcreteStrategyA extends Strategy {
    @Override
    public void AlgorithmInterface() {
        System.out.println("ConcreteStrategyA的具體實現");
    }
}
public class ConcreteStrategyB extends Strategy {
    @Override
    public void AlgorithmInterface() {
        System.out.println("ConcreteStrategyB的具體實現");
    }
}
public class ConcreteStrategyC extends Strategy {
    @Override
    public void AlgorithmInterface() {
        System.out.println("ConcreteStrategyC的具體實現");
    }
}
public class Context {
    Strategy strategy;
    public Context(String type) {
        switch (type)
        {
            case "A":
                strategy=new ConcreteStrategyA();
                break;
            case"B":
                strategy=new ConcreteStrategyB();
                break;
            case"C":
                strategy=new ConcreteStrategyC();
                break;
        }
    }
    public void ContextInterface()
    {
        strategy.AlgorithmInterface();
    }
}
public class Main {
    public static void main(String[] args) {
        Context context=new Context("A");
        context.ContextInterface();
        Context context1=new Context("B");
        context1.ContextInterface();
        Context context2=new Context("C");
        context2.ContextInterface();
    }
}
 

策略模式的解析：

策略模式是一種定義一系列演算法的方法，從概念上來看，所有的這些演算法完成的都是相同的工作，只是實現不同，它可以以相同的方式呼叫所有的演算法，減少了各種演算法類與使用演算法類之間的耦合

策略模式的Strategy類層次為Context定義了一系列的可供重用的演算法或行為。繼承有助於析取這些演算法的公共功能，策略模式的另一個優點是簡化了單元測試，因為每個演算法都有自己的類，可以通過自己的介面單獨測試。

注：

簡單工廠模式+策略模式並不是一個很好的解決辦法，不符合開放擴充套件原則

策略模式裡的switch語句可以用抽象工廠+反射得到更好的解決