设计模式-状态模式(State)

允许一个对象内部状态改变时改变它的行为,对象看起来似乎修改了它的类

问题:

状态模式和有限状态机紧密相关。其主要思想是程序在任意时刻仅可处于几种有限的状态中。 在任何一个特定状态中, 程序的行为都不相同, 且可瞬间从一个状态切换到另一个状态。 不过, 根据当前状态, 程序可能会切换到另外一种状态, 也可能会保持当前状态不变。 这些数量有限且预先定义的状态切换规则被称为转移。而状态判断通常是由比较多的条件判断语句实现(而过多的状态判断会导致我们项目维护变得更加困难,而且还很臃肿),也可以依据当前对象状态选择响应的行为。

解决方案:

状态模式建议为对象的所有可能状态新建一个类, 然后将所有状态的对应行为抽取到这些类中。

原始对象被称为上下文 (context), 它并不会自行实现所有行为, 而是会保存一个指向表示当前状态的状态对象的引用, 且将所有与状态相关的工作委派给该对象。

文档将工作委派给一个状态对象文档将工作委派给一个状态对象。如需将上下文转换为另外一种状态, 则需将当前活动的状态对象替换为另外一个代表新状态的对象。 采用这种方式是有前提的: 所有状态类都必须遵循同样的接口, 而且上下文必须仅通过接口与这些对象进行交互。

这个结构可能看上去与策略模式相似, 但有一个关键性的不同------在状态模式中, 特定状态知道其他所有状态的存在, 且能触发从一个状态到另一个状态的转换; 策略则几乎完全不知道其他策略的存在。

状态模式结构和其角色

在 Java 语言中, 状态模式通常被用于将基于 switch语句的大型状态机转换为对象。

这里是核心 Java 程序库中一些状态模式的示例:

javax.faces.lifecycle.LifeCycle#execute() (由Faces­Servlet控制: 行为依赖于当前 JSF 生命周期的阶段 (状态))

识别方法: 状态模式可通过受外部控制且能根据对象状态改变行为的方法来识别。

上代码:

public abstract class State {
    Player player;

    State(Player player) {
        this.player = player;
    }

    public abstract String onLock();
    public abstract String onPlay();
    public abstract String onNext();
    public abstract String onPrevious();
}

public class LockedState extends State {

    LockedState(Player player) {
        super(player);
        player.setPlaying(false);
    }

    @Override
    public String onLock() {
        if (player.isPlaying()) {
            player.changeState(new ReadyState(player));
            return "Stop playing";
        } else {
            return "Locked...";
        }
    }

    @Override
    public String onPlay() {
        player.changeState(new ReadyState(player));
        return "Ready";
    }

    @Override
    public String onNext() {
        return "Locked...";
    }

    @Override
    public String onPrevious() {
        return "Locked...";
    }
}

public class ReadyState extends State {

    public ReadyState(Player player) {
        super(player);
    }

    @Override
    public String onLock() {
        player.changeState(new LockedState(player));
        return "Locked...";
    }

    @Override
    public String onPlay() {
        String action = player.startPlayback();
        player.changeState(new PlayingState(player));
        return action;
    }

    @Override
    public String onNext() {
        return "Locked...";
    }

    @Override
    public String onPrevious() {
        return "Locked...";
    }
}

public class Player {
    private State state;
    private boolean playing = false;
    private List<String> playlist = new ArrayList<>();
    private int currentTrack = 0;

    public Player() {
        this.state = new ReadyState(this);
        setPlaying(true);
        for (int i = 1; i <= 12; i++) {
            playlist.add("Track " + i);
        }
    }

    public void changeState(State state) {
        this.state = state;
    }

    public State getState() {
        return state;
    }

    public void setPlaying(boolean playing) {
        this.playing = playing;
    }

    public boolean isPlaying() {
        return playing;
    }

    public String startPlayback() {
        return "Playing " + playlist.get(currentTrack);
    }

    public String nextTrack() {
        currentTrack++;
        if (currentTrack > playlist.size() - 1) {
            currentTrack = 0;
        }
        return "Playing " + playlist.get(currentTrack);
    }

    public String previousTrack() {
        currentTrack--;
        if (currentTrack < 0) {
            currentTrack = playlist.size() - 1;
        }
        return "Playing " + playlist.get(currentTrack);
    }

    public void setCurrentTrackAfterStop() {
        this.currentTrack = 0;
    }
}

public class Client{
   private Player player;
   public Client(Player player){
       this.player =  player;
   }

  public void test(){

    System.out.println( player.getState().onPlay());
    System.out.println( player.getState().onLock());
     System.out.println( player.getState().onNext());
     System.out.println( player.getState().onPrevious());
  }
}

测试:

public class Demo {
    public static void main(String[] args) {
        Player player = new Player();
        Client client = new Client(player);
        client.test();
    }
}

Paused...

Stop playing

Locked...

Locked...

状态模式适合应用场景

  1. 如果对象需要根据自身当前状态进行不同行为, 同时状态的数量非常多且与状态相关的代码会频繁变更的话, 可使用状态模式。
  2. 模式建议你将所有特定于状态的代码抽取到一组独立的类中。 这样一来, 你可以在独立于其他状态的情况下添加新状态或修改已有状态, 从而减少维护成本。
  3. 如果某个类需要根据成员变量的当前值改变自身行为, 从而需要使用大量的条件语句时, 可使用该模式。
  4. 状态模式会将这些条件语句的分支抽取到相应状态类的方法中。 同时, 你还可以清除主要类中与特定状态相关的临时成员变量和帮手方法代码。
  5. 当相似状态和基于条件的状态机转换中存在许多重复代码时, 可使用状态模式。
  6. 状态模式让你能够生成状态类层次结构, 通过将公用代码抽取到抽象基类中来减少重复。

如果状态机只有很少的几个状态, 或者很少发生改变,则无需使用此模型。

相关推荐
gjh12085 分钟前
设计模式:工厂方法模式和策略模式
设计模式·工厂方法模式·策略模式
shinelord明1 小时前
【再谈设计模式】抽象工厂模式~对象创建的统筹者
数据结构·算法·设计模式·软件工程·抽象工厂模式
前端拾光者2 小时前
前端开发设计模式——责任链模式
设计模式·责任链模式
liang89993 小时前
设计模式之策略模式(Strategy)
设计模式·策略模式
马剑威(威哥爱编程)4 小时前
读写锁分离设计模式详解
java·设计模式·java-ee
修道-03234 小时前
【JAVA】二、设计模式之策略模式
java·设计模式·策略模式
fanxbl9575 小时前
Electron 项目实现下载文件监听
javascript·electron·状态模式
G皮T8 小时前
【设计模式】结构型模式(四):组合模式、享元模式
java·设计模式·组合模式·享元模式·composite·flyweight
W_Meng_H8 小时前
设计模式-组合模式
设计模式·组合模式
吾与谁归in18 小时前
【C#设计模式(8)——过滤器模式(Adapter Pattern)】
设计模式·c#·过滤器模式