[学习笔记]设计模式[a]-{状态模式}

设计模式

相信大家对状态机都有了解，状态机可以实现很多逻辑处理。在程序设计中也有对应的状态模式，虽然相比状态机简单很多，但是也是一种很有应用场景的设计模式。

状态模式

首先是状态模式的定义
状态模式允许对象在内部状态改变时改变它的行为，对象看起来好像修改了它的类。
这句话怎么理解呢，首先是”允许对象在内部状态改变时改变它的行为”，正如状态机中的状态转移一样，如果状态机的状态改变了，它的下一步所能进行的“行为”也会对应产生变化。
第二句”对象看起来好像修改了它的类”,这个意味着，在外部看起来，我们的系统中只有一个类，但是事实上并不是这样。下面用一个简单的例子对状态模式进行介绍。
我们需要实现一个简单的显示器，用于显示门的开关:
1.当门打开的时候，显示打开状态，并提供关闭的方法。
2.当门关闭的时候，显示关闭状态，并提供打开的方法。
在没有学习状态模式的时候，我们可能这样实现代码:

public class Door {

    private static int OPEN = 0;
    private static int CLOSE = 1;
    private int state;

    public void openDoor() {
        if (state == OPEN) {
            return;
        }
        if (state == CLOSE) {
            state = OPEN;
        }
    }

    public void closeDoor() {
        if (state == OPEN) {
            state = CLOSE;
        }
        if (state == CLOSE) {
            return;
        }
    }

    public void showDoor() {
        if (state == OPEN) {
            System.out.println("Door is Open!");
        }
        if (state == CLOSE) {
            System.out.println("Door is Close!");
        }
    }
}

相当简单的逻辑，如果门关着，那么我关门的操作就会被忽略，开门的操作才会改变门的状态。
但是问题来了，如果现在门上加了锁，我们该如何修正这段代码从而实现需求呢？我们需要加一个上锁的状态，当门处于上锁的状态的时我们的开门操作需要先开锁，还要判断钥匙是不是匹配。。关门状态时也要加上可以上锁的操作。。。。
这简直就相当于重写了这段代码！
那么我们来看一下 如果使用状态模式对上面的需求该如何实现:
首先，每个状态是不同的类,同时继承一个基本接口:

abstract interface State {

    public abstract void openDoor();

    public abstract void closeDoor();

    public abstract void lockDoor();

}

然后把每个状态单独实现为一个类:
开门状态

class DoorOpen implements State {

    private Door door;

    public DoorOpen(Door door) {
        this.door = door;
    }

    public void openDoor() {
        return;
    }

    public void closeDoor() {
        door.setState(door.getDoorClose());
        System.out.println("Door is close");
    }

    public void lockDoor() {
        return;
    }
}

关门状态

class DoorClose implements State {

    private Door door;

    public DoorClose(Door door) {
        this.door = door;
    }

    public void openDoor() {
        door.setState(door.getDoorOpen());
        System.out.println("Door is open");
    }

    public void closeDoor() {
        return;
    }

    public void lockDoor() {
        door.setState(door.getDoorLock());
    }
}

锁门状态

class DoorLock implements State {

    private Door door;

    public DoorLock(Door door) {
        this.door = door;
    }

    public void openDoor() {
        check();//检查钥匙是否匹配
        door.setState(door.getDoorOpen());
        System.out.println("Door is open");
    }

    public void closeDoor() {
        return;
    }

    public void lockDoor() {
        return;
    }
}

我们最后的门这个类就十分简单了:

public class Door {

    private State DoorOpen;
    private State DoorClose;
    private State DoorLock;

    private State state = DoorOpen;

    public Door() {
        DoorOpen = new DoorOpen(this);
        DoorClose = new DoorOpen(this);
        DoorLock = new DoorOpen(this);
    }

    public void openDoor() {
        state.openDoor();
    }

    public void closeDoor() {
        state.closeDoor();
    }

    public void lockDoor() {
        state.lockDoor();
    }

    public State getDoorOpen() {
        return DoorOpen;
    }

    public State getDoorClose() {
        return DoorClose;
    }

    public State getDoorLock() {
        return DoorLock;
    }

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

如果以后要增加新的状态，我们只需要新增一个状态类并在门中增加这个状态即可，不需要对原来的代码进行修改。
最后是状态模式的类图: