软件构造复习3

1.可复用性的度量、形态与外部表现

白盒复用：源代码可见，可修改和扩展
黑盒复用：源代码不可见，不能修改
白盒框架：通过代码层面的继承进行框架扩展
黑盒框架：通过实现特定接口/delegation进行
框架扩展

2.面向复用的软件构造技术

LSP原则：在任何可以使用父类的情况中，都可以用子类代替
应用条件：
1.子类型可以增加方法，但不可删除方法
2.子类型需要实现抽象类型中的所有未实现方法
3.子类型中重写的方法必须有相同或子类型的返回值或者符合co-variance的参数
4.子类型中重写的方法必须使用同样类型的参数或者符合contra-variance的参数
5.子类型中重写的方法不能抛出额外的异常

规约条件：
1.更强的不变量
2.更弱的前置条件
3.更强的后置条件

协变：返回值不变或更具体
逆变：参数不变或更抽象，目前Java遇到逆变，当作overload看待

泛型的LSP：泛型不支持协变，如List与List没有关系

“委托”发生在object层面，而“继承”发生在class层面
delegation的类型：
1.临时性的delegation

2.永久性的delegation
聚合式（更加灵活，可动态传入）

组成式

3.面向复用的设计模式

1.Adapter Pattern（适配器模式）
将某个类/接口转换为client期望的其他形式。通过增加一个接口，将已存在的子类封装起来，client面向接口编程，从而隐藏了具体子类。

2. Decorator（装饰模式）

最终实现Inter inter = new A(new B(new C(new E))); //逐层委托

3.Facade（外观模式）
客户端需要通过一个简化的接口来访问复杂系统内的功能，提供一个统一的接口来取代一系列小接口调用，相当于对复杂
系统做了一个封装，简化客户端使用

内部可用switch case来选择不同情况

4.Strategy Pattern（策略模式）
为不同的实现算法构造抽象接口，利用delegation，运行时动态传入client倾向的算法类实例

5.Template Method（模板模式）
做事情的步骤一样，但具体方法不同。共性的步骤在抽象类内公共实现，差异化的步骤在各个子类中实现

6.Iterator Pattern（迭代器模式）
客户端希望遍历被放入容器/集合类的一组ADT对象，无需关心容器的具体类型 – 也就是说，不管对象被放进哪里，都应该提供同样的遍历方式

类A

class A
 {
	int k;
	public A (int k)
	{
		this.k = k;
	}
 }

类B

class B
 {
	 Set<A> set ;
	 public B (Set<A> set)
	 {
		 this.set = set;
	 }
 }

现在要遍历类B中的Set,按k的从小到大顺序

步骤一：实现A的比较器，即让A实现comparable接口，重写comparaTo()方法

public class A implements Comparable<A>
{
	 int k;
	public A (int k)
	{
		this.k = k;
	}
	@Override
	public int compareTo(A o) {
		return this.k-o.k;
	}
}

步骤二：实现A的迭代器，即构造一个新类AInterator,让其实现Iterator接口，并重写hasNext(),next()方法，且在传入Set时，对其重新排序

public class AInterator implements Iterator<Integer>{

	List<A> list ;
	int count = 0;
	public AInterator(Set<A> set)
	{
		list = new ArrayList<A>(set);
		Collections.sort(list); //重新排序
	}
	@Override
	public boolean hasNext() {
		
		return count<list.size();
	}

	@Override
	public Integer next() {
		A a = list.get(count);
		count++;
		return a.get(); //返回k值
	}

}

步骤三：B类实现Iterable接口，重写iterator()方法

class B implements Iterable<Integer>
 {
	 Set<A> set ;
	 public B (Set<A> set)
	 {
		 this.set = set;
	 }
	@Override
	public Iterator<Integer> iterator() {
		
		return new AInterator(set);
	}
 }

步骤四：开始迭代

Iterator<Integer> iterator = new B(set).iterator();//迭代
		while(iterator.hasNext())
		 {
			 int p = iterator.next();
			 System.out.println(p);
		 }