外观模式

GOF《设计模式》一书对Facade模式是这样描述的:
       为子系统中的一组接口提供一个统一接口。Facade模式定义了一个更高层的接口，使子系统更加容易使用。
       大致意思是说：使用一种比原有方式更简单的办法与系统交互。例如， 我们把一个很文件的文件，放在了第二抽屉里，而第二个抽屉的钥匙放在了第一个抽屉里，我们要想取出这个文件，第一步肯定要拿到第一个抽屉的钥匙，然后打开 它再拿出第二个抽屉的钥匙，最后打开第二个抽屉取出文件。
       我就上面说的那个情形写一下实现代码，首先我们要实现二个子系统,呵呵，把抽屉比喻成系统，有点夸张了（DrawerOne、DrawerTwo）：
class DrawerOne {
    public void open(){
       System.out.println("第一个抽屉被打开了");
       getKey();
    }
    public void getKey(){
       System.out.println("得到第二个抽屉的钥匙");
    }
}
class DrawerTwo{
    public void open(){
       System.out.println("第二个抽屉被打开了");
       getFile();
    }
    public void getFile(){
       System.out.println("得到这个重要文件");
    }
}
public class Client{
    public static void main(String []args){
       DrawerOne darwerOne=new DrawerOne();
       DrawerTwo darwerTwo=new DrawerTwo();
       darwerOne.open();
       darwerTwo.open();
    }
}
由于没有使用Façade模式，可以看到要想得到这个文件要首先打开第一个抽屉，然后再打开第二个抽屉，在我们实际所开发的系统中，有时候客户要实现某一操作，并不需要知道实现这一操作的详细步骤，而是简单地点击某一个按钮就可以得到自己想要的结果。下面对上面的代码使用Façade模式进行改进，建立一个FacadeDrawer类：
class DrawerFacade{
    DrawerOne darwerOne=new DrawerOne();
    DrawerTwo darwerTwo=new DrawerTwo();
    public void open(){
       darwerOne.open();
       darwerTwo.open();
    }
}
修改Client类：
public class DrawerClient{
    public static void main(String []args){
       DrawerFacade drawer=new DrawerFacade();
       drawer.open();
    }
}
输出结果如下：
第一个抽屉被打开了
得到第二个抽屉的钥匙
第二个抽屉被打开了
得到这个重要文件
正如上面所说，客户端client，它并不需要关心子系统，而是关心DrawerFacade所留下来的和外部交互的接口，而子系统在DrawerFacade的聚合。
以上只是个人拙见，哪里有不正确的地方，希望大家多多批评指正。^_^
    Facade模式主要适用于以下几种情况:
1)    不需要使用一个复杂系统的所有功能，而且可以创建一个新的类，包含访问系统的所有规则。如果只需要使用系统的部分功能，那么你为新类所创建的API将比原系统的API简单的多。
2)    希望封装或者隐藏系统原系统。
3)    希望使用原系统的功能，而且还希望增加一些新的功能。
4)    编写新类的成本小于所有人学会使用或者未来维护原系统上所需的成本。





外观模式(Facade pattern),用户操作不同的子系统，要解决用户与子系统的高耦合度，则使用此模式，增加一个用户操作系统，用户可通过此系统，操作到其他子系统，从而降低用户与子系统的耦合。
例如顾客要买肉，水果，用品。顾客一与顾客二买的东西有些一样，有些不一样。
子系统：
Java代码
1. public class Fruit { 
2.    public String apple; 
3.    public String pear; 
4. } 
水果
Java代码
1. public class Meat { 
2.     public String fish; 
3.     public String chicken; 
4. } 
肉
Java代码
1. public class Things { 
2.     public String pot; 
3.     public String bowl; 
4. } 
用品。
如果不使用外观模式
顾客一买水果中的苹果，肉食的鱼
Java代码
1. public class ClientA { 
2.     public void buy(){ 
3.         Fruit f = new Fruit(); 
4.         f.apple="1"; 
5.         Meat m = new Meat(); 
6.         m.chicken="2"; 
7.     } 
8. } 
顾客二买水果中的梨，用品中的盆
Java代码
1. public class ClientB { 
2.     public void buy(){ 
3.         Fruit f = new Fruit(); 
4.         f.pear="3"; 
5.         Things t = new Things(); 
6.         t.pot="2"; 
7.     } 
8. } 
这样可以看出顾客类，直接在操作子系统。

如果使用外观模式，可以提供一个商场，顾客可以去商场买。
Java代码
1. public class Shop { 
2.     Fruit f = new Fruit(); 
3.     Things t = new Things(); 
4.     Meat m = new Meat(); 
5. } 

顾客可从这里去买自己想要的。
Java代码
public class ClientC { 
    public void buy(){ 
        Shop s = new Shop(); 
        s.f.apple="1"; 
        s.m.chicken="2"; 
        s.t.pot="3"; 
    } 
} 

这里不难看出此模式重要作用也是解耦