文章目录
  1. 1. 简单介绍
  2. 2. UML图
    1. 2.1. 参与者
  3. 3. 实例
  4. 4. 输出
  5. 5. 效果
  6. 6. 适用情形
  7. 7. 和Strategy Pattern的比较

简单介绍

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

UML图

参与者

  1. Context:上下文类,持有一个状态类对象
  2. State:状态类的抽象接口
  3. ConcreteState:状态类的具体实现

实例

  1. Context类:

    public class Context {
        private State concreteStateA;
        private State concreteStateB;
        private State state;
    
        public Context() {
            concreteStateA = new ConcreteStateA(this);
            concreteStateB = new ConcreteStateB(this);
            state = concreteStateA;
        }
    
        public State getState() {
            return state;
        }
    
        public void setState(State state) {
            this.state = state;
        }
    
        public State getConcreteStateA() {
            return concreteStateA;
        }
    
        public State getConcreteStateB() {
            return concreteStateB;
        }
    
        public void request() {
            state.handle();
        }
    }
    
  2. State类:

    public interface State {
        public void handle();
    }
    
  3. ConcreteStateA类:

    public class ConcreteStateA implements State{
        private Context context;
        public ConcreteStateA(Context context) {
            this.context = context;
        }
    
        @Override
        public void handle() {
            System.out.println("ConcreteStateA!");
            context.setState(context.getConcreteStateB());
        }
    
    }
    
  4. ConcreteStateB类:

    public class ConcreteStateB implements State{
        private Context context;
        public ConcreteStateB(Context context) {
            this.context = context;
        }
    
        @Override
        public void handle() {
            System.out.println("ConcreteStateB!");
            context.setState(context.getConcreteStateA());
        }
    
    }
    
  5. Test类:

    public class Test {
        public static void main(String arg[]) {
            Context context = new Context();
    
            context.request();
            context.request();
            context.request();
        }
    }
    

输出

ConcreteStateA!
ConcreteStateB!
ConcreteStateA!

效果

  1. 本地化状态特定的行为(localizes state specific behavior)
  2. 使得状态显示转换(makes state transitions explicit)
  3. 状态对象可以共享(state objects can be shared)

适用情形

  1. 一个对象的行为取决于它的状态,并且他必须在运行时刻根据状态改变它的行为。
  2. 一个操作中含有庞大的多分枝的条件语句,并且这些分支依赖于该对象的状态。这个状态通常用一个或多个枚举常量表示。通常,有多个操作包含这一相同的条件结构。State模式将每一个条件分支放入一个独立的类中。这是得你可以根据对象自身的情况将对象的状态作为一个对象,这一对象可以不依赖于其他对象而独立变化。

和Strategy Pattern的比较

Strategy模式与State模式的结构形式几乎完全一样。但它们的应用场景(目的)却不一样.State模式重在强调对象内部状态的变化改变对象的行为,Strategy模式重在外部对策略的选择,策略的选择由外部条件决定,也就是说算法的动态的切换。但由于它们的结构是如此的相似,我们可以认为“状态模式是完全封装且自修改的策略模式”。

就是:STATE模式在对象内部状态改变时重新配置它的行为,
STRATEGY模式提供了一种用多个行为中的一个行为来配置一个类的方法, 使得算法可独立于使用它的客户而变化。

文章目录
  1. 1. 简单介绍
  2. 2. UML图
    1. 2.1. 参与者
  3. 3. 实例
  4. 4. 输出
  5. 5. 效果
  6. 6. 适用情形
  7. 7. 和Strategy Pattern的比较