【设计模式】 - 结构型模式 - 状态模式

桃月十二_

已于 2022-11-24 11:07:14 修改

阅读量130

点赞数

分类专栏：设计模式文章标签：状态模式设计模式

于 2022-11-24 10:55:31 首次发布

本文链接：https://blog.csdn.net/yzx3105/article/details/128012922

版权

设计模式专栏收录该内容

22 篇文章 0 订阅

订阅专栏

目录标题

前言
状态模式

前言

行为型模式用于描述程序在运行时复杂的流程控制，即描述多个类或对象之间怎样相互协作共同完成单个对象都无法单独完成的任务，它涉及算法与对象间职责的分配。
行为型模式分为类行为模式和对象行为模式，前者采用继承机制来在类间分派行为，后者采用组合或聚合在对象间分配行为。由于组合关系或聚合关系比继承关系耦合度低，满足“合成复用原则”，所以对象行为模式比类行为模式具有更大的灵活性。

行为型模式分为：
模板方法模式
策略模式
命令模式
职责链模式
状态模式
观察者模式
中介者模式
迭代器模式
访问者模式
备忘录模式
解释器模式
以上 11 种行为型模式，除了模板方法模式和解释器模式是类行为型模式，其他的全部属于对象行为型模式。

状态模式

概述

Demo

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

实现

电梯接口

public interface ILift {
	//电梯的4个状态
	//开门状态
	public final static int OPENING_STATE = 1;
	//关门状态
	public final static int CLOSING_STATE = 2;
	//运行状态
	public final static int RUNNING_STATE = 3;
	//停止状态
	public final static int STOPPING_STATE = 4;
	//设置电梯的状态
	public void setState(int state);
	//电梯的动作
	public void open();
	public void close();
	public void run();
	public void stop();
}

电梯实现类

public class Lift implements ILift {
	private int state;
	@Override
	public void setState(int state) {
		this.state = state;
	}
	//执行关门动作
	@Override
	public void close() {
		switch (this.state) {
			case OPENING_STATE:
				System.out.println("电梯关门了。。。");//只有开门状态可以关闭电梯门，可以对应电梯状态表来看
				this.setState(CLOSING_STATE);//关门之后电梯就是关闭状态了
				break;
			case CLOSING_STATE:
				//do nothing //已经是关门状态，不能关门
				break;
			case RUNNING_STATE:
				//do nothing //运行时电梯门是关着的，不能关门
				break;
			case STOPPING_STATE:
				//do nothing //停止时电梯也是关着的，不能关门
				break;
		}
	}
	//执行开门动作
	@Override
	public void open() {
		switch (this.state) {
			case OPENING_STATE: //门已经开了，不能再开门了
				//do nothing
				break;
			case CLOSING_STATE: //关门状态，门打开:
				System.out.println("电梯门打开了。。。");
				this.setState(OPENING_STATE);
				break;
			case RUNNING_STATE:
				//do nothing 运行时电梯不能开门
				break;
			case STOPPING_STATE:
				System.out.println("电梯门开了。。。");//电梯停了，可以开门了
				this.setState(OPENING_STATE);
				break;
		}
	}
	//执行运行动作
	@Override
	public void run() {
		switch (this.state) {
			case OPENING_STATE: //电梯不能开着门就走
				//do nothing
				break;
			case CLOSING_STATE: //门关了，可以运行了
				System.out.println("电梯开始运行了。。。");
				this.setState(RUNNING_STATE);//现在是运行状态
				break;
			case RUNNING_STATE:
				//do nothing 已经是运行状态了
				break;
			case STOPPING_STATE:
				System.out.println("电梯开始运行了。。。");
				this.setState(RUNNING_STATE);
				break;
		}
	}
	//执行停止动作
	@Override
	public void stop() {
		switch (this.state) {
			case OPENING_STATE: //开门的电梯已经是是停止的了(正常情况下)
				//do nothing
				break;
			case CLOSING_STATE: //关门时才可以停止
				System.out.println("电梯停止了。。。");
				this.setState(STOPPING_STATE);
				break;
			case RUNNING_STATE://运行时当然可以停止了
				System.out.println("电梯停止了。。。");
				this.setState(STOPPING_STATE);
				break;
			case STOPPING_STATE:
				//do nothing
				break;
		}
	}
}

测试类

public class Client {
	public static void main(String[] args) {
		Lift lift = new Lift();
		lift.setState(ILift.OPENING_STATE);//开门状态
		lift.open();//开门
		lift.close();//关门
		lift.run();//运行
		lift.stop();//停止
	}
}

执行结果在这里插入图片描述

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…case这样的判断（if…else也是一样)，使程序的可阅读性变差。
扩展性很差。如果新加了断电的状态，我们需要修改上面判断逻辑。

状态模式定义

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

结构

