策略模式和状态模式

策略模式

在上下文中携带策略接口作为成员变量，在使用上下文之前需要设置策略setStrategy（），然后使用策略接口成员变量来进行策略的执行。

步骤1：定义策略接口

// 策略接口
public interface Strategy {
    int execute(int a, int b);
}

步骤2：实现具体策略类

// 具体策略类：加法
public class ConcreteStrategyAdd implements Strategy {
    @Override
    public int execute(int a, int b) {
        return a + b;
    }
}

// 具体策略类：减法

public class ConcreteStrategySubtract implements Strategy {
    @Override
    public int execute(int a, int b) {
        return a - b;
    }
}

步骤3：创建上下文类

// 上下文类
public class Context {
    private Strategy strategy;

    public Context(Strategy strategy) {
        this.strategy = strategy;
    }

    public void setStrategy(Strategy strategy) {
        this.strategy = strategy;
    }
	//使用成员变量执行
    public int executeStrategy(int a, int b) {
        return strategy.execute(a, b);
    }
}

步骤4：编写客户端代码

public class Main {
    public static void main(String[] args) {
        // 使用加法策略
        Context context = new Context(new ConcreteStrategyAdd());
        System.out.println("10 + 5 = " + context.executeStrategy(10, 5));

        // 切换到减法策略
        context.setStrategy(new ConcreteStrategySubtract());
        System.out.println("10 - 5 = " + context.executeStrategy(10, 5));
    }
}

运行结果

10 + 5 = 15
10 - 5 = 5

策略模式的例子：线程池的拒绝策略

策略模式加工厂模式

在策略上下文类中使用一个策略生成的工厂类，然后工厂类会根据执行策略执行的方法传入参数来生成策略并且设置为策略上下文的成员变量，然后执行。

状态模式

和策略模式一样，都是有一个接口成员变量作为实际的执行者，通过设置这个成员变量使得上下文类能执行不同的状态的操作。

// 状态接口
public interface State {
    void handle(Context context);
}

// 具体状态类：开
public class OnState implements State {
    @Override
    public void handle(Context context) {
        System.out.println("Light is turning off.");
        context.setState(new OffState());
    }
}

// 具体状态类：关
public class OffState implements State {
    @Override
    public void handle(Context context) {
        System.out.println("Light is turning on.");
        context.setState(new OnState());
    }
}

// 上下文类
public class Context {
    private State state;

    public Context(State state) {
        this.state = state;
    }

    public void setState(State state) {
        this.state = state;
    }

    public void request() {
        state.handle(this);
    }
}

// 客户端代码
public class Main {
    public static void main(String[] args) {
        Context context = new Context(new OffState());
        context.request(); // Light is turning on.
        context.request(); // Light is turning off.
    }
}

策略模式和状态模式的差异

状态可以由状态成员变量执行过程中改变。
例如：

// 具体状态类：关
public class OffState implements State {
    @Override
    public void handle(Context context) {
        System.out.println("Light is turning on.");
        context.setState(new OnState());
    }
}

而策略模式只是执行策略。