设计模式GOF23之-----------行为型模式（责任链模式、迭代器模式、中介者模式、命令模式、解释器模式、访问者模式、模版方法模式、状态模式、观察者模式、备忘录模式）

一 责任链模式

       任链模式是一种对象的行为模式。在责任链模式里，很多对象由每一个对象对其下家的引用而连接起来形成一条链。请求在这个链上传递，直到链上的某一个对象决定处理此请求。发出这个请求的客户端并不知道链上的哪一个对象最终处理这个请求，这使得系统可以在不影响客户端的情况下动态地重新组织和分配责任。

责任链模式的结构

　　下面使用了一个责任链模式的最简单的实现。

　　责任链模式涉及到的角色如下所示：

　　●　　抽象处理者(Handler)角色：定义出一个处理请求的接口。如果需要，接口可以定义 出一个方法以设定和返回对下家的引用。这个角色通常由一个Java抽象类或者Java接口实现。上图中Handler类的聚合关系给出了具体子类对下家的引用，抽象方法handleRequest()规范了子类处理请求的操作。

　　●　　具体处理者(ConcreteHandler)角色：具体处理者接到请求后，可以选择将请求处理掉，或者将请求传给下家。由于具体处理者持有对下家的引用，因此，如果需要，具体处理者可以访问下家。

下面我们来看一个员工请假的例子：

首先我们封装请假的基本信息 ：

package GOF23;

/**
 * 封装请假的基本信息
 * 
 * @author lenovo
 *
 */
public class Chain_LeaveRequest {
	private String empName;
	private int leaveDays;
	private String reason;

	public Chain_LeaveRequest(String empName, int leaveDays, String reason) {
		super();
		this.empName = empName;
		this.leaveDays = leaveDays;
		this.reason = reason;
	}

	public String getEmpName() {
		return empName;
	}

	public void setEmpName(String empName) {
		this.empName = empName;
	}

	public int getLeaveDays() {
		return leaveDays;
	}

	public void setLeaveDays(int leaveDays) {
		this.leaveDays = leaveDays;
	}

	public String getReason() {
		return reason;
	}

	public void setReason(String reason) {
		this.reason = reason;
	}
}

构建领导的抽象类：

package GOF23;

/**
 * 抽象类
 * 
 * @author lenovo
 *
 */
public abstract class Chain_Leader {
	protected String name;
	protected Chain_Leader nextLeader; // 责任链的后继对象

	public Chain_Leader(String name) {
		super();
		this.name = name;
	}

	public Chain_Leader getNextLeader() {
		return nextLeader;
	}

	// 设定责任链上的后继对象(即设置他们的上司)
	public void setNextLeader(Chain_Leader nextLeader) {
		this.nextLeader = nextLeader;
	}
	
	/**
	 * 处理请求的核心业务方法
	 * @param request
	 */
	public abstract void handleRequest(Chain_LeaveRequest request);
	
}

下面将实现三个领导，对上面的抽象类实例化：

package GOF23;
/**
 *主任
 * @author lenovo
 *
 */
public class Chain_Director extends Chain_Leader {

	public Chain_Director(String name) {
		super(name);
	}

	@Override
	public void handleRequest(Chain_LeaveRequest request) {
		if(request.getLeaveDays() < 3) {
			System.out.println("员工：" + request.getEmpName() + " 请假天数：" + request.getLeaveDays() + " 理由： " + request.getReason());
			System.out.println("主任：" + this.name + "审批通过！");
		} else {
			if(this.nextLeader != null) {
				this.nextLeader.handleRequest(request);
			}
		}
	}

}

package GOF23;
/**
 * 经理
 * @author lenovo
 *
 */
public class Chain_Manager extends Chain_Leader {

	public Chain_Manager(String name) {
		super(name);
	}

	@Override
	public void handleRequest(Chain_LeaveRequest request) {
		if(request.getLeaveDays() < 10) {
			System.out.println("员工：" + request.getEmpName() + " 请假天数：" + request.getLeaveDays() + " 理由： " + request.getReason());
			System.out.println("经理：" + this.name + "审批通过！");
		} else {
			if(this.nextLeader != null) {
				this.nextLeader.handleRequest(request);
			}
		}
	}

}

package GOF23;
/**
 * 总经理
 * @author lenovo
 *
 */
public class Chain_GeneralManager extends Chain_Leader {

	public Chain_GeneralManager(String name) {
		super(name);
	}

	@Override
	public void handleRequest(Chain_LeaveRequest request) {
		if(request.getLeaveDays() < 30) {
			System.out.println("员工：" + request.getEmpName() + " 请假天数：" + request.getLeaveDays() + " 理由： " + request.getReason());
			System.out.println("总经理：" + this.name + "审批通过！");
		} else {
				System.out.println("莫非" + request.getEmpName() + "想辞职, 居然请假" + request.getLeaveDays() + "天！");
			}
		}
}

