State 状态模式 MD

时间：2022-12-03 11:58:08
Markdown版本笔记 我的GitHub首页 我的博客 我的微信 我的邮箱
MyAndroidBlogs baiqiantao baiqiantao bqt20094 baiqiantao@sina.com

目录

状态模式

状态模式看起来和策略模式很像，但是是两个不一样的设计模式。状态模式是一个类根据内部的状态动态的选择行为。策略模式一般用于算法，通过设置不同的策略类来执行不同的算法。

简介

状态模式允许一个对象在其内部状态改变的时候改变其行为，这个对象看上去就像是改变了它的类一样。

状态模式把所研究的对象的【行为】包装在不同的【状态对象】里，每一个状态对象都属于抽象状态类的一个子类。

状态模式的意图是让一个对象在其内部状态改变的时候，其行为也随之改变。

角色

  • 抽象状态类State：定义一个或一组接口，表示该状态下类的行为
  • 具体状态类ConcreteState：实现抽象状态类中定义的接口，从而达到不同状态下的不同行为
  • 环境类Context：定义客户感兴趣的接口，维护一个抽象状态类的子类的实例，这个实例代表对象当前的状态

和策略模式的比较

状态模式和策略模式的结构几乎完全一样，但它们的目的却完全不一样。

状态模式的行为是平行的、不可替换的，策略模式的行为是彼此独立、可相互替换的。

状态模式和策略模式都是为了实现解耦，避免一大堆的if-else的写法，但是状态模式更多的是适合不同状态下，同样的行为有不同的响应。根据实际生活来说，这种模式适合有明显的状态区分的时候。比如电视的开，关就是两种状态。

状态模式的关键点在于不同的状态下对于同一行为有不同的响应，这其实就是一个将if-else用多态来实现的具体实例

状态模式将所有与一个特定状态相关的行为都放入一个状态对象中，它提供了一个更好的方法来组织与特定状态相关的代码，将繁琐的状态判断转换成结构清晰的状态类族，在避免代码膨胀的同时也保证了可扩展性和可维护性

使用场景

  • 一个类的状态决定了他的行为，而且在运行时必须根据当前的状态来改变行为。
  • 跟策略模式一样，解决一大堆分支语句的存在。

优缺点：

  • 优点：将所有的状态和该状态的行为封装在同一个实现类中，然后有一个共同的接口，代码结构清晰，便于扩展和修改。
  • 缺点：也是要增加很多类

案例一

下面我们以日常开发中的登录功能来简单应用下状态模式

在登录模块中一般我们会根据用户是否是登录状态而有不同的操作，这里简单模拟2个操作，转发和评论

public interface UserState {

    void forward(Context context); //转发

    void comment(Context context); //评论

}

登录状态，调用转发和评论直接简单地弹出个Toast

public class LoginedState implements UserState {

    @Override

    public void forward(Context context) {

        Toast.makeText(context, "转发成功", Toast.LENGTH_SHORT).show();

    }

    @Override

    public void comment(Context context) {

        Toast.makeText(context, "评论成功", Toast.LENGTH_SHORT).show();

    }

}

未登录状态，调用转发和评论跳转到登录页面，这里直接简单地弹出登录的提示

public class LogoutState implements UserState {

    @Override

    public void forward(Context context) {

        Toast.makeText(context, "未登录，跳转到登录页面", Toast.LENGTH_SHORT).show();

    }

    @Override

    public void comment(Context context) {

        Toast.makeText(context, "未登录，跳转到登录页面", Toast.LENGTH_SHORT).show();

    }

}

相当于将每一个条件分支下的行为全部放入了一个独立的类中，如果不采用这种模式，则针对每一种行为都必须采取if-else方式判断

状态模式把对象的行为包装在不同的状态对象里，状态模式的意图是让一个对象在其内部状态发生改变的时候，其行为也随之改变

状态模式的行为是平行的、不可替换的

下面我们看看对外提供服务的环境类

public class LoginContext {

    private UserState userState = new LoginedState(); //用户状态，默认为登录状态