抽象状态（State）角色：定义一个接口，封装了状态及其行为。
具体状态（Concrete State）角色：State的实现类，表示具体的状态。
环境（Context）角色：保持并切换各个状态，其持有一个State的引用。它将依赖状态的各种操作委托给不同的状态对象执行。其负责与客户端交互
在这里插入图片描述

实现

demo1: 对上述电梯的案例使用状态模式进行改进。

在这里插入图片描述
抽象状态类

public abstract class LiftState {
	//定义一个环境角色，也就是封装状态的变化引起的功能变化
	protected Context context;
	public void setContext(Context context) {
		this.context = context;
	}
	//电梯开门动作
	public abstract void open();
	//电梯关门动作
	public abstract void close();
	//电梯运行动作
	public abstract void run();
	//电梯停止动作
	public abstract void stop();
}

开启状态

public class OpenningState extends LiftState {
	//开启当然可以关闭了，我就想测试一下电梯门开关功能
	@Override
	public void open() {
		System.out.println("电梯门开启...");
	}
	@Override
	public void close() {
		//状态修改
		super.context.setLiftState(Context.closeingState);
		//动作委托为CloseState来执行，也就是委托给了ClosingState子类执行这个动作
		super.context.getLiftState().close();
	}
	//电梯门不能开着就跑，这里什么也不做
	@Override
	public void run() {
		//do nothing
	}
	//开门状态已经是停止的了
	@Override
	public void stop() {
		//do nothing
	}
}

运行状态

public class RunningState extends LiftState {
	//运行的时候开电梯门？你疯了！电梯不会给你开的
	@Override
	public void open() {
		//do nothing
	}
	//电梯门关闭？这是肯定了
	@Override
	public void close() {//虽然可以关门，但这个动作不归我执行
		//do nothing
	}
	//这是在运行状态下要实现的方法
	@Override
	public void run() {
		System.out.println("电梯正在运行...");
	}
	//这个事绝对是合理的，光运行不停止还有谁敢做这个电梯？！估计只有上帝了
	@Override
	public void stop() {
		super.context.setLiftState(Context.stoppingState);
		super.context.stop();
	}
}

停止状态

public class StoppingState extends LiftState {
	//停止状态，开门，那是要的！
	@Override
	public void open() {
		//状态修改
		super.context.setLiftState(Context.openningState);
		//动作委托为CloseState来执行，也就是委托给了ClosingState子类执行这个动作
		super.context.getLiftState().open();
	}
	@Override
	public void close() {//虽然可以关门，但这个动作不归我执行
		//状态修改
		super.context.setLiftState(Context.closeingState);
		//动作委托为CloseState来执行，也就是委托给了ClosingState子类执行这个动作
		super.context.getLiftState().close();
	}
	//停止状态再跑起来，正常的很
	@Override
	public void run() {
		//状态修改
		super.context.setLiftState(Context.runningState);
		//动作委托为CloseState来执行，也就是委托给了ClosingState子类执行这个动作
		super.context.getLiftState().run();
	}
	//停止状态是怎么发生的呢？当然是停止方法执行了
	@Override
	public void stop() {
		System.out.println("电梯停止了...");
	}
}

关闭状态

public class ClosingState extends LiftState {
	@Override
	//电梯门关闭，这是关闭状态要实现的动作
	public void close() {
		System.out.println("电梯门关闭...");
	}
	//电梯门关了再打开，逗你玩呢，那这个允许呀
	@Override
	public void open() {
		super.context.setLiftState(Context.openningState);
		super.context.open();
	}
	//电梯门关了就跑，这是再正常不过了
	@Override
	public void run() {
		super.context.setLiftState(Context.runningState);
		super.context.run();
	}
	//电梯门关着，我就不按楼层
	@Override
	public void stop() {
		super.context.setLiftState(Context.stoppingState);
		super.context.stop();
	}
}

环境角色

