状态模式(State Pattern) —— 让你的对象学会72变

当一个对象内在状态改变时允许其改变行为，这个对象看起来像改变了其类。

一、怎么理解一个对象有多个状态？

一个对象和多个状态关联，每种状态又对应一种行为，也就是同一个对象会因为状态不同让你觉得这是不是同一个类。

比如，手机的HOME键：

关机状态: 没有反应。
开机后首次启动: 密码解锁。
非首次启动: 密码解锁或者指纹解锁。
启动后：返回主页面。

这里因为手机状态的不同，HOME键就有不同的功能或者行为。

同样是HOME键给人们的感觉好像是好多的按键，好像不再是同一个类。

也就是说对象的行为依赖于它的状态（属性），并且可以根据它的状态改变而改变它的相关行为。

二、怎么去实现？

上面的对象因为状态不同而出现不同行为的场景怎么去实现？

你可能会想到 if/else 那种方式去实现，代码中包含大量与对象状态有关的条件语句，满足不同的条件就选择执行对应的行为。

但这种方式在介绍策略模式的时候也说过它的缺点，难维护、难扩展，违背开闭原则。

使用状态模式就可以很好的规避这个问题，状态模式将各种具体的状态类抽象出来，把受环境改变的对象行为包装在不同的状态对象里，其意图是让一个对象在其内部状态改变的时候，其行为也随之改变。这段红色的字已经说清楚了状态模式的实现方式：

抽象状态类：

abstract class State {
    public abstract void Handle(Context context);
}

具体状态类：

/**
 * 具体状态类 A
 */
class ConcreteStateA extends State {
    public void Handle(Context context) {
        System.out.println("当前状态是 A.");
        // 改变状态
        context.setState(new ConcreteStateB());
    }
}

/**
 * 具体状态类 B
 */
class ConcreteStateB extends State {
    public void Handle(Context context) {
        System.out.println("当前状态是 B.");
        // 改变状态
        context.setState(new ConcreteStateA());
    }
}

上下文环境类：

class Context {
    private State state;

    //定义环境类的初始状态
    public Context(State state) {
        this.state = state;
    }

    //设置新状态
    public void setState(State state) {
        this.state = state;
    }

    //读取状态
    public State getState() {
        return (state);
    }

    //对请求做处理
    public void Handle() {
        state.Handle(this);
    }
}

public class Client {
    public static void main(String[] args) {
        State state = new ConcreteStateA();
        //创建环境
        Context context = new Context(state);
        //处理请求
        context.Handle();
        context.Handle();
        context.Handle();
        context.Handle();
    }
}

三、用“状态模式”设计一个多线程的状态转换程序

现在先定义一个抽象状态类（TheadState），然后为上图的每个状态设计一个具体状态类，它们是新建状态（New）、就绪状态（Runnable ）、运行状态（Running）、阻塞状态（Blocked）和死亡状态（Dead），每个状态中有触发它们转变状态的方法，环境类（ThreadContext）中先生成一个初始状态（New），并提供相关触发方法，下图所示是线程状态转换程序的结构图：

abstract class ThreadState {
    //状态名
    protected String stateName;
}

//具体状态类：新建状态
class New extends ThreadState {
    public New() {
        stateName = "新建状态";
        System.out.println("当前线程处于：新建状态.");
    }

    public void start(ThreadContext context) {
        System.out.print("调用start()方法-->");
        if (stateName.equals("新建状态")) {
            // 启动新线程，并改变状态
            context.setState(new Runnable());
        } else {
            System.out.println("当前线程不是新建状态，不能调用start()方法.");
        }
    }
}

//具体状态类：就绪状态
class Runnable extends ThreadState {
    public Runnable() {
        stateName = "就绪状态";
        System.out.println("当前线程处于：就绪状态.");
    }

    public void getCPU(ThreadContext context) {
        System.out.print("获得CPU时间-->");
        if (stateName.equals("就绪状态")) {
            // 改变状态 —— 变成运行状态
            context.setState(new Running());
        } else {
            System.out.println("当前线程不是就绪状态，不能获取CPU分片.");
        }
    }
}

//具体状态类：运行状态
class Running extends ThreadState {
    public Running() {
        stateName = "运行状态";
        System.out.println("当前线程处于：运行状态.");
    }

    public void suspend(ThreadContext context) {
        System.out.print("调用suspend()方法-->");
        if (stateName.equals("运行状态")) {
            context.setState(new Blocked());
        } else {
            System.out.println("当前线程不是运行状态，不能调用suspend()方法.");
        }
    }

    public void stop(ThreadContext context) {
        System.out.print("调用stop()方法-->");
        if (stateName.equals("运行状态")) {
            context.setState(new Dead());
        } else {
            System.out.println("当前线程不是运行状态，不能调用stop()方法.");
        }
    }
}

//具体状态类：阻塞状态
class Blocked extends ThreadState {
    public Blocked() {
        stateName = "阻塞状态";
        System.out.println("当前线程处于：阻塞状态.");
    }

    public void resume(ThreadContext context) {
        System.out.print("调用resume()方法-->");
        if (stateName.equals("阻塞状态")) {
            context.setState(new Runnable());
        } else {
            System.out.println("当前线程不是阻塞状态，不能调用resume()方法.");
        }
    }
}

//具体状态类：死亡状态
class Dead extends ThreadState {
    public Dead() {
        stateName = "死亡状态";
        System.out.println("当前线程处于：死亡状态.");
    }
}

class ThreadContext {
    private ThreadState state;

    ThreadContext() {
        state = new New();
    }

    public void setState(ThreadState state) {
        this.state = state;
    }

    public ThreadState getState() {
        return state;
    }

    public void start() {
        ((New) state).start(this);
    }

    public void getCPU() {
        ((Runnable) state).getCPU(this);
    }

    public void suspend() {
        ((Running) state).suspend(this);
    }

    public void stop() {
        ((Running) state).stop(this);
    }

    public void resume() {
        ((Blocked) state).resume(this);
    }

    public void startWork (){
        this.start();
        this.getCPU();
        this.suspend();
        this.resume();
        this.getCPU();
        this.stop();

    }
}

public class Client {
    public static void main(String[] args) {
        ThreadContext context = new ThreadContext();
        context.startWork();
    }
}

当前线程处于：新建状态.
调用start()方法-->当前线程处于：就绪状态.
获得CPU时间-->当前线程处于：运行状态.
调用suspend()方法-->当前线程处于：阻塞状态.
调用resume()方法-->当前线程处于：就绪状态.
获得CPU时间-->当前线程处于：运行状态.
调用stop()方法-->当前线程处于：死亡状态.

四、适用场景

优点

状态模式将与特定状态相关的行为局部化到一个状态中，并且将不同状态的行为分割开来，满足“单一职责原则”。
减少对象间的相互依赖。将不同的状态引入独立的对象中会使得状态转换变得更加明确，且减少对象间的相互依赖。
有利于程序的扩展。通过定义新的子类很容易地增加新的状态和转换。

缺点

状态模式的使用必然会增加系统的类与对象的个数。
状态模式的结构与实现都较为复杂，如果使用不当会导致程序结构和代码的混乱。

应用场景

通常在以下情况下可以考虑使用状态模式。

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

posted @ 2022-06-25 14:02 沙滩de流沙阅读(54) 评论(0) 编辑收藏举报

刷新页面返回顶部