策略模式

由策略抽象类或接口定义出一系列具体算法, 分别封装起来, 让各种算法策略之间可以相互替换, 让算法的变化不会影响到算法的客户. 使用上下文对象维护对算法对象的引用

import java.util.*;

interface Strategy {
    public void Algorithm();
}

class ConcreteStrategyA implements Strategy {
    public void Algorithm() {
        System.out.println("Concrete Strategy A");
    }
}

class ConcreteStrategyB implements Strategy {
    public void Algorithm() {
        System.out.println("Concrete Strategy B");
    }
}

class ConcreteStrategyC implements Strategy {
    public void Algorithm() {
        System.out.println("Concrete Strategy C");
    }
}

class Context {

    Strategy strategy;
    public Context(Strategy strategy) {
        this.strategy = strategy; 
    }
    public void setStrategy(Strategy strategy) {
        this.strategy = strategy;
    }
    public void ContextExecute() {
        strategy.Algorithm();
    }    

}

public class StrategyPattern {

    public static void main(String[] args) {
        Context context;

        context = new Context(new ConcreteStrategyA());
        context.ContextExecute();

        context = new Context(new ConcreteStrategyB());
        context.ContextExecute();

        context = new Context(new ConcreteStrategyC());
        context.ContextExecute();
    }
}

可以将策略模式与简单工厂相结合,修改Context类为StrategyFactory类

class StrategyFactory {
    
    Strategy strategy;
    public StrategyFactory(Strategy strategy) {
        this.strategy = strategy;
    }
    public static Strategy newStrategy(String StrategyType) {
        Strategy strategy = null;
        switch (StrategyType) {
            case "1":
                strategy = new ConcreteStrategyA();
                break;
            case "2":
                strategy = new ConcreteStrategyB();
                break;
            case "3":
                strategy = new ConcreteStrategyC();
                break;
        }
        return strategy;
    }
    public void runAlgorithmByStrategy() {
        this.strategy.Algorithm();
    }
    public static void runAlgorithmByStrategy(String StrategyType) {
        newStrategy(StrategyType).Algorithm();
    }
}