行为型设计模式

行为型模式(Behavioral Pattern)是对不同对象之间划分责任和算法的抽象化。通过行为型模式，可以更加清晰地划分类与对象的职责，并研究系统在运行时实例对象之间的交互。

类行为型模式：使用继承机制在类间分派行为，通过多态等方式来分配父类与子类的职责。

对象行为型模式：使用对象复合而不是继承分配行为，通过对象关联等方式来分配多个类的职责。

 

模板方法模式

定义一个操作中的算法的骨架，而将一些步骤延迟到子类中。

 

命令模式

命令(Command)模式又叫作动作(Action)模式或事务(Transaction)模式，是一种对象的行为模式。将一个请求封装为一个对象，从而使你可用不同的请求对客户进行参数化；对请求排队或记录请求日志，以及支持可撤消的操作。

/**
 * 命令接口
 */
public interface Command {
 
	/**
	 * 执行命令
	 */
	public void execute();
}

/**
 * 命令的接收者：真正执行命令的对象，比如打印机，输出流...
 */
public class Receiver {
	/**
	 * 示意方法，真正执行命令相应的操作
	 */
	public void action() {
		System.out.println("接收者开始行动。。。");
	}
}

/**
 * 各种命令实现
 */
public class ConcreteCommand implements Command{
    /**
     * 持有相应的接收者对象
     */
    private Receiver receiver = null;
 
    /**
     * 构造方法，传入相应的接收者对象
     *
     * @param receiver 相应的接收者对象
     */
    public ConcreteCommand(Receiver receiver) {
        this.receiver = receiver;
    }
 
    /**
     * 执行命令
     */
    @Override
    public void execute() {
        // 通常会转调接收者对象的相应方法，让接收者来真正执行功能
        receiver.action();
    }
 
}

/**
 * 命令的调用者
 */
public class Invoker {
 
	/**
	 * 持有命令对象
	 */
	private Command command = null;
 
	/**
	 * 设置调用者持有的命令对象
	 * 
	 * @param command 命令对象
	 */
	public void setCommand(Command command) {
		this.command = command;
	}
 
	/**
	 * 示意方法，调用命令执行请求
	 */
	public void invoke() {
		command.execute();
	}
}


public class Client {
	public static void main(String[] args) {
		// 创建接收者
		Receiver receiver = new Receiver();
		// 创建命令对象，设定它的接收者
		Command command = new ConcreteCommand(receiver);
		// 创建调用者，把命令对象设置进去
		Invoker invoker = new Invoker();
		invoker.setCommand(command);
		// 调用者调用命令
		invoker.invoke();
	}
}

命令类，使调用者和接收者解耦合，两者都不知道对方的接口。由于发起命令的对象和具体的实现完全解耦，因此扩展新的命令就很容易，只需要实现新的命令对象，然后在装配的时候，把具体的实现对象设置到命令对象中，然后就可以使用这个命令对象，已有的实现完全不用变化。

 

观察者模式

当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新

public class Observer {
    public void update(){
        System.out.println("注意被观察者做出了更新");
    }
}

public class Subject {

    private LinkedList<Observer> list;

    public void attach(Observer observer){
        list.add(observer);
    }

    public void detach(){
        list.removeLast();
    }

    public void remind(){
        list.parallelStream().peek(Observer::update);
    }
}

就是基本的用一个链表存着需要通知的对象的引用，如果状态发生改变，就遍历该链表，并修改状态。

策略模式

定义一系列算法，并进行封装，并使其可相互替换策略模式使得算法可独立于使用它的客户而变化 。

实现其实很简单，定义一个算法接口，然后就有了各种算法实现，调用时，传入不同的算法实现即可；函数式Lambda表达式也是基于策略模式的思想。

 

中介者模式

用一个中介对象来封装一系列的对象交互。中介者使各对象不需要显式地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互。

 

状态模式

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

其实，就利用了基本的组合而已...，说的很高深...

 

访问者模式

表示一个作用于某对象结构中的各元素的操作，可在不改变这些对象本身的情况下，定义作用于这些对象的新操作。

accept方法中调用了visit方法，而不同的visitor对象有不同的visit方法（传入this指针【Element对象】），这样就实现了不改变对象本身但是做出了新操作。

 

迭代器模式

提供一种可顺序访问聚合对象中各个元素的方法但不暴露该对象内部表示。

用内部类实现最好，上JDK源码。双击shift，输入ArrayList，ctrl+F12，找到iterator方法，下面就是Itr私有类的实现方式。

foreach本质就是for(T t : this)

 

职责链模式

职责链模式的实现就是过滤器链，避免请求的发送者和接收者之间的耦合关系，多个对象都有机会处理一个请求对象连成一条链，沿链传递该请求，直到有对象处理。

//过滤器基类
public abstract class AbstractFilter {

    protected AbstractFilter nextFilter;

    //设置下一个过滤器
    public void setNextFilter(AbstractFilter nextFilter) {
        this.nextFilter = nextFilter;
    }

    //过滤逻辑
    public abstract void doFilter(Request request, Response response);
}