首页 > 其他分享 >行为型模式-状态模式

行为型模式-状态模式

时间：2022-11-09 18:58:15浏览次数：43  
标签：状态 void 模式 STATE protected context Override 行为 public

概述

【例】通过按钮来控制一个电梯的状态，一个电梯有开门状态，关门状态，停止状态，运行状态。每一种状态改变，都有可能要根据其他状态来更新处理。例如，如果电梯门现在处于运行时状态，就不能进行开门操作，而如果电梯门是停止状态，就可以执行开门操作。

类图如下：

 

 

 

public interface ILift {

    int OPENING_STATE = 1;

    int CLOSING_STATE = 2;

    int RUNNING_STATE = 3;

    int STOPPING_STATE = 4;

    //设置电梯状态的功能
    void setState(int state);

    void open();

    void close();

    void run();

    void stop();
    
}

 

 

public class Lift implements ILift{

    //声明记录当前电梯状态
    private int state;

    @Override
    public void setState(int state) {
        this.state = state;
    }

    @Override
    public void open() {
        switch (state) {
            case OPENING_STATE:
                //什么都不做
                break;
            case CLOSING_STATE:
                System.out.println("电梯打开了");
                //设置当前电梯为开启
                setState(OPENING_STATE);
                break;
            case RUNNING_STATE:
                //什么都不做
                break;
            case STOPPING_STATE:
                System.out.println("电梯打开了");
                //设置当前电梯为开启
                setState(OPENING_STATE);
                break;
        }
    }

    @Override
    public void close() {
        switch (state) {
            case OPENING_STATE:
                System.out.println("电梯关门了");
                setState(CLOSING_STATE);
                break;
            case CLOSING_STATE:
                break;
            case RUNNING_STATE:
                //什么都不做
                break;
            case STOPPING_STATE:
                break;
        }
    }

    @Override
    public void run() {
        switch (state) {
            case OPENING_STATE:
                break;
            case CLOSING_STATE:
                System.out.println("电梯开始运行了");
                setState(RUNNING_STATE);
                break;
            case RUNNING_STATE:
                //什么都不做
                break;
            case STOPPING_STATE:
                System.out.println("电梯开始运行了");
                setState(RUNNING_STATE);
                break;
        }
    }

    @Override
    public void stop() {
        switch (state) {
            case OPENING_STATE:
                break;
            case CLOSING_STATE:
                System.out.println("电梯停止了");
                setState(STOPPING_STATE);
                break;
            case RUNNING_STATE:
                System.out.println("电梯停止了");
                setState(STOPPING_STATE);
                break;
            case STOPPING_STATE:
                System.out.println("电梯打开了");
                break;
        }
    }
}

 

 

public class Client {

    public static void main(String[] args) {
        Lift lift = new Lift();
        lift.setState(ILift.RUNNING_STATE);

        lift.open();
        lift.close();
        lift.run();
        lift.stop();
    }
}

 

 

问题分析：

  • 使用了大量的switch..casei这样的判断(if…else也是一样)，使程序的可阅读性变差，
  • 扩展性很差。如果新加了断电的状态，我们需要修改上面判断逻辑

定义：

对有状态的对象，把复杂的“判断逻辑“提取到不同的状态对象中，允许状态对象在其内部状态发生改变时改变其行为。

结构：

状态模式包含以下主要角色。

  • 环境(Cotext)角色：也称为上下文，它定义了客户程序需要的接口，维护一个当前状态，并将与状态相关的操作委托给当前状态对象来处理。
  • 抽象状态(State)角色：定义一个接口，用以封装环境对象中的特定状态所对应的行为。
  • 具体状态(Concrete State)角色：实现抽象状态所对应的行为。

案例实现

对上述电梯的案例使用状态模式进行改进。类图如下：

 

 

 

//抽象状态类
public abstract class LiftState {

    //声明环境角色类变量
    protected Context context;

    public void setContext(Context context) {
        this.context = context;
    }


    protected abstract void open();

    protected abstract void close();

    protected abstract void run();

    protected abstract void stop();
}

 

 

public class Context {


    //定义对应状态对象的常量
    public static final OpeningState OPENING_STATE = new OpeningState();

    public static final ClosingState CLOPENING_STATE = new ClosingState();

    public static final RunningState RUNNING_STATE = new RunningState();

    public static final StoppingState STOPPING_STATE = new StoppingState();

    //定义一个当前电梯状态变量
    private LiftState liftState;

    public LiftState getLiftState() {
        return liftState;
    }

    //设置当前状态对象
    public void setLiftState(LiftState liftState) {
        this.liftState = liftState;
        //设置当前状态对象中的context对象
        this.liftState.setContext(this);
    }


    public void open() {
        this.liftState.open();
    }

    public void close() {
        this.liftState.close();
    }

    public void run() {
        this.liftState.run();
    }

    public void stop() {
        this.liftState.stop();
    }

}

 

 

public class OpeningState extends LiftState{
    //当前状态要执行的状态

    @Override
    protected void open() {
        System.out.println("电梯开启");
    }

