面向复用的设计模式（Behavioral patterns）

Strategy 策略模式

策略模式基础

**问题提出：**假设有多种不同的算法来实现同一个任务，但是要根据client的需要动态切换算法，不是写死在代码里，这种要求应该如何达到？

**解决方案：**为不同的实现算法构造抽象接口，利用delegation，运行时动态传入client倾向的算法类实例

策略模式实例

Template Method模板模式

模板模式基础

问题提出： 几个客户端共享相同的算法，但在细节上有所不同，即算法由可自定义部分和不变部分组成。 普通步骤不应在子类中重复，而需要重用。那么如何实现此模式？

解决方案： 算法的常见步骤被分解成一个抽象类，抽象（未实现）原语操作表示算法的可定制部分。并且使用继承和重写实现模板模式。

模板模式实例

下面展示一个Template实例。

public abstract class CarBuilder {
	protected abstract void BuildSkeleton();
	protected abstract void InstallEngine();
	protected abstract void InstallDoor();
	// Template Method that specifies the general logic
	public void BuildCar() { //通用逻辑
		BuildSkeleton();
		InstallEngine();
		InstallDoor();
	} 
}

public class PorcheBuilder extends CarBuilder {
	protected void BuildSkeleton() {
		System.out.println("Building Porche Skeleton");
	}
	protected void InstallEngine() {
		System.out.println("Installing Porche Engine");
	}
	protected void InstallDoor() {
		System.out.println("Installing Porche Door");
	} 
}

public class BeetleBuilder extends CarBuilder {
	protected void BuildSkeleton() {
		System.out.println("Building Beetle Skeleton");
	}
	protected void InstallEngine() {
		System.out.println("Installing Beetle Engine");
	}
	protected void InstallDoor() {
		System.out.println("Installing Beetle Door");
	} 
}

下面展示一些 main方法。

public static void main(String[] args) {
	CarBuilder c = new PorcheBuilder();
	c.BuildCar();
	c = new BeetleBuilder();
	c.BuildCar();
}

执行结果：

这里也是Template实例

这是其代码实现

public abstract class OrderProcessTemplate {
	public boolean isGift;
	public abstract void doSelect();
	public abstract void doPayment();
	public final void giftWrap() {
		System.out.println("Gift wrap done.");
	}
	public abstract void doDelivery();
	public final void processOrder() {
	doSelect();
	doPayment();
	if (isGift)
		giftWrap();
	doDelivery();
	} 
}

public class NetOrder extends OrderProcessTemplate {
	@Override
	public void doSelect() { … }
	@Override
	public void doPayment() { … }
	@Override
	public void doDelivery() { … }
}

Iterator 迭代器

迭代器基础

**问题提出：**客户端希望遍历被放入容器/集合类的一组ADT对象，无需关心容器的具体类型。也就是说，不管对象被放进哪里，都应该提供同样的遍历方式。这种遍历方式如何实现？
解决方案： 迭代的策略模式。

迭代器结构

Abstract Iterator class 定义遍历协议
Concrete Iterator subclasses对于每个聚合类（aggregate class）
Aggregate interface创造迭代器的实例
聚合实例保持引用Iterator对象

Iterable接口：实现该接口的容器对象是可迭代遍历的

public interface Iterable<T> {
	...
	Iterator<T> iterator();
}

Iterator接口：迭代器

public interface Iterator<E> {
	boolean hasNext();
	E next();
	void remove();
}

Iterator pattern：让自己的集合类实现Iterable接口，并实现自己的独特Iterator迭代器(hasNext, next, remove)，允许客户端利用这个迭代器进行显式或隐式的迭代遍历：

for (E e : collection) { … }
Iterator<E> iter = collection.iterator(); 
while(iter.hasNext()) { … }

public interface Collection<E> extends Iterable<E> {
	boolean add(E e);
	boolean addAll(Collection<? extends E> c);
	boolean remove(Object e);
	boolean removeAll(Collection<?> c);
	boolean retainAll(Collection<?> c);
	boolean contains(Object e);
	boolean containsAll(Collection<?> c);
	void clear();
	int size();
	boolean isEmpty();
	Iterator<E> iterator();
	Object[] toArray()
	<T> T[] toArray(T[] a);
	…
 }

迭代器实例

public class Pair<E> implements Iterable<E> {
	private final E first, second;
	public Pair(E f, E s) { first = f; second = s; }
	public Iterator<E> iterator() {
		return new PairIterator();
	}
	private class PairIterator implements Iterator<E> {
		private boolean seenFirst = false, seenSecond = false;
		public boolean hasNext() { return !seenSecond; }
		public E next() {
			if (!seenFirst) { seenFirst = true; return first; }
			if (!seenSecond) { seenSecond = true; return second; }
			throw new NoSuchElementException();
		}
		public void remove() {
			throw new UnsupportedOperationException();
		} 
	} 
}