    public void setUserState(UserState userState) { //设置用户状态

        this.userState = userState;

    }

    public void forward(Context context) {

        userState.forward(context);

    }

    public void comment(Context context) {

        userState.comment(context);

    }

}

下面我们看看怎么调用：

LoginContext context = LoginContext();

context.forward(MainActivity.this); //默认是登录状态，所以可以直接调用转发功能

context.setUserState(new LogoutState()); //登录状态改为未登录

context.forward(MainActivity.this); //注销登录后再调用转发或是评论功能，执行的就会是弹出登录提示

通过上面的例子我们可以看出，状态模式把对象的不同状态下的行为封装起来，对象的状态改变了，对象的行为也会改变。

案例二

抽象状态类

interface IState {

    void open(); //电梯门开启动作

    void close();//电梯关闭动作

    void run();//运行电梯动作

    void stop();//停止电梯动作

}

具体状态类

class OpenningState implements IState {

    private Context context;

    public OpenningState(Context context) {

        this.context = context;

    }

    @Override

    public void open() {

        System.out.println("电梯门开启...");

    }

    @Override

    public void close() {

        context.setState(Context.closeingState);//状态修改

        context.getState().close(); //动作委托给CloseState来执行

    }

    @Override

    public void run() {

        System.out.println("------------------电梯门开启状态下运行？要死啊，你！");

    }

    @Override

    public void stop() {

        System.out.println("------------------电梯门开启状态下停止？额，这个本来就应该是这样的吧！");

    }

}
class ClosingState implements IState {

    private Context context;

    public ClosingState(Context context) {

        this.context = context;

    }

    @Override

    public void close() {

        System.out.println("电梯门关闭...");

    }

    @Override

    public void open() {

        context.setState(Context.openningState);

        context.getState().open();

    }

    @Override

    public void run() {

        context.setState(Context.runningState);

        context.getState().run();

    }

    @Override

    public void stop() {

        context.setState(Context.stoppingState);

        context.getState().stop();

    }

}
class RunningState implements IState {

    private Context context;

    public RunningState(Context context) {

        this.context = context;

    }

    @Override

    public void close() {

        System.out.println("------------------运行状态下关闭电梯门？电梯门本来就是关着的！");

    }

    @Override

    public void open() {

        System.out.println("------------------运行状态下开电梯门？你疯了！");

    }

    @Override

    public void run() {

        System.out.println("电梯上下跑...");

    }

    @Override

    public void stop() {

        context.setState(Context.stoppingState);

        context.getState().stop();

    }

}
class StoppingState implements IState {

    private Context context;

    public StoppingState(Context context) {

        this.context = context;

    }

    @Override

    public void close() {

        System.out.println("------------------停止状态下关门？电梯门本来就是关着的！");

    }

    @Override

    public void open() {

        context.setState(Context.openningState);

        context.getState().open();

    }

    @Override

    public void run() {

        context.setState(Context.runningState);

        context.getState().run();

    }

    @Override

    public void stop() {

        System.out.println("电梯停止了...");

    }

}

环境类

class Context {

    public static OpenningState openningState;

    public static ClosingState closeingState;

    public static RunningState runningState;

    public static StoppingState stoppingState;

    private IState state;

    public IState getState() {

        return state;

    }

    public Context() {

        openningState = new OpenningState(this);

        closeingState = new ClosingState(this);

        runningState = new RunningState(this);

        stoppingState = new StoppingState(this);

    }

    public void setState(IState state) {

        this.state = state;

    }

    public void open() {

        state.open();

    }

    public void close() {

        state.close();

    }

    public void run() {

        state.run();

    }

    public void stop() {

        state.stop();

    }

}

测试

class Test {

    public static void main(String[] args) {

        Context context = new Context();

        IState[] states = {new OpenningState(context), new ClosingState(context), new RunningState(context), new StoppingState(context)};

        for (IState state : states) {

            System.out.println("当前状态【" + state.getClass().getSimpleName() + "】");

            context.open();

            context.close();

            context.run();

            context.stop();

        }

    }

}

2016-10-20

相关文章