适配器模式

【0】README

0.1）本文部分文字描述转自 "head first设计模式"，旨在学习  适配器模式 的基础知识；

【1】适配器模式定义：将一个类的接口，转换成客户期望的另一个接口。适配器让原本接口不兼容的类可以合作无间；

【2】这里有鸭子pojo，火鸡pojo，我想要将火鸡 装扮为一只鸭子（这就需要适配器来起作用啦）；

• step1）创建Duck 和 Turkey 接口和其子类

public interface Duck {
	public void quack();
	public void fly();
}

public class MallardDuck implements Duck{

	@Override
	public void quack() { // 鸭子叫声
		System.out.println("quack.");
	}

	@Override
	public void fly() {
		System.out.println("flying.");
	}
}

public interface Turkey {
	public void gobble();
	public void fly();
}

public class WildTurkey implements Turkey{

	@Override
	public void gobble() {
		System.out.println("gobble gobble.");
	}

	@Override
	public void fly() {
		System.out.println("wild turkey's fly.");
	}

}

• step2）创建适配器（用火鸡装鸭子）

public class TurkeyAdapter implements Duck{
	private Turkey turkey;
	
	public TurkeyAdapter(Turkey turkey) {
		this.turkey = turkey;
	}
	
	@Override
	public void quack() {
		turkey.gobble();
	}

	@Override
	public void fly() {
		turkey.fly();
	}
}

• step3）适配器测试类

public class TurkeyAdapterTest {
	public static void main(String[] args) {
		MallardDuck duck = new MallardDuck();
		
		WildTurkey turkey = new WildTurkey();
		Duck turkeyApapter = new TurkeyAdapter(turkey);
		
		System.out.println("the turkey says: ");
		turkey.gobble();
		turkey.fly();
		
		System.out.println("\nthe duck says: ");
		testDuck(duck);
		
		System.out.println("\n the turkeyAdapter says: ");
		testDuck(turkeyApapter);
	}
	// 外表是鸭子，实际上是火鸡
	static void testDuck(Duck duck) {
		duck.quack();
		duck.fly();
	}
}

最后，打印结果

the turkey says: 
gobble gobble.
wild turkey's fly.

the duck says: 
quack.
flying.

 the turkeyAdapter says: 
gobble gobble.
wild turkey's fly.<strong style="font-family: 宋体; background-color: rgb(255, 255, 255);"><span>	</span></strong>

【3】适配器模式解析

3.1）客户，适配器和被适配者的关系

3.2）客户使用适配器的过程如下：

• step1）客户通过目标接口调用适配器的方法对适配器发出请求；
• step2）适配器使用被适配者接口把请求转换为被适配者的一个或多个调用接口；
• step3）客户接收到调用的结果，但并未察觉这一切是适配器在其转换作用；
• Attention）客户和被适配器是解耦的，一个不知道另一个；

【4】将枚举适配到迭代器

1）problem：我们经常面对遗留代码，这些代码暴露出枚举器接口，但我们又希望在新的代码中只使用迭代器。想解决这个问题，看来我们需要构造一个适配器。

2）将枚举适配到迭代器

3）代码如下

• step1）构建枚举适配器，将枚举类型适配到迭代器

// 枚举适配器，将枚举类型适配到迭代器
public class MyEnumeratoinAdapter implements Iterator<Object>{
	Enumeration<Object> enumeration;
	
	public MyEnumeratoinAdapter(Collection c) {
		enumeration = Collections.enumeration(c);
	}
	
	@Override
	public boolean hasNext() {
		return enumeration.hasMoreElements();
	}

	@Override
	public Object next() {
		return enumeration.nextElement();
	}

	@Override
	public void remove() {
		Iterator.super.remove();
	}
}

• step2）枚举适配器测试用例

• public class MyEnumerationTest {
  	public static void main(String[] args) {
  		String[] array = new String[]{"D","C","B","A","W"};
  		List<String> list = Arrays.asList(array);
  		// 表面上，adapter是一个迭代器，实质上是 枚举器
  		Iterator adapter = new MyEnumeratoinAdapter(list);
  		
  		while(adapter.hasNext()) {
  			System.out.println(adapter.next());
  		}
  	}
  }

• 打印结果

• D
  C
  B
  A
  W