状态模式、策略模式

状态模式、策略模式

状态模式和策略模式有些相似，都是能够动态改变对象的行为。但是状态模式是通过状态转移来改变 Context 所组合的 State 对象，而策略模式是通过 Context 本身的决策来改变组合的 Strategy 对象。所谓的状态转移，是指 Context 在运行过程中由于一些条件发生改变而使得 State 对象发生改变，注意必须要是在运行过程中。

状态模式主要是用来解决状态转移的问题，当状态发生转移了，那么 Context 对象就会改变它的行为；而策略模式主要是用来封装一组可以互相替代的算法族，并且可以根据需要动态地去替换 Context 使用的算法。

状态模式

在状态模式（State Pattern）中，类的行为是基于它的状态改变的。这种类型的设计模式属于行为型模式。

在状态模式中，我们创建表示各种状态的对象和一个行为随着状态对象改变而改变的 context 对象。

状态决定行为

角色： 状态模式主要由两个角色，一个环境角色Context,Context对象用来接受状态,。

状态角色State，State是个接口，有状态的方法，State的实现类有不同的状态，每个状态实现不同内容。

实例

建立一个Context,用来处理状态，建立State和他的实现类,决定不同状态下的操作。

1、建立状态State

//状态接口
public interface State {

    public void doAction(Context context);//由state决定对context的操作

}

2、建立环境Context

public class Context {

    private State state;//状态控制Context

    public Context() {//构造函数不提供状态
        state=null;
    }

    public State getState() {
        return state;
    }

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

3、状态的三个实现类

不同状态下有不同的实现，环境对象Context得到状态后执行不同的实现。

public class InitState implements State {
    @Override
    public void doAction(Context context) {
        System.out.println("The Init State!");

        context.setState(this);//将当前状态传入
    }

    @Override
    public String toString() {//不同状态下同一行为
        return "Init!!!";
    }

    public void init(){//状态各自的行为
        System.out.println("We need Init!!!");
    }
}

public class StopState implements State {
    @Override
    public void doAction(Context context) {
        System.out.println("The Stop State!");

        context.setState(this);//将当前状态传入
    }

    @Override
    public String toString() {
        return "Stop!!!";
    }

    public void stop(){
       System.out.println("Now Stop!!!");
   }
}

public class StartState implements State {
    @Override
    public void doAction(Context context) {
        System.out.println("The Start State!");

        context.setState(this);//将当前状态传入
    }


    @Override
    public String toString() {
        return "Start!!!";
    }

    public void start(){
        System.out.println("Let's Start!!!");
    }
}

4、模式使用

通过测试查看具体使用

public static void main(String[] args) {

        Context context=new Context();//建立context

        InitState initState=new InitState();//建立state

        initState.doAction(context);//由state决定context的行为
        System.out.println(context.getState().toString());//不同状态下的方法
        initState.init();//状态自己的方法


        StartState startState=new StartState();
        startState.doAction(context);
        System.out.println(context.getState().toString());
        startState.start();

        StopState stopState=new StopState();
        stopState.doAction(context);
        System.out.println(context.getState().toString());
        stopState.stop();

    }

The Init State!
Init!!!
We need Init!!!
The Start State!
Start!!!
Let's Start!!!
The Stop State!
Stop!!!
Now Stop!!!

策略模式

在策略模式（Strategy Pattern）中，一个类的行为或其算法可以在运行时更改。这种类型的设计模式属于行为型模式。

在策略模式中，我们创建表示各种策略的对象和一个行为随着策略对象改变而改变的 context 对象。策略对象改变 context 对象的执行算法。

策略决定行为

角色： 策略模式和状态模式非常相似。一个环境角色Context,一个策略角色若干个策略。

实例

我们建立一个Strategy接口，里面有一个策略方法，它的实现类都对这个方法有不同的实现。建立一个Context环境类，通过传入的策略执行策略的方法。

1、策略接口

public interface Strategy {

    public void doStrategy(int a,int b);//执行策略
}

2、策略的实现

三个策略，加减乘。

public class AddStrategy implements Strategy {
    @Override
    public void doStrategy(int a, int b) {
        System.out.println("a add b ="+(a+b));
    }
}

public class SubstractStrategy implements Strategy {
    @Override
    public void doStrategy(int a, int b) {
        System.out.println("a Substract b ="+(a-b));
    }
}

public class MultiplyStrategy implements Strategy {
    @Override
    public void doStrategy(int a, int b) {
        System.out.println("a Multiply b ="+(a*b));
    }
}

3、建立Context环境类，决定执行何种策略

public class Context {

    private Strategy strategy;

    public Context(Strategy strategy) {//将策略传入context中
        this.strategy = strategy;
    }

    public void executeStrategy(int a,int b){//由context决定执行何种策略
        strategy.doStrategy(a,b);
    }
}

4、执行策略

传入不同的策略给环境Context,由context负责实现策略。

 public static void main(String[] args) {

        Strategy strategy=new AddStrategy();//建立策略
        Context context=new Context(strategy);//将策略交给context
        context.executeStrategy(10,2);//执行策略

        context=new Context(new MultiplyStrategy());//将策略交给context
        context.executeStrategy(10,2);//执行策略

        context=new Context(new SubstractStrategy());//将策略交给context
        context.executeStrategy(10,2);//执行策略

    }

a add b =12
a Multiply b =20
a Substract b =8