软件构造设计模式（下）

Iterator

Iterator模式是用于遍历集合类的标准访问方法。它可以把访问逻辑从不同类型的集合类中抽象出来，从而避免向客户端暴露集合的内部结构。

Iterable接口：自己的集合类实现
Iterator接口：主要用于遍历Collection集合中的元素，Iterator对象也被称为迭代器。Iterator接口包含三个基本方法，next()，hasNext()，remove()
iterator方法：返回一个iterator的实现

注：在遍历时，迭代变量所获得的是集合元素的值，而不是集合元素本身。

自定义迭代器

public class XX<E> implements Iterable<E>{
	public Iterator<E> iterator(){
		return new XXIterator():
	}
	private class XXIterator implements Iterator<E>{
		public boolean hasNext(){...}
		public E next(){...}
		public void remove(){...}
	}
}

客户端

隐式迭代器

XX<String> xx = new XX<String>(...);
for(String s:xx){...}

显式迭代器

Iterator<String> iterator = yy.iterator();

Facade外观模式

是一种通过为多个复杂的子系统提供一个一致的接口，而使这些子系统更加容易被访问的模式。该模式对外有一个统一接口，外部应用程序不用关心内部子系统的具体的细节，这样会大大降低应用程序的复杂度，提高了程序的可维护性。

Facade类

将客户的请求代理给适当的子系统对象

public class Facade{
	XX a;
	YY b;
	public Facade(){
		a = new XX();
		b = new YY();
	}
	public void method1(){
		this.a.function1();
	}
	public void method1(){
		this.b.function2();
	}
}

子系统

处理Facade指派的任务

public class XX{
	public void function1(){
		...
	}
}
public class YY{
	public void function2(){
		...
	}
}

客户端

Facade facade = new Facade();
facade.method1();
facade.method2():

Proxy代理模式

隔离对复杂对象的访问

Subject抽象角色

通过接口或抽象类声明真实角色实现的业务方法。

public interface Subject{
	void XX();
}

RealSubject代理角色

实现抽象角色，是真实角色的代理，通过真实角色的业务逻辑方法来实现抽象方法，并可以附加自己的操作。

public RealSubject implements Subject{
	public RealSubject(Object o){
		this.o = o;
	}
	@Override
	public void XX(){
		......
	}
}

Proxy真实角色

实现抽象角色，定义真实角色所要实现业务逻辑，供代理角色。

public class Proxy implements Subject{
	public Proxy(Object o){
		this.o = o;
	}
	@Override
	public void XX(){
		new RealSubject(Object o).XX();
	}

客户端

new Proxy(Object o).XX();

Factory/Abstract Factory

State

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

Context类（环境角色）

定义客户端所感兴趣的接口，并且保留一个具体状态类的实例。

class Context{
	State state;
	public Context(State s){
		state = s;
	}
	public int XX(){//具体操作（状态转换）
		return state.XX();
	}
	......
}

State接口（抽象状态角色）

定义一个接口，用来封装环境对象的一个特定的状态所对应的行为。

public interface State{
	public int XX();
}

State的实现类（具体状态角色）

每一个状态类都实现了环境的一个状态所对应的行为。

public class State1 implements State{
	@Override
	public int XX(){...}
}

Memento备忘录模式

在不破坏封闭的前提下，捕获并外部化一个对象的内部状态，这样之后就可以将该对象恢复到保存时的状态。

Memento类

class Memento{
	private State state;
	public Memento(State state){
		this.state = state;
	}
	public State getState(){
		return state;
	}
}

Caretaker类

class Caretaker{
	private List<Memento> mementos = new ArrayList<>():
	public void addMemento(Memento m){
		mementos.add(m);
	}
	public Memento getState(){
		return mementos.get(?);
	}
}

Originator类

class Originator{
	private State state;
	public void setState(State state){
		this.state = state;
	}
	public Memento save(){//记录当前状态
		return new Memento(state);
	}
	public void restore(Memento m){//恢复历史状态
		state = m.getState();
	}
}

客户端

Careteker caretaker = new Caretaker():
Originator originator = new Originator():
originator.setState(“...”);
caretaker.addMemento(originator.save());
orginator.restore(caretaker.getMemento());

Originator相当于具有状态的对象；Caretaker负责记录历史状态集合，兼回滚的功能；Memento负责保存单个状态；客户端不涉及Memento的实例。

比较器

两种方法

Comparable内部比较器

实现Comparable接口，重写CompareTo 方法

...implements Comparable<Object>{
	@Override
	public int compareTo(Object o){...}
}

• 客户端

Collections.sort(...);

Comparator外部比较器

重写compare方法

...implements Comparator<Object>{
	@Override
	public int compare(Object o1,Object o2){...}
}

• 客户端

Collections.sort(...,new Comparator<...>());