策略模式

在上下文中携带策略接口作为成员变量，在使用上下文之前需要设置策略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());
    }
}

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