01 适配器模式（Adapter）

适配器模式

实现方式

适配器模式将某个类的接口转换成客户端期望的另一个接口表示，目的是消除由于接口不匹配所造成的类的兼容性问题。主要分为三类：类的适配器模式、对象的适配器模式、接口的适配器模式。

1. 类的适配器模式
   核心思想：Source 类，拥有一个方法，待适配，目标接口是Targetable，通过Adapter类，将Source的功能扩展到Targetable里，看代码：

	public class Source {    
	    public void method1() {  
	        System.out.println("this is original method!");  
	    }  
	}  
	public interface Targetable {    
	    /* 与原类中的方法相同 */  
	    public void method1();    
	    /* 新类的方法 */  
	    public void method2();  
	}  
	public class Adapter extends Source implements Targetable {  
	    @Override  
	    public void method2() {  
	        System.out.println("this is the targetable method!");  
	    }  
	}  
	//Adapter类继承Source类，实现Targetable接口，下面是测试类：
	public class AdapterTest {    
	    public static void main(String[] args) {  
	        Targetable target = new Adapter();  
	        target.method1();  
	        target.method2();  
	    }  
	}  
	//输出：
	//this is original method!
	//this is the targetable method!
	//这样Targetable接口的实现类就具有了Source类的功能。

2. 对象的适配器模式
   基本思路和类的适配器模式相同，只是将Adapter类作修改，这次不继承Source类，而是持有Source类的实例，以达到解决兼容性的问题。看图：

	//只需要修改Adapter类的源码即可：
	public class Wrapper implements Targetable {    
	    private Source source;        
	    public Wrapper(Source source){  
	        super();  
	        this.source = source;  
	    }  
	    @Override  
	    public void method2() {  
	        System.out.println("this is the targetable method!");  
	    }    
	    @Override  
	    public void method1() {  
	        source.method1();  
	    }  
	}  
	//测试类：
	 public class AdapterTest {    
	    public static void main(String[] args) {  
	        Source source = new Source();  
	         Targetable target = new Wrapper(source);  
	         target.method1();  
	        target.method2();  
	    }  
	}  
	//输出与第一种一样，只是适配的方法不同而已。

3. 接口的适配器模式，接口的适配器是这样的：有时我们写的一个接口中有多个抽象方法，当我们写该接口的实现类时，必须实现该接口的所有方法，
   这明显有时比较浪费，因为并不是所有的方法都是我们需要的，有时只需要某一些，此处为了解决这个问题，我们引入了接口的适配器模式，借助于一个抽象类，该抽象类实现了该接口，实现了所有的方法，而我们不和原始的接口打交道，只和该抽象类取得联系，所以我们写一个类，继承该抽象类，重写我们需要的方法就行。
   看一下类图：

	public interface Sourceable {        
	    public void method1();  
	    public void method2();  
	}  
	//抽象类Wrapper2：
	public abstract class Wrapper2 implements Sourceable{        
	    public void method1(){}  
	    public void method2(){}  
	}
	public class SourceSub1 extends Wrapper2 {  
	    public void method1(){  
	        System.out.println("the sourceable interface's first Sub1!");  
	    }  
	}  
	public class SourceSub2 extends Wrapper2 {  
	    public void method2(){  
	        System.out.println("the sourceable interface's second Sub2!");  
	    }  
	}  
	public class WrapperTest {    
	    public static void main(String[] args) {  
	        Sourceable source1 = new SourceSub1();  
	        Sourceable source2 = new SourceSub2();          
	        source1.method1();  
	        source1.method2();  
	        source2.method1();  
	        source2.method2();  
	    }  
	}  
	//测试输出：
	//the sourceable interface's first Sub1!
	//the sourceable interface's second Sub2!

这个很好理解，在实际开发中，我们也常会遇到这种接口中定义了太多的方法，以致于有时我们在一些实现类中并不是都需要。看代码：

应用场景

1. 类的适配器模式
   当希望将一个类转换成满足另一个新接口的类时，可以使用类的适配器模式，创建一个新类，继承原有的类，实现新的接口即可。原始类不想改变，但想复用原始类的所有public方法。
2. 对象的适配器模式
   当希望将一个对象转换成满足另一个新接口的对象时，可以创建一个Wrapper类，持有原类的一个实例，在 Wrapper 类的方法中，调用实例的方法。
   依赖原实例，但可以调用想复用的一个或多个方法。
3. 接口的适配器模式
   当不希望实现一个接口中所有的方法时，可以创建一个抽象类 Wrapper，实现所有方法，其它类继承抽象类即可。

---

外观模式(Facade)

外观模式是为了解决类与类之间的依赖关系，像 Spring 可以将类和类之间的关系配置到配置文件中，而外观模式就是将他们的关系放在一个 Facade 类中，降低了类类之间的耦合度，该模式中没有涉及到接口。以一个计算机的启动过程为例

	public class CPU {        
	    public void startup(){  
	        System.out.println("cpu startup!");  
	    }        
	    public void shutdown(){  
	        System.out.println("cpu shutdown!");  
	    }  
	}  
	
	public class Memory {        
	    public void startup(){  
	        System.out.println("memory startup!");  
	    }        
	    public void shutdown(){  
	        System.out.println("memory shutdown!");  
	    }  
	}  
	
	public class Disk {        
	    public void startup(){  
	        System.out.println("disk startup!");  
	    }        
	    public void shutdown(){  
	        System.out.println("disk shutdown!");  
	    }  
	}  
	
	public class Computer {  
	    private CPU cpu;  
	    private Memory memory;  
	    private Disk disk;  
	    
	    public Computer(){  
	        cpu = new CPU();  
	        memory = new Memory();  
	        disk = new Disk();  
	    }        
	    
	    public void startup(){  
	        System.out.println("start the computer!");  
	        cpu.startup();  
	        memory.startup();  
	        disk.startup();  
	        System.out.println("start computer finished!");  
	    }        
	    
	    public void shutdown(){  
	        System.out.println("begin to close the computer!");  
	        cpu.shutdown();  
	        memory.shutdown();  
	        disk.shutdown();  
	        System.out.println("computer closed!");  
	    }  
	}  

	public class User {  
	    public static void main(String[] args) {  
	        Computer computer = new Computer();  
	        computer.startup();  
	        computer.shutdown();  
	    }  
	}

如果我们没有 Computer，那么，CPU、Memory、Disk他们之间将会相互持有实例，产生关系，这样会造成严重的依赖，修改一个类，可能会带来其他类的修改，这不是我们想要看到的，有了 Computer 类，他们之间的关系被放在了 Computer 类里，这样就起到了解耦的作用，这，就是外观模式。

适配器 VS 外观模式

意图不同

适配模式的意图：“改变”接口，以符合客户端的需求；
外观模式的意图：提供子系统的一个简化接口，结偶；