上述笔记代码有点问题，开机状态和关机状态需要修改成下面这样：

public class StartState implements State {
    public void start(Context context) {
    }

    public void close(Context context) {
        context.setState(new CloseState());//注意状态的切换
        System.out.println("close State");
    }
}

public class CloseState implements State {
    public void start(Context context) {
    context.setState(new StartState());//注意状态的切换
        System.out.println("start State");
    }
    public void close(Context context) {
    }

}

Context类也要修改：

public class Context {
    private State state;
    public void setState(State state) {
        this.state = state;
    }

    public State getState() {
        return state;
    }

    public void start() {
        getState().start(this);
    }

    public void close() {
        getState().close(this);
    }

}

Python 方式：

# State Pattern with Python Code
from abc import abstractmethod,ABCMeta

# 创建State接口
class State(metaclass=ABCMeta):
    @abstractmethod
    def doAction(self,inContext):
        pass

# 创建实现State接口的实体类
class step1State(State):
    def doAction(self,inContext):
        if inContext.contextState != "Step1" :
            inContext.setState(step2State())
            inContext.doSomething()
        else :
            print("Player is in : Step1 state")

class step2State(State):
    def doAction(self,inContext):
        if inContext.contextState != "Step2" :
            inContext.setState(step3State())
            inContext.doSomething()
        else :
            print("Player is in : Step2 state")

class step3State(State):
    def doAction(self,inContext):
        if inContext.contextState != "Step3" :
            print("State wrong， Over！")
        else :
            print("Player is in : Step3 state")

# 创建Context类
class Context():
    _aState = None
    contextState = ""

    def __init__(self):
        self._aState = step1State()
        contextState = "Step1"
    def setState(self, inState):
        self._aState = inState
    def getState(self):
        return self._aState
    def doSomething(self):
        self._aState.doAction(self)

# 调用输出
if __name__ == '__main__':
    aContext = Context()
    aContext.contextState = "Step1"
    aContext.doSomething()

    aContext.contextState = "Step3"
    aContext.doSomething()

    aContext.contextState = "Step5"
    aContext.doSomething()

这个完全误人子弟了。

笔记二是对的，最后一个笔记yesok的再次误人子弟。

把context换成computer就明白了，computer如果只有开机，关机，播放三种操作，但是有开机，关机，播放中三种状态。每种状态能够执行的操作肯定是不同的。

                            开机    关机    播放

开机中                不可       可       可

关机中                 可         不可     不可

播放中               不可      可          不可

状态即使抽象出来，也只是computer的属性，方便扩展不写switch而已，状态的变化肯定是源于computer自身的动作的，用oo的思想来看，调用者对于状态state的api应该是不可见的。

new computer时，会设置一个默认状态，我们的例子应该是关机中。然后关机中的computer只能有一个有效操作，就是开机，至于其他两种操作是设置为无响应，还是log提示无法操作，那也随便了。

最后，状态切换本身就是每个状态的内禀属性，关机中通过开机操作切换到开机中的代码，应该写在CloseState里，至于说耦合问题，这些状态本身互相之间就是有联系的，怎么可能互相独立？

状态之间不是解耦的，所以才说状态模式对“开闭原则”的支持并不好。

状态模式中类有状态，状态的修改会改变整个类行为。

策略没有状态，策略的选择由客户端决定。

public class StateTest {
    public static void main(String[] args) {
        System.out.println("=====状态模式=====");
        TrafficLight light = new TrafficLight(ColorEnum.GREEN);
        for (int i = 0; i < 4; i++) {
            System.out.println("当前状态[" + light.getState() + "]");
            light.forward();
        }
    }
}
/* 抽象状态类 */
interface LightColor {
    void forward(TrafficLight light); // 向前转换
}
/* 具体状态枚举类 */
enum ColorEnum implements LightColor {
    GREEN {
        public void forward(TrafficLight light) {
            System.out.println("向前转换: 绿灯 => 黄灯");
            light.setState(ColorEnum.YELLOW); // 状态切换为黄灯        
        }
        public String toString() {
            return "绿灯@" + this.hashCode();
        }
    },
    YELLOW {
        public void forward(TrafficLight light) {
            System.out.println("向前转换: 黄灯 => 红灯");
            light.setState(ColorEnum.RED); // 状态切换为红灯
        }
        public String toString() {
        return "黄灯@" + this.hashCode();
        }
    },
    RED {
        public void forward(TrafficLight light) {
            System.out.println("向前转换: 红灯 => 绿灯");
            light.setState(ColorEnum.GREEN); // 状态切换为绿灯       
        }
        public String toString() {
            return "红灯@" + this.hashCode();
        }
    };
    public void forward(TrafficLight light) {
        throw new UnsupportedOperationException("Invalid forward!");
    }
}
/* 主题类 */
class TrafficLight {
    private LightColor color;
    // 维持一个对抽象状态对象的引用   
    public TrafficLight(LightColor color) {
        this.color = color;
    }
    // 设置状态对象    
    public void setState(LightColor color) {
        this.color = color;
    }
    // 获取当前状态对象    
    public LightColor getState() {
        return color;
    }
    public void forward() {
        color.forward(this);
    }
}

运行结果:

=====状态模式=====
当前状态[绿灯@51228289]
向前转换: 绿灯 => 黄灯
当前状态[黄灯@396873410]
向前转换: 黄灯 => 红灯
当前状态[红灯@1706234378]
向前转换: 红灯 => 绿灯
当前状态[绿灯@51228289]
向前转换: 绿灯 => 黄灯