客户端：

package GOF23;

public class Chain_Client {

	public static void main(String[] args) {
		Chain_Leader a = new Chain_Director("张三");
		Chain_Leader b = new Chain_Manager("李四");
		Chain_Leader c = new Chain_GeneralManager("王五");

		// 组织责任链对象的关系
		a.setNextLeader(b); // a的领导是b;
		b.setNextLeader(c); // b的领导是c

		// 开始请假操作
		Chain_LeaveRequest req1 = new Chain_LeaveRequest("Tom", 200, "回英国老家探亲！");
		a.handleRequest(req1);

	}
}

结果：

核心代码：

	public void handleRequest(Chain_LeaveRequest request) {
		if(request.getLeaveDays() < 3) {
			System.out.println("员工：" + request.getEmpName() + " 请假天数：" + request.getLeaveDays() + " 理由： " + request.getReason());
			System.out.println("主任：" + this.name + "审批通过！");
		} else {
			if(this.nextLeader != null) {
				this.nextLeader.handleRequest(request);
			}
		}
	}

责任链从主任--经理--总经理一步一步移交，由于天数大于了10，最后交给总经理处理。

责任链的作用

• 弱化了发出请求的人和处理请求的人之间的关系
  发出请求的人只需要向第一个具体的处理者发送请求，然后就可以不用管了，处理者会在责任链上自己寻找处理的方法。
  这样就解耦了处理者和请求者之间的关系。
  如果我们不采取责任链模式，那么请求者就必须要很清楚哪个处理者能处理它的请求，就必须对所有的处理者都有所了解，类似于上帝视角，然而在实际中，要求请求这了解这么多是不实际的

• 可以动态的改变责任链
  责任链还有的好处就是可以动态的改变责任，删除或者添加或者改变顺序。

• 让各个处理者专注于实现自己的职责
  责任链模式同时还做到了处理者之间的解耦，处理者自己专注于自己的处理逻辑就好，不管其他处理者干什么。

• 推卸责任也可能导致处理延迟
  我们可以责任链模式需要在责任链上传播责任，直至找到合适的处理对象。这样提高了程序的灵活性，但同时也出现了处理的延迟，因为有一个寻找的过程。所以需要低延迟的情况下，就不应该使用责任链模式

责任链模式的应用

在视窗系统中，经常会使用到责任链模式，尤其是事件的处理，熟悉javascript开发的朋友，可能会知道，浏览器中的事件有冒泡机制，，就是事件的是向父控件传播的，如果自己处理不了，就会传播给父控件去处理。

二 迭代器模式

代器模式定义

迭代器模式（Iterator），提供一种方法顺序访问一个聚合对象中的各种元素，而又不暴露该对象的内部表示。

迭代器模式的角色构成

(1)迭代器角色（Iterator）:定义遍历元素所需要的方法，一般来说会有这么三个方法：取得下一个元素的方法next()，判断是否遍历结束的方法hasNext()），移出当前对象的方法remove(),

(2)具体迭代器角色（Concrete Iterator）：实现迭代器接口中定义的方法，完成集合的迭代。

(3)容器角色(Aggregate):  一般是一个接口，提供一个iterator()方法，例如java中的Collection接口，List接口，Set接口等

(4)具体容器角色（ConcreteAggregate）：就是抽象容器的具体实现类，比如List接口的有序列表实现ArrayList，List接口的链表实现LinkList，Set接口的哈希列表的实现HashSet等。

迭代器模式应用的场景及意义
(1)访问一个聚合对象的内容而无需暴露它的内部表示

(2)支持对聚合对象的多种遍历

(3)为遍历不同的聚合结构提供一个统一的接口

迭代器模式四个角色之间的关系可以用类图表示

 

下面我们来看一个自定迭代器的例子：

 (1)迭代器角色（Iterator）

package GOF23;
/**
 * 自定义迭代器接口
 * @author lenovo
 *
 */
public interface MyIterator {
	void first(); //将游标指向第一个元素
	void next(); //将游标指向下一个元素
	boolean hasNext(); //判断是否存在下一个元素
	
	boolean isFirst();
	boolean isLast();
	
	Object getCurrentobj(); //获取当前游标指向的对象
}

（2）具体容器角色（ConcreteAggregate）+具体迭代器角色（Concrete Iterator作为ConcreteAggregate的内部类）

package GOF23;

import java.util.ArrayList;
import java.util.List;

/**
 * 自定义聚合类
 * 
 * @author lenovo
 *
 */
public class ConcreteMyAggreate {
	// 定义容器
	private List