行为型设计模式—strategy(策略模式)/command(命令模式)/memento(备忘录模式)/state(状态模式)

一、行为型设计模式的作用

关注点在于类和对象如何协作,各自分担职责。

二、strategy(策略模式)

(1)、思想

通过客户端构造方法,注入不同的抽象实现子类类,执行相同的客户端方法,
执行不同的逻辑,替代if else,
公有逻辑都在抽象类里面定义好了,所有传入不同的抽象子类都会执行同一个公有逻辑。

(2)、步骤

 1. 创建抽象类,创建公有的具体方法和抽象方法 
 2. 创建不同的子类重写抽象方法 
 3. 在客户端通过构造方法,注入不同的子类。
 4. 调用的时候传入不同子类,就可以实现不同的私有逻辑。

(3)、代码

//策略抽象类,声明抽象方法和公共的方法
public abstract class IStrategy {

    public abstract void privatePrint();

    public void print() {
        System.out.println("公共策略");
    }
}

//具体策略1,重写抽象方法
public  class strategyImpl1 extends  IStrategy{

    @Override
    public void privatePrint() {
        System.out.println("私有策略1");
    }
}

//具体策略2,重写抽象方法
public  class strategyImpl2 extends IStrategy{

    @Override
    public void privatePrint() {
        System.out.println("私有策略2");
    }
}

//客户端,通过构造方法注入策略接口,声明执行策略接口方法的方法exec
public class Client {

    private IStrategy iStrategy;
    //构造方法注入策略接口
    public Client(IStrategy iStrategy) {
        this.iStrategy = iStrategy;
    }
    //客户端方法
    public void exec(){
        this.iStrategy.print();
        this.iStrategy.privatePrint();
    }
}

//策略模式,通过客户端构造方法,指定具体策略,执行相同的接口方法,执行不同的逻辑,替代if else
public class strategyTest {

    public static void main(String[] args) {
        Client client=new Client(new strategyImpl1());
        client.exec();
    }
}

二、command(命令模式)

（1)、思想

将命令执行的过程封装成命令对象,调用不同的命令对象方法,进行不同的操作。

(2)、步骤

 1. 声明命令抽象类,声明不同的方法 
 2. 声明具体命令类,继承抽象类,重写方法 
 3. 在客户端用抽象类变量指向具体的命令子类,执行方法。

（3)、代码

//命令抽象类
public abstract class Command {

    public abstract void doit();
    public abstract void undo();
}

public class Content {

    String msg="hello everybody";
}

//具体命令类
public class insertCommand extends Command{

    private Content content;

    public insertCommand(Content content) {
        this.content = content;
    }

    private String insertMsg="www";

    @Override
    public void doit() {
        content.msg+=insertMsg;
    }

    @Override
    public void undo() {
        content.msg=content.msg.substring(0,content.msg.length()-insertMsg.length());
    }
}

//命令模式,将执行逻辑封装成命令对象,可以方便的实现undo退回功能。
public class commandTest {

    public static void main(String[] args) {
        Content content=new Content();
        Command command=new insertCommand(content);
        command.doit();
        System.out.println(content.msg);
        command.undo();
        System.out.println(content.msg);
    }
}

三、memento(备忘录模式)

（1)、思想

	将每一步操作都封装成一个备忘录对象,由备忘录管理类进行管理,
	后面需要退回到那一步操作的时候,直接从备忘录管理对象里面获取。
	也就是对每一步操作做持久化并记录版本,方便后面回退到任意版本。

(2)、步骤

 1. 声明备忘录类,用于数据的详细信息 	
 2. 声明备忘录管理类,通过成员变量备忘录类列表和add/get等方法来管理备忘录对象。

（3)、代码

//备忘录类
public class Memento {

    //状态
    private String state;

    public Memento(String state) {
        this.state = state;
    }

    //获取状态
    public String getState() {
        return state;
    }
}

//备忘录管理类
public class CareTaker {

    private List<Memento> mementoList=new ArrayList<>();

    public void add(Memento memento){
        mementoList.add(memento);
    }

    public Memento get(int index){
        return mementoList.get(index);
    }
}

//备忘录创建类
public class Originator {

    //状态
    private String state;

    public String getState() {
        return state;
    }

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

    //保存状态
    public Memento  saveStateToMemento(){
        return new Memento(state);
    }

    //获取状态
    public void getStateFromMemento(Memento Memento){
        state = Memento.getState();
    }
}

//备忘录状态,备忘录类记录每个阶段的数据(就是一个实体对象),
// 备忘录创建类,来创建备忘录(就是给实体对象赋值并初始化)
//备忘录管理类,将初始化好的备忘录实体加入到列表里面,以便随时恢复到指定状态
public class mementoTest {

    public static void main(String[] args) {
        //备忘录管理类
        CareTaker careTaker=new CareTaker();
        //备忘路创建类
        Originator originator=new Originator();

        //备忘录创建类生成状态,备忘录管理类保存
        originator.setState("save1");
        careTaker.add(originator.saveStateToMemento());
        originator.setState("save2");
        careTaker.add(originator.saveStateToMemento());

        System.out.println(careTaker.get(0).getState());
    }
}

四、state(状态模式)

(1)、思想

代替状态判断的if else语句,通过将状态抽象成对象,每个状态的执行方法实现不同的逻辑,
在客户端中就可以通过状态对象的不同来实现不同的逻辑。

(2)、步骤

 1. 声明一个状态接口,实现接口方法 
 2. 实现接口子类,重写接口方法 
 3. 客户端用接口对象指向不同的接口实现状态类,调用同一方法实现不同的逻辑。

(3)、代码

//抽象状态类
public interface absState {

    public void doit(Context context);
}

//主体对象
public class Context {

    //主体对象持有状态对象
    private absState absState;

    public absState getAbsState() {
        return absState;
    }

    public void setAbsState(absState absState) {
        this.absState = absState;
    }
}

public class startState implements absState{

    @Override
    public void doit(Context context) {
        context.setAbsState(this);
    }

    @Override
    public String toString() {
        return "startState{}";
    }
}

public class endState implements absState{

    @Override
    public void doit(Context context) {
        context.setAbsState(this);
    }

    @Override
    public String toString() {
        return "endState{}";
    }
}

//状态模式,将不同状态下的执行逻辑封装成不同的状态对象
//声明一个主体对象,声明多个状态对象,状态对象里面声明方法将当前状态设置为主体对象的状态
//然后在客户端用主体对象的状态属性.方法,即可通过状态的不同实现多态
public class stateTest {

    public static void main(String[] args) {
        //声明主体
        Context context=new Context();
        //声明状态
        absState start=new startState();
        //给主体赋上状态
        start.doit(context);
        System.out.println(context.getAbsState().toString());
    }
}