设计模式（适配器模式，外观模式）

适配器模式图例所示：

二孔插头和三孔插座是解耦的，一个不知道另一个，实现了解耦。

适配器模式定义：将一个类的接口，转换成客户期望的另一个接口。适配器可以让原本不兼容的两个类相互合作。

Duck.java

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

MallardDuck.java

public class MallardDuck implements Duck{
     public void quack(){
	     System.out.println("quack");
	}
	
	public void fly(){
	     System.out.println("i'm flying");
	}
}

Turkey.java

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

WildTurkey.java

public class WildTurkey implements Turkey{
    public void gobble(){
	     System.out.println("Gobble gobble");
	}
	
	public void fly(){
	    System.out.println("i'm flying");
	}
}

TurkeyAdapter.java

public class TurkeyAdapter implements Duck{
    Turkey turkey;
	
	public TurkeyAdapter(Turkey turkey){
	     this.turkey = turkey;
	}
	
	public void quack(){
	    turkey.gobble();
	}
	
	public void fly(){
	     for(int i=0;i<5;i++){
		     turkey.fly();
		}
	}
}

DuckTestDrive.java

public class DuckTestDrive{

     public static void main(String[] args){
	     MallardDuck duck = new MallardDuck();
		 WildTurkey turkey = new WildTurkey();
		 Duck turkeyAdapter = 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(turkeyAdapter);
		 
	}
	
	public static void testDuck(Duck duck){
	        duck.quack();
		duck.fly();
	}
}

以上是基于对象适配器的模式，还有一种 基于类适配器模式。

对象适配器模式：拿上面的代码说，Turkey接口当做client看待，Duck接口当做被适配者看待，TurkeyAdapter适配器用Turkey对象实现了Duck接口的方法。（单继承组合方式）

类适配器模式  ：Turkey接口，Duck接口，Adapter适配器继承Turkey接口和Duck接口，使得Tukey的子类通过Adapter适配器可以使用Duck的子类。(多重继承的方式，c++支持，java不支持多重继承)

         

class adapter public：Turkey接口的子类，public Duck接口的子类{ }

相对类适配器而言，对象适配器的 优点就是：可以适配 某个类，而且也可以适配它的子类；

                                                         而缺点就是： 当被适配者的子类加入一个行为方法后，适配器又需要重新改动。

装饰者模式应用场景：一个已经设计的类，需要加入一些新的行为责任到类中。

适配器模式应用场景：把两个不相干的类，通过一个接口（适配器）来链接两者。两个类不在乎接口怎么实现的，只要两者之间可以相互作用。

外观模式应用场景 ：把许多的细枝末节过程用一个方法打包起来，调用这个方法，就实现了里面的细枝末节。