精华内容
下载资源
问答
  • Java状态机

    千次阅读 2016-04-14 21:34:30
     子状态 DoorOpen 实现转移时只负责返回下目标状态是什么,将状态转移的 action 留给 Door2 实例自己来做;而不是像“ A. 基本的 State Pattern 实现”那样在 DoorOpen 内部保存一个 Door2 实例的...

    http://chuanwang66.iteye.com/blog/1328563


    1. 概述

        The intent of the STATE pattern is to distribute state-specific logic across classes that represent an object’s state.

        STATE 设计模式的目的 是:将特定状态相关的逻辑分散到一些类的状态类中。

     

    2. 实例

        旋转门: Consider the model of the state of a carousel door(revolving door). A carousel is a large, smart rack that accepts material through a doorway and stores the material according to a bar code ID on it. The door operates with a single button. See the state diagram below for some detail.

     

        旋转门的状态图:(状态图细节见 4. )


     

    3. 状态模型的两种实现方法

        3.1 方法一: switch

      

    Observable是java.util中的类^^居然以前都不晓得哦,该打!

     

    Door的具体实现如下:

    Java代码  收藏代码
    1. import java.util.Observable;  
    2.   
    3. /** 
    4.  * This class provides an initial model of a carousel door 
    5.  * that manages its state without moving state-specific 
    6.  * logic out to state classes. 
    7.  */  
    8. public class Door extends Observable {  
    9.     public final int CLOSED = -1;  
    10.     public final int OPENING = -2;  
    11.     public final int OPEN = -3;  
    12.     public final int CLOSING = -4;  
    13.     public final int STAYOPEN = -5;  
    14.   
    15.     private int state = CLOSED;  
    16.   
    17.     /** 
    18.      * The carousel user has touched the carousel button. This "one touch" 
    19.      * button elicits different behaviors, depending on the state of the door. 
    20.      */  
    21.     public void touch() {  
    22.         switch (state)  
    23.         {  
    24.             case OPENING:  
    25.             case STAYOPEN:  
    26.                 setState(CLOSING);  
    27.                 break;  
    28.             case CLOSING:  
    29.             case CLOSED:  
    30.                 setState(OPENING);  
    31.                 break;  
    32.             case OPEN:  
    33.                 setState(STAYOPEN);  
    34.                 break;  
    35.             default:  
    36.                 throw new Error("can't happen");  
    37.         }  
    38.     }  
    39.   
    40.     /**  
    41.      * This is a notification from the mechanical carousel that  
    42.      * the door finished opening or shutting. 
    43.      */  
    44.     public void complete() {  
    45.         if (state == OPENING)  
    46.             setState(OPEN);  
    47.         else if (state == CLOSING)  
    48.             setState(CLOSED);  
    49.     }  
    50.   
    51.     /** 
    52.      * This is a notification from the mechanical carousel that the 
    53.      * door got tired of being open. 
    54.      */  
    55.         public void timeout() {  
    56.             setState(CLOSING);  
    57.         }  
    58.        
    59.     /** 
    60.      * @return a textual description of the door's state 
    61.      */  
    62.     public String status()  
    63.     {  
    64.         switch (state)  
    65.         {  
    66.             case OPENING:  
    67.                 return "Opening";  
    68.             case OPEN:  
    69.                 return "Open";  
    70.             case CLOSING:  
    71.                 return "Closing";  
    72.             case STAYOPEN:  
    73.                 return "StayOpen";  
    74.             default:  
    75.                 return "Closed";  
    76.         }  
    77.     }  
    78.   
    79.     private void setState(int state)  
    80.     {  
    81.         this.state = state;  
    82.         setChanged();  
    83.         notifyObservers();  
    84.     }  
    85. }  
     

    但是采用这种实现,有一个缺陷:state变量在Door类的实现中浑身扩散,就像癌症一般!

     

     

        3.2 方法二: State Pattern

     

        A. 基本的 State Pattern 实现


     

        以上设计方式要求每个状态子类实例内部“ hold 住”一个 Door2 实例的引用,这样才能完成 Door2 实例和它的各个状态实例时间的互相通信。这种设计要求一个状态实例对应一个 Door2 实例,这样一来,一个状态实例就只能为一个 Door2 实例服务╮ ( ╯▽╰ ) ╭

        客户端这样调用:

    Java代码  收藏代码
    1. public static void main(String[] args){  
    2.         Door2 door=new Door2();  
    3.           
    4.         //1. 初始状态  
    5.         System.out.println(door.status());  
    6.           
    7.         //2. 转移到Opening状态  
    8.         door.touch();  
    9.         System.out.println(door.status());  
    10.           
    11.         //3. 转移到Open状态  
    12.         door.complete();  
    13.         System.out.println(door.status());  
    14.           
    15.         //4. 转移到Closing状态  
    16.         door.timeout();  
    17.         System.out.println(door.status());  
    18.           
    19.         //5. 回到Closed状态  
    20.         door.complete();  
    21.         System.out.println(door.status());  
    22.     }  

     

     

    下面给出Door2类、DoorState抽象类、DoorStayOpen类的实现:

    Door2:

    Java代码  收藏代码
    1. public class Door2 extends Observable {  
    2.     public final DoorState CLOSED = new DoorClosed(this);  
    3.     public final DoorState CLOSING = new DoorClosing(this);  
    4.     public final DoorState OPEN = new DoorOpen(this);  
    5.     public final DoorState OPENING = new DoorOpening(this);  
    6.     public final DoorState STAYOPEN = new DoorStayOpen(this);  
    7.   
    8.     private DoorState state = CLOSED;  
    9.   
    10.     public void touch() {  
    11.         state.touch();  
    12.     }  
    13.   
    14.     public void complete() {  
    15.         state.complete();  
    16.     }  
    17.   
    18.     public void timeout() {  
    19.         state.timeout();  
    20.     }  
    21.   
    22.     public String status() {  
    23.         return state.status();  
    24.     }  
    25.   
    26.     protected void setState(DoorState state) {  
    27.         this.state = state;  
    28.         setChanged();  
    29.         notifyObservers();  
    30.     }  

     

    DoorState抽象类:

    Java代码  收藏代码
    1. public abstract class DoorState {  
    2.     protected Door2 door;  
    3.   
    4.     public abstract void touch();  
    5.   
    6.     public void complete() {  
    7.     }  
    8.   
    9.     public void timeout() {  
    10.     }  
    11.   
    12.     public String status() {  
    13.         String s = getClass().getName();  
    14.         return s.substring(s.lastIndexOf('.') + 1);  
    15.     }  
    16.   
    17.     public DoorState(Door2 door) {  
    18.         this.door = door;  
    19.     }  
    20. }  
     

    DoorStayOpen类:

    Java代码  收藏代码
    1. public class DoorStayOpen extends DoorState {  
    2.     public DoorStayOpen(Door2 door) {  
    3.         super(door);  
    4.     }  
    5.   
    6.     public void touch() {  
    7.         door.setState(door.CLOSING);  
    8.     }  
    9. }  
     

     

        B. State Pattern 实现 2 ——让状态实例( DoorState 的子类实例)为多个 Door2 实例服务

        子状态 DoorOpen 实现转移时只负责返回下目标状态是什么,将状态转移的 action 留给 Door2 实例自己来做;而不是像“ A. 基本的 State Pattern 实现”那样在 DoorOpen 内部保存一个 Door2 实例的引用 door ,亲自调用door.setState(door.STAYOPEN); 来实现状态转移

        改进后的关键代码:

       

    Java代码  收藏代码
    1. public class DoorOpen extends DoorState{  
    2.        public DoorState touch(){  
    3.            return DoorState.STAYOPEN;  
    4.            // 以前是 door.setState(door.STAYOPEN);  
    5.        }  
    6.        ...  
    7. }  
    8.   
    9.    
    10.   
    11.     public class Door2 extends Observable{  
    12.        public void touch(){  
    13.            state=state.touch();  
    14.            // 以前是 state.touch();  
    15.            // 即将转移状态的工作留给状态实例来做,事不关己高高挂起  
    16.        }  
    17. }   

     

     

        C. State Pattern 实现 3 ——让状态实例( DoorState 的子类实例)为多个 Door2 实例服务

        另一种实现这种效果的方法是:将 Door2 实例作为参数传递给 DoorState 的状态转移方法,而非建立Composite 的关联关系(将 DoorState 的子类对象作为 Door2 的属性)。

        也即,用“ Dependency 依赖”(弱依赖,如调用)代替了“ Association 关联”(强依赖,如作为属性进行组合)。

     

     

     

    4. 状态图细节

        何谓 State 状态 : Generally speaking, the state of an object depends on the collective value of the object ’ s instance variables. In some cases, most of an object ’ s attributes are fairly static once set, and one attribute is dynamic and plays a prominent role in the class ’ s logic. This attribute may represent the state of the entire object and may even be named state.



     

        4.1 State

        You can subdivide a state icon into areas that show the state  s name and activities活动 .

        3 frequently used categories of activities are entry (what happens when the system enters the state), exit (what happens when the system leaves the state), and do (what happens while the system is in the state).


     

        4.2 Transition s (Details: Event[Guard Condition]/Action)

        You can also add some details to the transition lines. You can indicate an event that causes a transition to occur (atrigger event ) and the computation (the action ) that executes and makes the state change happen.

        A guard condition : when it’s met, the transition takes place. 通常将超时作为监护条件,∵可以认为此时没有任何event.


    •源状态 Source State :即受转换影响的状态

    •目标状态 Target State :当转换完成后,对象的状态

    •触发事件 (Trigger) Event :用来为转换定义一个事件,包括调用、改变、信号、时间四类事件

    •监护条件 (Guard Condition) :布尔表达式,决定是否激活转换、

    •动作 (Action) :转换激活时的操作

     

    几个实例:



     

     


     

    展开全文
  • java状态机学习总结

    千次阅读 2020-04-28 08:59:53
    首先,我们需要了解,什么是状态机? 有限状态机(英语:finite-state machine,缩写:FSM)又称有限状态自动机,简称状态机,是表示有限个状态以及在这些状态之间的转移和动作等行为的数学模型 在我的理解里,状态...


    首先,我们需要了解,什么是状态机?

    有限状态机(英语:finite-state machine,缩写:FSM)又称有限状态自动机,简称状态机,是表示有限个状态以及在这些状态之间的转移和动作等行为的数学模型
    在我的理解里,状态机可以描述核心业务规则,核心业务内容,总结一下就是a实体,在b状态下,由c角色,在满足d条件时,执行e操作成功后,迁移到f状态下,并产生g事件,通常用于业务复杂的订单等业务里

    那么我们为什么要用到状态机呢,正常的写法也是可以实现的啊,用状态机的好处是什么?
    1.不需要每个接口都校验当前状态:直接数据库配置某个状态,加某个操作,才能进行下去,如果不对的状态进行该操作,会报错

    2.同一个接口配置不同的流程:同一个如审批通过的接口,不同状态下审批不通过,需要走不同的流程,如审批中审批不通过,走改变状态的流程,变更审批中审批不通过,走回退历史的版本数据的流程,如果不用状态机,则需要分开写2个接口,或者在一个接口里走if else,考虑到复杂的订单状态变迁触发节点,可能if-else会非常多,比如某5种状态下的同一个接口走不同的流程

    3.实现流程可配制化,高内聚,集中配置,直接在数据库更改配置信息,可维护性和扩展性强

    4.易变更,快速修改

    5.易使用,极大简化前端的代码,是否可以删除,变更按钮的显示和隐藏通过后端返回的字段展示,后端直接根据状态机来判断是否可以删除,变更

    是否还需要乐观锁?
    需要的,在接口入口处,会判断这个状态下是否可以进行这个操作,但是高并发情况下,为了保证幂等性,还是需要加一下乐观锁,即传入上一个状态,sql更新的时候加一个status = 上一个状态的条件

    状态机的实现:说了这么多,状态机到底是怎么实现的呢?
    首先会有2个表:flow和flow_picker表:
    flow表主要用于存放不同的流程的名字,主要会有个id,订单走一个流,退货单走一个流


    flow_picker主要是每个业务创建的时候,会关联到哪个flow,就是关联到哪个流程id里,会通过来源,渠道,类型,等级等等条件,筛选出这个订单,关联的flow,存入订单表里的flow_id字段


    然后会有个配置流程的表:

    可以看到,先会根据订单的flow_id筛选出走哪个流程,再根据来源状态 source_status,操作operation_value,会到达目标状态target_status,并且会执行action_name,当然action_name是自己配置的,action_name里面的类就是不同流程,执行的代码

    根据这个配置,初始化的时候注入所有的action,可以调到数据库对应的配置的aciton类,同一个接口,可以执行多个流程,就好了

    展开全文
  • Java 有限状态机 (设计模式——状态模式) 编写代码的时候,有时会遇见较为复杂的swith...case...和if...else...语句。这一刻有时会想到状态机,用有限状态机替换swith...case...和if...else...可以: 降低程序的...

    Java 有限状态机 (设计模式——状态模式)

    编写代码的时候,有时会遇见较为复杂的swith...case...if...else...语句。这一刻有时会想到状态机,用有限状态机替换swith...case...if...else...可以:

    • 降低程序的复杂度;
    • 提高程序的可维护性;
    • 状态机模式体现了开闭原则和单一职责原则。
      每个状态都是一个子类,增加状态就要增加子类;修改状态只要修改一个类就行了。

    以上是有限状态机的好处。其亦有缺点

    • 使用状态机子类会增多,也就是类膨胀,这点需要程序员在开发中自己衡量。

    状态模式定义:

    Allow an object to alter its behavior when its internal state changes.The object will appear to change its class.
    允许对象在其内部状态发生变化时更改其行为。看起来像更改了其类 (这翻译不好,这里应该是体现了其封装性:外部的调用不用知道其内部如何实现状态和行为变化的)。

    举个例子

    我们每天都乘坐电梯,电梯有四种状态:开门、关门、运行、停止。

    Col1 开门 行为 关门 行为 运行 行为 停止 行为
    开门 态 no yes no no
    关门 态 yes no yes yes
    运行 态 no no no yes
    停止 态 yes no yes no

    LiftState.java

    /**
     * 定义电梯行为:打开、关闭、运行、停止
     */
    public abstract class LiftState {
    
        // 拥有一个电梯对象,用于更新电梯当前状态
        protected Lift mLift;
    
        /**
         * 通过构造函数引入电梯的实例化对象
         *
         * @param lift
         */
        public LiftState(Lift lift) {
            this.mLift = lift;
        }
    
        /**
         * 行为:打开电梯门
         */
        public abstract void open();
    
        /**
         * 行为:关闭电梯门
         */
        public abstract void close();
    
        /**
         * 行为:电梯运行
         */
        public abstract void run();
    
        /**
         * 行为:电梯停止运行
         */
        public abstract void stop();
    }
    

    电梯的四种状态

    public class OpeningState extends LiftState {
    
    
        public OpeningState(Lift lift) {
            super(lift);
        }
    
    
        @Override
        public void open() {
            // 执行开门动作
            System.out.println("执行开门动作");
        }
    
        @Override
        public void close() {
            // 执行关门动作
            // 1、转化为关门状态
            mLift.setState(mLift.getCloseingState());
            // 2、关门
            mLift.close();
        }
    
        @Override
        public void run() {
            // do noting
            // 开门状态,不能执行运行动作
    
        }
    
        @Override
        public void stop() {
            // do noting
            // 开门状态下,不执行停止动作
        }
    }
    
    public class ClosingState extends LiftState {
    
    
        public ClosingState(Lift lift) {
            super(lift);
        }
    
    
        @Override
        public void open() {
            // 执行开门动作
            // 1、变化为开门状态
            this.mLift.setState(mLift.getOpenningState());
            // 2、开门
            this.mLift.open();
        }
    
        @Override
        public void close() {
            System.out.println("执行关门动作");
        }
    
        @Override
        public void run() {
            // 运行动作
            // 1、运行状态
            this.mLift.setState(mLift.getRunningState());
            // 2、运行动作
            this.mLift.run();
        }
    
        @Override
        public void stop() {
            // 停止动作
            // 1、转化为停止状态
            this.mLift.setState(mLift.getStoppingState());
            // 2、停止
            this.mLift.stop();
        }
    
    }
    
    public class RunningState extends LiftState {
    
    
        public RunningState(Lift lift) {
            super(lift);
        }
    
    
        @Override
        public void open() {
            // do noting
        }
    
        @Override
        public void close() {
            // do noting
        }
    
        @Override
        public void run() {
            // 运行动作
            System.out.println("电梯上下运行中...");
        }
    
        @Override
        public void stop() {
            // 停止动作
            // 1、转化为停止状态
            this.mLift.setState(mLift.getStoppingState());
            // 2、停止动作
            this.mLift.stop();
        }
    
    }
    
    public class StoppingState extends LiftState {
    
    
        public StoppingState(Lift lift) {
            super(lift);
        }
    
        @Override
        public void open() {
            // 开门动作
            // 1、开门状态
            this.mLift.setState(mLift.getOpenningState());
            // 2、执行开门动作
            this.mLift.open();
        }
    
        @Override
        public void close() {
            // do noting
        }
    
        @Override
        public void run() {
            // 运行动作
            // 1、运行状态
            this.mLift.setState(mLift.getRunningState());
            // 2、运行动作
            this.mLift.run();
        }
    
        @Override
        public void stop() {
            // 电梯停止动作
            System.out.println("电梯停止运行...");
        }
    
    
    }
    

    定义电梯类

    /**
     * 定义电梯类
     */
    public class Lift {
        //定义出电梯的所有状态
        private LiftState openningState;
        private LiftState closingState;
        private LiftState runningState;
        private LiftState stoppingState;
    
        // 定义当前电梯状态
        private LiftState mCurState;
    
    
        /**
         * 构造方法
         */
        public Lift() {
            openningState = new OpeningState(this);
            closingState = new ClosingState(this);
            runningState = new RunningState(this);
            stoppingState = new StoppingState(this);
        }
    
        /**
         * 执行开门动作
         */
        public void open() {
            mCurState.open();
        }
    
        /**
         * 执行关门动作
         */
        public void close() {
            mCurState.close();
        }
    
        /**
         * 执行运行动作
         */
        public void run() {
            mCurState.run();
        }
    
        /**
         * 执行停止动作
         */
        public void stop() {
            mCurState.stop();
        }
    
        // ##################设置当前电梯状态#####################
    
        /**
         * 设置当前电梯状态
         *
         * @param state
         */
        public void setState(LiftState state) {
            this.mCurState = state;
        }
    
        // ###################获取电梯的全部状态####################
    
        public LiftState getOpenningState() {
            return openningState;
        }
    
        public LiftState getCloseingState() {
            return closingState;
        }
    
        public LiftState getRunningState() {
            return runningState;
        }
    
        public LiftState getStoppingState() {
            return stoppingState;
        }
    
    }
    

    运行

    public static void main(String[] args) {
            Lift lift = new Lift();
            lift.setState(new ClosingState(lift));
            lift.open();
            lift.close();
            lift.run();
            lift.stop();
        }
    

    运行结果

    执行开门动作
    执行关门动作
    电梯上下运行中...
    电梯停止运行...
    

    参考:

    《设计模式之禅》

    ========== THE END ==========

    展开全文
  • Java状态机

    千次阅读 2018-03-07 11:16:07
    结构StateMachine.java ... 四个元素:当前状态, 目标状态, 事件, 行为 Action.java TestMachine.java StateMachine.javapackage com.guo.state;import java.util.ArrayList;public class StateMachine { //状

    结构

    StateMachine.java 
    Transation.java  
        四个元素:当前状态, 目标状态, 事件, 行为 
    Action.java
    TestMachine.java
    

    StateMachine.java

    package com.guo.state;
    
    import java.util.ArrayList;
    
    public class StateMachine {
    
            //状态
        public enum STATE{
            IDEL,
            RUN,
            STOP
        }
    
        //事件
        public enum EVENT{
            RUN,
            STOP,
            OVER
        }
    
        public STATE currentState = STATE.IDEL;
        public ArrayList<Transation> trans;
    
        //注册
        public void regist(ArrayList<Transation> trans){
            this.trans = trans;
        }
    
        //更新
        @SuppressWarnings("unchecked")
        public <T> void change(EVENT event,T t){
            for(Transation tran : trans){
                if(tran.fromState == currentState && tran.event == event){
                    if(t!=null) tran.action.beforeExec(t);
                    tran.action.exec();
                    currentState = tran.toState;
                }
            }
        }
    
    }
    
    
    

    Action.java

    package com.guo.state;
    
    public interface Action<T> {
        void beforeExec(T t);
        void exec();
    }
    
    class ActionRun<T> implements Action<T>{
    
        @Override
        public void exec() {
            System.out.println("ActionRun: exec");
        }
    
        @Override
        public void beforeExec(T t) {
    
        }
    
    }
    
    
    class ActionStop<T> implements Action<T>{
    
        @Override
        public void exec() {
            System.out.println("ActionStop: exec");
        }
    
        @Override
        public void beforeExec(T t) {
    
        }
    
    }
    
    class ActionOver<T> implements Action<T>{
    
        @Override
        public void exec() {
            System.out.println("ActionOver: exec");
        }
    
        @Override
        public void beforeExec(T t) {
    
        }
    
    }

    Transation.java

    
    package com.guo.state;
    
    import com.guo.state.StateMachine.EVENT;
    import com.guo.state.StateMachine.STATE;
    
    public class Transation {
        public STATE fromState;
        public STATE toState;
        public EVENT event;
        public Action action;
    
        public Transation(STATE fromState, STATE toState, EVENT event,Action action){
            this.fromState = fromState;
            this.toState = toState;
            this.event = event;
            this.action = action;   
        }
    }
    

    测试类 TestMachine.java

    
    package com.guo.state;
    
    import java.util.ArrayList;
    
    import com.guo.state.StateMachine.EVENT;
    import com.guo.state.StateMachine.STATE;
    
    public class TestMachine {
        public static void main(String[] args) {
    
            ArrayList<Transation> list = new ArrayList<Transation>();
    
            //IDEL => RUN
            list.add(new Transation(STATE.IDEL, STATE.RUN, EVENT.RUN, new ActionRun<String>() {
                @Override
                public void exec() {
                    super.exec();
    
                }
    
                @Override
                public void beforeExec(String t) {
                    super.beforeExec(t);
                    System.out.println(t);
    
                }
            }));
    
            //RUN => STOP
            list.add(new Transation(STATE.RUN, STATE.STOP, EVENT.STOP, new ActionStop<Integer>() {
    
                @Override
                public void exec() {
                    super.exec();
                }
    
                @Override
                public void beforeExec(Integer t) {
                    super.beforeExec(t);
                    System.out.println(t);
                }
    
            }));
    
            //STOP => IDEL
            list.add(new Transation(STATE.STOP, STATE.IDEL, EVENT.OVER, new ActionOver<Boolean>() {
    
                @Override
                public void exec() {
                    super.exec();
                }
    
                @Override
                public void beforeExec(Boolean t) {
                    super.beforeExec(t);
                    System.out.println(t);
                }
    
            }));
            StateMachine machine = new StateMachine();
            machine.regist(list);
    
            machine.change(EVENT.RUN, "run");
            machine.change(EVENT.STOP, 1);
            machine.change(EVENT.OVER, true);
    
        }
    }
    
    

    #### 待完善
    action中有可能是异步任务or同步任务,把任务包装成js中Promise的形式,就可以兼容两种情况.<参考Rxjava>

    然而并没有用在实际项目中.

    展开全文
  • 一个java状态机样例的代码

    万次阅读 2013-08-29 16:19:51
    在UML当中有状态机视图,这个状态机可以用于自动售货机,自动售票机等等场景,下面是用java代码模拟的一个状态机: 1.状态机接口 package stateMachine; /** * 状态机接口 * @author seacean * @date 2013-8-29...
  • 超清晰的java线程状态机

    千次阅读 2017-09-10 19:28:54
    http://www.uml-diagrams.org/examples/java-6-thread-state-machine-diagram-example.html
  • JAVA enum实现简单状态机功能

    千次阅读 2014-03-12 15:35:22
    1.背景  我们做android应用,往往要进行多个状态的...有的时候通过if else也能完成功能,但是却显得代码很乱,这时候用enum枚举方法产生状态机机制,就很清晰的实现功能。 2.代码 简单的三种状态切换 public cl
  • FSM(状态机)的JAVA实现

    千次阅读 2019-06-03 16:19:19
    有限状态机(英语:finite-state machine,縮寫:FSM)又稱有限状态自动机,简称状态机,是表示有限个状态以及在这些状态之间的转移和动作等行为的数学模型。(FROM WIKI) FSM的核心和作用 状态机中的核心内容:...
  • Java设计模式:状态机模式

    千次阅读 2019-04-21 23:33:13
    public class State { private String value; public String getValue() { ... // 状态2 state.setValue("state2"); context.method(); } }   输出: State method1 State method2  
  • 利用Java枚举实现简单的状态机

    千次阅读 2019-04-19 21:13:55
    利用Java枚举实现状态机的想法比较新颖,在某些场景下用处也很大,看了一篇文章不错翻译在此。 --------------------------------------------------------------------------------------------------------------...
  • 相信不少java开发者写过状态变更的业务,比如订单流程、请假流程等等。一般会搞一个状态标识来标识生命周期的某个阶段。很多人会写这种逻辑: 如果流程几十个岂不是要if到爆炸。还有这“0”、“1”是几个意思? ...
  • 使用Java枚举实现简单的状态机

    千次阅读 2019-03-29 22:25:11
    本文将介绍在Java中如何通过枚举来实现状态机。通过与接口及具体类来的实现方式来说明枚举实现状态机器的优势。 2.Java Enums 枚举是一种定义了一组常量的特殊的类。通过枚举使代码可读性更好。我们以人力资源系统为...
  • java 枚举高级应用之状态机

    千次阅读 2012-07-04 10:15:14
    枚举类型非常适合用来创建状态机,一个状态机通常可以拥有有限的几个状态,他通常根据输入,从一个状态进入到下一个状态。 下面是一个用枚举实现的自动售货机的例子,很简陋,但是表达清楚了意思就差不多了,也希望...
  • 本文将讲解确定有限自动状态机和非确定有限自动状态机的概念定义,特点和区别。将结合图片例子重点讲解什么是非确定有限自动状态机。 有限自动状态机可以分为确定的和不确定的。“确定性”将在下文详讲。“有限”性...
  • 有限状态机(FSM)的Java 演示

    万次阅读 2014-09-18 14:51:40
    本文从简单的例子入手,逐步演变成非常复杂的程序。 在简明 状态模式(5.8)中,状态之间的变换由外界控制,或者说,多种状态是分割的、无关的。状态模式最有趣的地方正是讨论其状态的变迁。
  • java设计模式之状态机模式

    万次阅读 2018-06-08 15:46:15
    ①UML设计:②定义:不同的状态,不同的行为,每个状态有着相应的行为③示例:public class OpenState implements LiftState { //拥有一个电梯对象,用于更新电梯当前状态 Lift lift; public OpenState(Lift ...
  • 4、用while运行状态机,其实这个while放到Context内更好,应该是状态机自己维护状态,而不是外部通过状态机去控制状态。 5、比较巧的设计是,每个state的操作返回boolean,作为状态是否终止的判断。 资源:...
  • 状态机

    千次阅读 2015-04-10 13:50:01
    有限状态机(Finite State Machine或者Finite State Automata)是软件领域中一种重要的工具,很多东西的模型实际上就是有限状态机。 最近看了一些游戏编程AI的材料,感觉游戏中的AI,第一要说的就是有限状态机来...
  • 欢迎关注公众号: Asshole是啥? Asshole 是具有流程编排能力的分布式事件处理框架,如图 ...PS:asshole对新增加一个事件及处理十分简单,只需要继承Event类和AbstractHandler类即可 ... 使用场景:将碎...
  • 有限状态机实现-状态机介绍

    千次阅读 2017-11-12 12:05:51
    这个系列最终实现的状态机并不是一个标准的状态机,把状态机的很多标准的概念进行了简化,对概念的东西做了减法,实现了具备基本功能的状态机(很多所谓状态机更高级的功能,如:伪态,也可以在基本功能实现)。...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 404,893
精华内容 161,957
关键字:

java状态机作用

java 订阅