    @Override
    protected void close() {
        super.context.setLiftState(Context.CLOPENING_STATE);
        super.context.close();
    }

    @Override
    protected void run() {
        //do noting
    }

    @Override
    protected void stop() {
        //do nothing
    }
}

class ClosingState extends LiftState{
    @Override
    protected void open() {
        super.context.setLiftState(Context.OPENING_STATE);
        super.context.open();
    }

    @Override
    protected void close() {
        System.out.println("电梯门关了");
    }

    @Override
    protected void run() {
        super.context.setLiftState(Context.RUNNING_STATE);
        super.context.run();
    }

    @Override
    protected void stop() {
        super.context.setLiftState(Context.STOPPING_STATE);
        super.context.stop();
    }
}

class RunningState extends LiftState{
    @Override
    protected void open() {
        //do nothing
    }

    @Override
    protected void close() {
        //do nothing
    }

    @Override
    protected void run() {
        System.out.println("电梯正在运行");
    }

    @Override
    protected void stop() {
        super.context.setLiftState(Context.STOPPING_STATE);
        super.context.stop();
    }
}

class StoppingState extends LiftState{
    @Override
    protected void open() {
        super.context.setLiftState(Context.OPENING_STATE);
        super.context.open();
    }

    @Override
    protected void close() {
        super.context.setLiftState(Context.CLOPENING_STATE);
        super.context.close();
    }

    @Override
    protected void run() {
        super.context.setLiftState(Context.RUNNING_STATE);
        super.context.run();
    }

    @Override
    protected void stop() {
        System.out.println("电梯停止了");
    }
}

 

 

public class Client {

    public static void main(String[] args) {
        //创建环境对象角色
        Context context = new Context();
        context.setLiftState(new ClosingState());
        context.open();
        context.run();
        context.close();
        context.stop();

    }
}

 

 

 

 

 

优缺点

优点：

  • 将所有与某个状态有关的行为放到一个类中，并且可以方便地增加新的状态，只需要改变对象状态即可改变对象的行为。
  • 允许状态转换逻辑与状态对象合成一体，而不是某一个巨大的条件语句块。

缺点

  • 状态模式的使用必然会增加系统类和对象的个数。
  • 状态模式的结构与实现都较为复杂，如果使用不当将导致程序结构和代码的混乱。
  • 状态模式对"开闭原则“的支持并不太好。

使用场景

  • 当一个对象的行为取决于它的状态，并且它必须在运行时根据状态改变它的行为时，就可以考虑使用状态模式
  • 一个操作中含有庞大的分支结构，并且这些分支决定于对象的状态时。

 

标签：状态,void,模式,STATE,protected,context,Override,行为,public
From： https://www.cnblogs.com/lpzjava/p/16874803.html

相关文章

  • 单例模式实现的多种方式、pickle序列化模块、选课系统需求分析等
    目录单例模式实现的多种方式方式一：方式二:方式三方式四pickle序列化模块选课系统需求分析功能提炼选课系统架构设计三层架构选课系统目录搭建选课系统功能搭建单例模式实......
  • 判断文件或文件夹(目录)是否存在（状态） C/C++ win/linux通用
    一、windows下使用_access()或linux下使用access()函数判断文件状态windows下使用_access()函数所在头文件：<io.h>函数原型：int_access(constchar*_Filename,int_Acces......
  • 单列模式与pickle模块
    单列模式实现的多种方法单列模式实现的多种方法方式classC1:__instance=Nonedef__init__(self,name,age):self.name=nameself.age......
  • 创建类模式大PK
    创建类模式包括工厂方法模式、创建者模式、抽象工厂模式、单例模式和原型模式，他们能够提供对象的创建和管理职责。创建型模式，就是用来创建对象的模式，抽象了实例化的过程。它......
  • 结构类模式大PK
    结构型模式，顾名思义讨论的是类和对象的结构，它采用继承机制来组合接口或实现（类结构型模式），或者通过组合一些对象，从而实现新的功能（对象结构型模式），结构类模式包括：适配器模式、组......
  • 包装模式大PK
    包装模式包括：装饰模式、适配器模式、门面模式、代理模式、桥梁模式，下面来看看这5个包装模式的区别，用一个追星的例子来加以说明，首先来看代理模式：追星族只需要找代理要签名即......
  • 设计模式利剑三--抽象工厂方法模型
    定   义：为创建一组相关或相互依赖的对象提供一个接口，而且无需指定他们的具体类优   点：           1、封装性，每个产品的实现类不是高层模块要关心的，他们......
  • 门面模式VS中介者模式
          门面模式为复杂的子系统提供给一个统一的访问界面，它定义的而是一个高层接口，该接口使得子系统更加容易使用，避免外部模块深入到子系统内部而产生于子系统内部细......
  • 设计模式利剑4-模板方法模式
    定   义：定义一个操作中的算法的框架，而将一些步骤延迟到子类中，使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤优   点：            1......
  • 设计模式利剑5-建造者模式
    定   义：将一个复杂对象的构建于它的表示分离，使得同样的构建过程可以创建不同的表示优   点：            1、封装性            2、建造者......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99