GOF23设计模式（十）

GOF设计模式之责任链模式(Chain of Responsibility)与迭代器模式(iterator)

责任链模式(Chain of Responsibility)

将能够处理同一类请求的对象连成一条链，所提交的请求沿着链传递，
这里写一个公司请假流程管理。

管理类

public abstract class Leader {
	protected String name;
	protected Leader nextLeader; //责任链上的后继对象
	public Leader(String name) {
		this.name = name;
	}
	//设定责任链上的后继对象
	public void setNextLeader(Leader nextLeader) {
		this.nextLeader = nextLeader;
	}
	//处理请求的核心代码
	public abstract void handlequest(LeaveRequest request);
}

请假请求

public class LeaveRequest {
	private String empName;
	private int LeaveDays;
	private String reason;
	public LeaveRequest(String empName, int leaveDays, String reason) {
		this.empName = empName;
		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) {
		LeaveDays = leaveDays;
	}
	public String getReason() {
		return reason;
	}
	public void setReason(String reason) {
		this.reason = reason;
	}
}

主任类

public class Director extends Leader{

	public Director(String name) {
		super(name);
	}
	@Override
	public void handlequest(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.handlequest(request);
			}
		}
	}
}

经理类

public class Manager extends Leader{

	public Manager(String name) {
		super(name);
	}
	@Override
	public void handlequest(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.handlequest(request);
			}
		}
	}
}

总经理类

public class GeneralManager extends Leader{

	public GeneralManager(String name) {
		super(name);
	}
	@Override
	public void handlequest(LeaveRequest request) {
		if(request.getLeaveDays()<30) {
			System.out.println("员工："+request.getEmpName()+"请假，天数："+request.getLeaveDays()
			+",理由："+request.getReason());
			System.out.println("总经理："+this.name+"批准");
		}else {
			System.out.println("不通过");
		}
	}
}

测试

public class Client {

	public static void main(String[] args) {
		Leader a=new Director("张三");
		Leader b=new Manager("李四");
		Leader c=new GeneralManager("张三");
		//组织责任链对象关系
		a.setNextLeader(b);
		b.setNextLeader(c);
		//开始请假
		LeaveRequest req1=new LeaveRequest("老王", 15, "回乡下老家探亲");
		a.handlequest(req1);
	}
}

结果

员工：老王请假，天数：15,理由：回乡下老家探亲
总经理：张三批准

迭代器模式(iterator)

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

迭代器接口

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

自定义聚合类

/**
 * 自定义聚合类
 *
 */
public class ConcreteMyAggregate {
	private List<Object> list=new ArrayList<>();

	public void addObject(Object obj) {
		this.list.add(obj);
	}
	public void removeObject(Object obj) {
		this.list.remove(obj);
	}
	public List<Object> getList() {
		return list;
	}
	public void setList(List<Object> list) {
		this.list = list;
	}
	//获得迭代器
	public MyIterator createIterator() {
		return new ConcreteIterator();	
	}
	
	// 内部类定义迭代器，可以使用外部类实现
	private class ConcreteIterator implements MyIterator{
		private int cursor; //定义游标用于记录遍历时的位置 
		@Override
		public void first() {
			cursor=0;
		}

		@Override
		public void next() {
			if(cursor<list.size()) {
				cursor++;
			}
		}

		@Override
		public boolean hasNext() {
			if(cursor<list.size()) {
				return true;
			}
			return false;
		}

		@Override
		public boolean isFirst() {
			return cursor==0?true:false;
		}

		@Override
		public boolean islast() {
			return cursor==(list.size()-1)?true:false;
		}

		@Override
		public Object getCurrentObj() {
			return list.get(cursor);
		}
	}
}

测试

public class Client {

	public static void main(String[] args) {
		ConcreteMyAggregate cma=new ConcreteMyAggregate();
		cma.addObject("a");
		cma.addObject("b");
		cma.addObject("c");
		cma.addObject("d");
		cma.addObject("e");
		MyIterator iter=cma.createIterator();
		while(iter.hasNext()) {
			System.out.println(iter.getCurrentObj());
			iter.next();		}
	}
}

结果

a
b
c
d
e