目录
- 1.概述
- 2.结构
- 3.案例实现
- 3.1.抽象状态类
- 3.2.具体状态类
- 3.3.上下文类
- 3.4.测试
- 4.优缺点
- 5.使用场景
1.概述
【例】通过按钮来控制一个电梯的状态,电梯有开门状态,关门状态,停止状态,运行状态。每一种状态改变,都有可能要根据其他状态来更新处理。例如,如果电梯门现在处于运行时状态,就不能进行开门操作,而如果电梯门是停止状态,就可以执行开门操作。其类图如下:
具体实现代码如下:
ILift.java
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();
}
Lift.java
//电梯类(ILift 接口的实现类)
public class Lift implements ILift {//声明一个记录当前电梯的状态private int state;public void setState(int state) {this.state = state;}public void open() {switch (state) { //当前电梯状态case OPENING_STATE ://什么事都不做break;case CLOSING_STATE :System.out.println("电梯打开了...");//设置当前电梯状态为开启状态setState(OPENING_STATE);break;case STOPPING_STATE :System.out.println("电梯打开了...");//设置当前电梯状态为开启状态setState(OPENING_STATE);break;case RUNNING_STATE ://什么事都不做break;}}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;}}public void run() {switch (this.state) {case OPENING_STATE: //电梯不能开着门就走//do nothingbreak;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;}}public void stop() {switch (this.state) {case OPENING_STATE: //开门的电梯已经是是停止的了(正常情况下)//do nothingbreak;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 nothingbreak;}}
}
Client.java
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();}
}
问题分析:
- 使用了大量的
switch…case
这样的判断(换成if…else
也是一样),使程序的可读性变差。 - 扩展性很差,如果新加了断电的状态,则需要修改上面的判断逻辑。
(2)状态模式 (State Pattern) 是一种行为型设计模式,它允许在一个对象内部状态改变时改变它的行为。状态模式将状态封装成独立的类,并将动作委托给代表当前状态的对象,以此实现状态转换时的行为变化。使用状态模式,我们可以将状态转换规则封装在不同状态类中,让上下文对象从复杂的状态转换逻辑中解耦出来,同时利用多态特性让状态转换具有扩展性和灵活性。
2.结构
状态模式包含以下主要角色:
- 上下文 (Context) 角色:是一个包含状态的对象,它在运行时根据不同的状态改变其行为。上下文对象持有一个对当前状态的引用,并将具体的操作委托给当前状态对象处理。
- 抽象状态 (Abstract State) 角色:定义了一个公共的接口,用于封装不同状态的行为。可以是一个抽象类或接口,并声明了在不同状态下可能发生的方法。
- 具体状态 (Concrete State) 角色:实现了抽象状态接口,并定义了在对应状态下具体的行为。每个具体状态类都封装了一种特定状态的行为。
3.案例实现
对上述电梯的案例使用状态模式进行改进。类图如下:
具体实现代码如下:
3.1.抽象状态类
LiftState.java()
//抽象状态类
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();
}
3.2.具体状态类
OpeningState.java
//电梯开启状态类
public class OpeningState extends LiftState {//当前状态要执行的方法public void open() {System.out.println("电梯开启。。。");}public void close() {//修改状态super.context.setLiftState(Context.CLOSING_STATE);//调用当前状态中的context中的close方法super.context.close();}public void run() {//什么都不做}public void stop() {//什么都不做}
}
ClosingState.java
//电梯关闭状态类
public class ClosingState extends LiftState {@Override//电梯门关闭,这是关闭状态要实现的动作public void close() {System.out.println("电梯门关闭...");}//电梯门关了再打开,逗你玩呢,那这个允许呀@Overridepublic void open() {super.context.setLiftState(Context.OPENING_STATE);super.context.open();}//电梯门关了就跑,这是再正常不过了@Overridepublic void run() {super.context.setLiftState(Context.RUNNING_STATE);super.context.run();}//电梯门关着,我就不按楼层@Overridepublic void stop() {super.context.setLiftState(Context.STOPPING_STATE);super.context.stop();}
}
RunningState.java
//电梯运行状态类
public class RunningState extends LiftState {//运行的时候开电梯门?你疯了!电梯不会给你开的@Overridepublic void open() {//do nothing}//电梯门关闭?这是肯定了@Overridepublic void close() {//虽然可以关门,但这个动作不归我执行//do nothing}//这是在运行状态下要实现的方法@Overridepublic void run() {System.out.println("电梯正在运行...");}//这个事绝对是合理的,光运行不停止还有谁敢做这个电梯?!估计只有上帝了@Overridepublic void stop() {super.context.setLiftState(Context.STOPPING_STATE);super.context.stop();}
}
StoppingState.java
//电梯停止状态类
public class StoppingState extends LiftState {//停止状态,开门,那是要的!@Overridepublic void open() {//状态修改super.context.setLiftState(Context.OPENING_STATE);//动作委托为CloseState来执行,也就是委托给了 ClosingState 子类执行这个动作super.context.getLiftState().open();}@Overridepublic void close() {//虽然可以关门,但这个动作不归我执行//状态修改super.context.setLiftState(Context.CLOSING_STATE);//动作委托为 CloseState 来执行,也就是委托给了 ClosingState 子类执行这个动作super.context.getLiftState().close();}//停止状态再跑起来,正常的很@Overridepublic void run() {//状态修改super.context.setLiftState(Context.RUNNING_STATE);//动作委托为 CloseState 来执行,也就是委托给了 ClosingState 子类执行这个动作super.context.getLiftState().run();}//停止状态是怎么发生的呢?当然是停止方法执行了@Overridepublic void stop() {System.out.println("电梯停止了...");}
}
3.3.上下文类
Context.java
//环境角色类
public class Context {//定义对应状态对象的常量public final static OpeningState OPENING_STATE = new OpeningState();public final static ClosingState CLOSING_STATE = new ClosingState();public final static RunningState RUNNING_STATE = new RunningState();public final static 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();}
}
3.4.测试
Client.java
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();}
}
4.优缺点
- 优点:
- 将状态封装成独立的类,使得状态转换的逻辑更加清晰,避免了大量的条件判断语句。
- 将状态和状态切换的行为分离,使得状态转换的代码可扩展和可维护。增加新的状态类或修改现有的状态类时,对上下文对象和其他状态类都没有影响。
- 增强了代码的可读性和可维护性。每个状态都有自己的类,使得代码具备了良好的结构化,并且易于理解和修改。
- 通过引入多态性,可以方便地增加新的状态类,而不需要修改现有的代码。
- 缺点:
- 如果状态类很多,可能会导致类的数量庞大,增加了代码的复杂性。
- 状态类的创建和销毁需要维护和管理,可能会增加系统的开销。
- 当状态转换的逻辑较为简单时,使用状态模式可能会显得过于繁琐。
5.使用场景
(1)状态模式适用于以下情况:
- 当一个对象的行为取决于其内部状态,并且在不同状态下需要有不同的行为时,可以使用状态模式。例如,订单状态的改变会导致不同的操作和行为,可以使用状态模式来管理订单的状态转换。
- 当有大量的条件语句用于根据不同状态执行不同操作时,可以使用状态模式来简化代码并提高可维护性。
- 当一个对象的行为需要根据多个条件进行判断,并且这些条件随着时间的推移可能会发生变化时,可以使用状态模式。通过将每个条件封装为一个状态类,可以方便地添加、修改或删除状态,而不会对其他部分产生影响。
- 当需要在运行时动态改变对象的行为时,可以使用状态模式。通过改变对象的状态,可以改变其行为,而不需要修改对象的代码。
(2)总之,状态模式适用于需要根据对象的内部状态来改变其行为,并且希望将状态转换逻辑封装在独立的状态类中的情况。它提供了一种清晰、灵活和可扩展的方式来管理对象的状态和行为。