设计模式：行为型-状态模式

缺乏、安全感 2022-11-18 01:49 208阅读 0赞

### 目录 ###

*  第一章 状态模式介绍
 *  第二章 状态模式实现
 *   *  2.1、环境类
     *  2.2、抽象状态类
     *  2.3、具体状态类
     *  2.4、测试类
 *  第三章 状态模式应用
 *   *  3.1、环境类
     *  3.2、抽象状态类
     *  3.3、具体状态类
     *  3.4、测试类

--------------------

> 项目地址：https://gitee.com/caochenlei/design-pattern

# 第一章 状态模式介绍 #

状态模式的介绍：

在软件开发过程中，应用程序中的部分对象可能会根据不同的情况做出不同的行为，我们把这种对象称为有状态的对象，而把影响对象行为的一个或多个动态变化的属性称为状态。当有状态的对象与外部事件产生互动时，其内部状态就会发生改变，从而使其行为也发生改变。如人都有高兴和伤心的时候，不同的情绪有不同的行为，当然外界也会影响其情绪变化。

对这种有状态的对象编程，传统的解决方案是：将这些所有可能发生的情况全都考虑到，然后使用 if-else 或 switch-case 语句来做状态判断，再进行不同情况的处理。但是显然这种做法对复杂的状态判断存在天然弊端，条件判断语句会过于臃肿，可读性差，且不具备扩展性，维护难度也大。且增加新的状态时要添加新的 if-else 语句，这违背了“开闭原则”，不利于程序的扩展。

以上问题如果采用“状态模式”就能很好地得到解决。在状态模式（State Pattern）中，类的行为是基于它的状态改变的。这种类型的设计模式属于行为型模式。在状态模式中，我们创建表示各种状态的对象和一个行为随着状态对象改变而改变的 context 对象。

状态模式的优点：

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

状态模式的缺点：

*  状态模式的使用必然会增加系统的类与对象的个数。
 *  状态模式的结构与实现都较为复杂，如果使用不当会导致程序结构和代码的混乱。
 *  状态模式对开闭原则的支持并不太好，对于可以切换状态的状态模式，增加新的状态类需要修改那些负责状态转换的源码，否则无法切换到新增状态，而且修改某个状态类的行为也需要修改对应类的源码。

状态模式的场景：

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

状态模式的角色：

*  环境类（Context）角色：也称为上下文，它定义了客户端需要的接口，内部维护一个当前状态，并负责具体状态的切换。
 *  抽象状态（State）角色：定义一个接口，用以封装环境对象中的特定状态所对应的行为，可以有一个或多个行为。
 *  具体状态（Concrete State）角色：实现抽象状态所对应的行为，并且在需要的情况下进行状态切换。

![41514fa1f173e39914169b2673b127e8.gif][]

# 第二章 状态模式实现 #

## 2.1、环境类 ##

Context

public class Context { 
        private State state;
    
        public Context() { 
            this.state = new ConcreteStateA();
        }
    
        //设置状态
        public void setState(State state) { 
            this.state = state;
        }
    
        //读取状态
        public State getState() { 
            return (state);
        }
    
        //请求处理
        public void Handle() { 
            state.Handle(this);
        }
    }

## 2.2、抽象状态类 ##

State

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

## 2.3、具体状态类 ##

ConcreteStateA

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

ConcreteStateB

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

## 2.4、测试类 ##

Client

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

当前状态是 A.
    当前状态是 B.
    当前状态是 A.
    当前状态是 B.

# 第三章 状态模式应用 #

多线程存在 5 种状态，分别为新建状态、就绪状态、运行状态、阻塞状态和死亡状态，各个状态当遇到相关方法调用或事件触发时会转换到其它状态，其状态转换规律如下图所示：

![834fc4c716b9bb8804b57593633a96b5.gif][]

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

![2d4084f895a92caced72b841423f3210.gif][]

## 3.1、环境类 ##

ThreadContext

public 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);
        }
    }

## 3.2、抽象状态类 ##

ThreadState

public abstract class ThreadState { 
        protected String stateName;
    }

## 3.3、具体状态类 ##

New

public class New extends ThreadState { 
        public New() { 
            stateName = "新建状态";
            System.out.println("当前线程处于：新建状态.");
        }
    
        public void start(ThreadContext hj) { 
            System.out.print("调用start()方法-->");
            if (stateName.equals("新建状态")) { 
                hj.setState(new Runnable());
            } else { 
                System.out.println("当前线程不是新建状态，不能调用start()方法.");
            }
        }
    }

Runnable

public class Runnable extends ThreadState { 
        public Runnable() { 
            stateName = "就绪状态";
            System.out.println("当前线程处于：就绪状态.");
        }
    
        public void getCPU(ThreadContext hj) { 
            System.out.print("获得CPU时间-->");
            if (stateName.equals("就绪状态")) { 
                hj.setState(new Running());
            } else { 
                System.out.println("当前线程不是就绪状态，不能获取CPU.");
            }
        }
    }

Running

public class Running extends ThreadState { 
        public Running() { 
            stateName = "运行状态";
            System.out.println("当前线程处于：运行状态.");
        }
    
        public void suspend(ThreadContext hj) { 
            System.out.print("调用suspend()方法-->");
            if (stateName.equals("运行状态")) { 
                hj.setState(new Blocked());
            } else { 
                System.out.println("当前线程不是运行状态，不能调用suspend()方法.");
            }
        }
    
        public void stop(ThreadContext hj) { 
            System.out.print("调用stop()方法-->");
            if (stateName.equals("运行状态")) { 
                hj.setState(new Dead());
            } else { 
                System.out.println("当前线程不是运行状态，不能调用stop()方法.");
            }
        }
    }

Blocked

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

Dead

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

## 3.4、测试类 ##

Client

public class Client { 
        public static void main(String[] args) { 
            ThreadContext context = new ThreadContext();
            context.start();
            context.getCPU();
            context.suspend();
            context.resume();
            context.getCPU();
            context.stop();
        }
    }

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

[41514fa1f173e39914169b2673b127e8.gif]: /images/20221022/190171d4bf4b4f3b8dce240f609fc76c.png
[834fc4c716b9bb8804b57593633a96b5.gif]: /images/20221022/a46076bdaf824596baef9c5eab40d406.png
[2d4084f895a92caced72b841423f3210.gif]: /images/20221022/46816b4e90684155ba202982cc023bd8.png