混合模式（策略模式+工厂方法模式+门面模式）

使用这三种模式设计一个简单的计算器程序：计算器是用于计算数值之间进行数学计算后所获得的值。它包含基本的"加减"功能。以上对以上需求进行分析可以得出计算有两种策略(+与-)。

计算策略的实现：

/*抽象策略*/
public interface Strategy
{
    /*定义了计算策略所拥有的算法*/
    public int calculate(int a,int b);
}

/*加法策略的实现*/
public class AddStrategy implements Strategy
{
    @Override
    public int calculate(int a, int b)
    {
        return a+b;
    }
}

/*减法策略的实现*/
public class SubStrategy implements Strategy
{
    @Override
    public int calculate(int a, int b)
    {
        return a-b;
    }
}

此时还需要一个封装策略的对象，让策略可以互换：

public class StrategyContext
{
    /*封装了策略对象*/
    private Strategy strategy = null;
    
    public StrategyContext(Strategy strategy)
    {
        this.strategy = strategy;
    }
    
    /*实现了策略可以互换的功能*/
    public void setStrategy(Strategy strategy)
    {
        this.strategy = strategy;
    }
    
    public int execute(int a,int b)
    {
        return this.strategy.calculate(a, b);
    }
}

　　为了避免策略模式必须要将具体的策略暴露给高层模块的缺点，我们使用工厂来生成策略，现在高层模块只需要一个约束条件就可以获得需要的策略。
策略生成工厂的实现：

/*策略生成抽象工厂*/
public interface Factory
{
    /*定义一个生成策略的接口，其参数还可以使用一个配置文件来实现约束条件，这里使用了枚举*/
    public Strategy createStrategy(StrategyEnum strategyEnum);
}

public class StrategyFactory implements Factory
{
    @Override
    public Strategy createStrategy(StrategyEnum strategyEnum)
    {
        Strategy strategy = null;
        
        try
        {
            String strategyName = strategyEnum.getStrategyName();
            Class<?> clazz = Class.forName(strategyName);
            strategy = (Strategy)clazz.newInstance();
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
        
        return strategy;
    }
}

　　每次进行计算的步骤为：获取工厂、获取策略、封装策略、计算结果。这样写比较麻烦，高层模块为了计算一个结果还需要记住执行顺序，这时候我们可以使用门面模式来屏蔽子系统的复杂性，为高层模块提供一个计算接口即可。

计算机器门面的实现：

public class FacadeContext
{
    /*门面模式不参与子系统的逻辑，所以对子系统进行了一次封装*/
    private Factory factory = new StrategyFactory();
    private StrategyContext context = new StrategyContext(null);
    
    public FacadeContext(){}
    
    public int calculate(int a,int b,StrategyEnum strategy)
    {
        this.context.setStrategy(this.factory.createStrategy(strategy));
        return this.context.execute(a, b);
    }
}

/*计算器的门面，简单的委托类，为高层提供一个反问子系统的接口，让高层模块不再依赖子系统*/
public class CalculatorFacade
{
    private FacadeContext context = new FacadeContext();
    
    public CalculatorFacade()
    {}
    
    public int calculate(int a,int b,StrategyEnum strategy)
    {
        return this.context.calculate(a, b, strategy);
    }
}

来看看场景类：

public class Client
{
    public static void main(String[] args)
    {
        /*获取门面，使用其提供的接口访问子系统*/
        CalculatorFacade calculatorFacade = new CalculatorFacade();
        System.out.println("2+2="+calculatorFacade.calculate(2, 2, StrategyEnum.ADD));
    }
}

附：StrategyEnum枚举代码：

public enum StrategyEnum
{
    ADD("com.suxiaolei.calculator.strategy.AddStrategy"),
    SUB("com.suxiaolei.calculator.strategy.SubStrategy");
    
    private String strategyName;
    
    private StrategyEnum(String strategyName)
    {
        this.strategyName = strategyName;
    }
    
    public String getStrategyName()
    {
        return this.strategyName;
    }
}

　　以上是混合使用三种模式的一个简单例子，可以看出灵活搭配模式能让系统更健壮，灵活性更高，扩展性更强。在上述例子添加策略非常非常的容易，只需要继承Strategy接口即可，然后在枚举中增加对应的策略类名即可，高层代码一点也不用改变。其实要是使用配置文件的方式，则只需要继承Strategy接口，都不用枚举了，这样更灵活。