1. 状态模式

状态模式，当一个对象的内在状态改变时允许改变其行为，这个对象看起来像是改变了其类

• 状态模式主要解决的是当控制一个对象状态转换的条件表达式过于复杂的时候，把状态的判断逻辑转移到表示不同状态的一系列类当中

状态模式

• Context类维护一个ConcreteState子类的实例，这个实例定义当前的状态

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

public class ConcreteState extends State {
    @Override
    public void Handle(StateContext context) {
        System.out.println("工作开始");
        context.state = new ConcreteStateB();
    }
}

public class ConcreteStateB extends State {
    @Override
    public void Handle(StateContext context) {
        System.out.println("工作结束");
    }
}

public class StateContext {
    public State state; //记录当前的状态
    public StateContext(State state) {
        this.state = state;
    } // 创建StateContext实例，记录当前状态
    public void Request() {
        state.Handle(this);
    } //用户通过调用Request来转换状态
}

public class StateClient {
    public static void main(String[] args) {
        StateContext stateContext = new StateContext(new ConcreteState());
        stateContext.Request();
        stateContext.Request();
    }
}

好处

• 将与特定状态相关的行为局部化，并且将不同状态的行为分割开来
• 通过定义新的子类可以很容易地增加新的状态和转换
• 当一个对象的行为取决于它的状态，并且它必须在运行时刻根据状态改变它的行为时，就可以考虑用状态模式了

2. 适配器模式

适配器模式将一个类的接口转换成客户希望的另外一个接口。Adapter模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作

适配器模式

• 两个类所做的事情类似，但是具有不同的接口要使用它，这样可以统一接口，让类之间更加简单、更直接、更紧凑
• 在双方都不太容易修改时使用适配器

public abstract class BasketballPlayer {
    abstract void attack();
    abstract void defense();
}

public class Translator extends BasketballPlayer {
    private YaoMing yaoMing;
    public Translator (YaoMing yaoMing) {
        this.yaoMing = yaoMing;
    }
    @Override
    void attack() {
        yaoMing.jingong();
    }

    @Override
    void defense() {
        yaoMing.fangshou();
    }
}

public class YaoMing {
    public void jingong() {
        System.out.println("姚明进攻");
    }

    void fangshou() {
        System.out.println("姚明防守");
    }
}

public class BasketballClient {
    public static void main(String[] args) {
        Translator translator = new Translator(new YaoMing());
        translator.attack();
        translator.defense();
    }
}

3. 备忘录模式

备忘录：在不破坏封装的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态，这样以后就可将该对象恢复到原先保存的状态

备忘录模式

• CareTaker负责保存好备忘录Memento
• Originator发起者，负责创建一个备忘录Memento，用以记录当前的内部状态
• Memento负责存储Originator的内部状态，有两个接口，宽接口对着Originator，只能由Originator修改备忘录，窄接口对着CareTaker，只能读取储存的状态

public class Originator {
    private String state;

    public String getState() {
        return state;
    }

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

    public Memento saveState() {
        return new Memento(state);
    }

    public String readState(Memento memento) {
        return memento.state;
    }
}

/*
负责控制如何存储数据，类似于一个集装箱
 */
public class Memento {
    String state;
    public Memento(String state) {
        this.state = state;
    }
}

/*
控制存储在哪儿，类似于一个仓库
 */
public class CareTaker {
    Memento memento;
    public CareTaker(Memento memento) {
        this.memento = memento;
    }

    public Memento getMemento() {
        return memento;
    }

}

/*
客户端Originator只和CareTaker进行交互
 */
public class ClientMemento {
    public static void main(String[] args) {
        Originator originator = new Originator();
        originator.setState("game start");
        originator.saveState();

        CareTaker careTaker = new CareTaker(originator.saveState());
        System.out.println(careTaker.memento.state);
    }
}