状态模式

前言

状态模式也是行为型设计模式，设计的初衷是应对同一个对象里不同状态变化时的不同行为的变化。

目录

一、定义

当一个对象内在状态改变时允许其改变行为，这个对象看起来像改变了其类。简单点来说，就是通过定义一个状态变量，通过这个状态变量，控制自身行为。

二、模式原理分析

我们模拟电梯开门、关门的例子

//1.抽象电梯状态
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();
}
//2.上下文  各种状态
public class Context{
    public final static ClosingState closeingState = new ClosingState();
    public final static RunningState runningState = new RunningState();
    public final static StoppingState stoppingState = new StoppingState();
    
    //定义一个当前电梯状态
    private LiftSate liftState;
    public LiftState getLiftState(){
        return liftState;
    }
    public void setLiftState(LiftState liftState){
        this.liftState = listState;
        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.开门状态
public class OpenngingState extends LiftState{
    @Override
    public void close(){
        //状态修改
        super.context.setLifeState(Context.closeingState);
        //委托给CloseState来执行
        super.context.getLiftState().close();
    }
    @Override
    public void open(){
        System.out.println("电梯门开启");
    }
    @Override
    public void run(){
        //电梯运行
    }
    @Override
    public void stop(){
        //电梯停止
    }
}
//4.关闭状态
public class OpenngingState extends LiftState{
    @Override
    public void close(){
     	System.out.println("电梯门关门");
        
    }
    @Override
    public void open(){
       //状态修改
        super.context.setLifeState(Context.openningState);
        super.context.getLiftState().open();
    }
    @Override
    public void run(){
        super.context.setLifeState(Context.runingState);
        super.context.getLiftState().run();
    }
    @Override
    public void stop(){
        super.context.setLifeState(Context.stoppingState);
        super.context.getLiftState().stop();
    }
}
//5.运行状态
public class RunningState extends LifeState{
    @Override
    public void close(){
        
    }
    @Override
    public void open(){
     
    }
    @Override
    public void run(){
        System.out.println("电梯上下运行");
    }
    @Override
    public void stop(){
        super.context.setLifeState(Context.stoppingState);
        super.context.getLiftState().stop();
    }
}
//6.停止状态
public class RunningState extends LifeState{
    @Override
    public void close(){
        
    }
    @Override
    public void open(){
        super.context.setLifeState(Context.openningState);
        super.context.getLiftState().open();
    }
    @Override
    public void run(){
        super.context.setLifeState(Context.runningState);
        super.context.getLiftState().run();
    }
    @Override
    public void stop(){
        System.out.println("电梯停止运行了，到楼层了");
    }
}
//7.场景类
public class Client{
    public static void main(String[] args){
        Context context = new Context();
        context.setLiftState(new CloseingState());
        context.open();
        context.close();
        context.run();
        context.stop();
    }
}
复制代码

三、使用场景

• 行为随状态改变而改变的场景，如购物订单变化、电梯运行状态

• 条件、分支判断语句的替代者

四、优点

• 避免大量的if-else语句，结构清晰

• 快速理解状态和行为之间的关系

• 遵循设计原则，每个状态都是一个子类，新增和修改都是针对子类，体现了单一职责原则

五、缺点

• 很多状态就会有很多子类，造成很多零散类，

• 状态切换关系复杂，每个状态间的关系需要很好的理解，维护成本增加