public class Context {
	//定义出所有的电梯状态
	public final static OpenningState openningState = new OpenningState();//开门状态，这时候电梯只能关闭
	public final static ClosingState closeingState = new ClosingState();//关闭状态，这时候电梯可以运行、停止和开门
	public final static RunningState runningState = new RunningState();//运行状态，这时候电梯只能停止
	public final static StoppingState stoppingState = new StoppingState();//停止状态，这时候电梯可以开门、运行
	//定义一个当前电梯状态
	private LiftState liftState;
	public LiftState getLiftState() {
		return this.liftState;
	}
	public void setLiftState(LiftState liftState) {
		//当前环境改变
		this.liftState = liftState;
		//把当前的环境通知到各个实现类中
		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 Client {
	public static void main(String[] args) {
		Context context = new Context();
		context.setLiftState(new ClosingState());
		context.open();
		context.close();
		context.run();
		context.stop();
	}
}

demo2

最近王二狗又要过生日了，近两年他内心中是非常抗拒过生日的，因为每过一个生日就意味着自己又老一岁，离被辞退的35岁魔咒又近了一步。可惜时间是不以人的意志为转移的，任何人都阻止不了时间的流逝，所以该过还的过。令二狗比较欣慰的时，这次过生日老婆送了他一个自己一直想要的机械键盘作为生日礼物… 翠花于是在二狗生日前3天在京东上下了一个单…
自从下单以来，二狗天天看物流状态信息，心心念念着自己的机械键盘快点到…
这个物流系统就很适合使用状态模式来开发，因为此过程存在很多不同的状态，例如接单，出库，运输，送货，收货，评价等等。而订单在每个不同的状态下的操作可能都不一样，例如在接单状态下，商家就需要通知仓库拣货，通知用户等等操作，其他状态类似

下面是实例的UML类图
在这里插入图片描述
状态接口：此接口定义各个状态的统一操作接口

public interface LogisticsState {
    void doAction(JdLogistics context);
}

物流Context类：此类持有一个LogisticsState 的引用，负责在流程中保持并切换状态

public class JdLogistics {
    private LogisticsState logisticsState;

    public void setLogisticsState(LogisticsState logisticsState) {
        this.logisticsState = logisticsState;
    }

    public LogisticsState getLogisticsState() {
        return logisticsState;
    }

    public void doAction(){
        logisticsState.doAction(this);
    }
}

实现各种状态类
接单状态类，其需要实现LogisticsState接口

public class OrderState implements LogisticsState {
    @Override
    public void doAction(JdLogistics context) {
        System.out.println("商家已经接单，正在处理中...");
    }
}

出库状态类

public class ProductOutState implements LogisticsState {
    @Override
    public void doAction(JdLogistics context) {
        System.out.println("商品已经出库...");
    }
}

依次类推，可以建立任意多个状态类
测试类

public class StateClient {

    public void buyKeyboard() {
        //状态的保持与切换者
        JdLogistics jdLogistics = new JdLogistics();

        //接单状态
        OrderState orderState = new OrderState();
        jdLogistics.setLogisticsState(orderState);
        jdLogistics.doAction();

        //出库状态
        ProductOutState productOutState = new ProductOutState();
        jdLogistics.setLogisticsState(productOutState);
        jdLogistics.doAction();

        //运输状态
        TransportState transportState = new TransportState();
        jdLogistics.setLogisticsState(transportState);
        jdLogistics.doAction();
    }
}

商家已经接单，正在处理中...
商品已经出库...
商品正在运往天津分发中心

技术要点总结

必须要有一个Context类，这个类持有State接口，负责保持并切换当前的状态。
状态模式没有定义在哪里进行状态转换，demo2是在Context类进行的，有的是在State类中转换。

当使用Context类切换状态时，状态类之间互相不认识，他们直接的依赖关系应该由客户端负责。
例如，只有在接单状态的操作完成后才应该切换到出库状态，那么出库状态就对接单状态有了依赖，这个依赖顺序应该由客户端负责，而不是在状态内判断。

当使用具体的State类切换时，状态直接就可能互相认识，一个状态执行完就自动切换到了另一个状态去了

优缺点、应用场景

优点
增强了程序的可扩展性，因为我们很容易添加一个State
增强了程序的封装性，每个状态的操作都被封装到了一个状态类中
缺点
类变多了
使用场景
当一个对象的行为取决于它的状态，并且它必须在运行时根据状态改变它的行为时，就可以考虑使用状态模式。
一个操作中含有庞大的分支结构，并且这些分支决定于对象的状态时。

状态模式与策略模式

状态模式与策略模式的UML类图都是一样的，从表面上看他们非常相似。特别是将状态切换任务放在Context中做的时候就更像了，但是其背后的思想却非常不同。

策略模式定义了一组可互相代替的算法，这一组算法对象完成的是同一个任务，只是使用的方式不同，例如同样是亿万富翁，马云通过卖东西实现，而王思聪通过继承实现。
状态模式不同的状态完成的任务完全不一样。

来源：https://zhuanlan.zhihu.com/p/369732910
https://www.bilibili.com/video/BV1Np4y1z7BU?p=114&vd_source=b901ef0e9ed712b24882863596eab0ca

桃月十二_

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
【设计模式】 - 结构型模式 - 状态模式

通过按钮来控制一个电梯的状态，一个电梯有开门状态，关门状态，停止状态，运行状态。每一种状态改变，都有可能要根据其他状态来更新处理。例如，如果电梯门现在处于运行时状态，就不能进行开门操作，而如果电梯门是停止状态，就可以执行开门操作。对有状态的对象，把复杂的“判断逻辑”提取到不同的状态对象中，允许状态对象在其内部状态发生改变时改变其行为。必须要有一个Context类，这个类持有State接口，负责保持并切换当前的状态。
复制链接

扫一扫

专栏目录