外观模式（门面Facade）

定义：要求一个子系统的外部与其内部的通信必须通过一个统一的对象进行。门面模式提供一个高层次的接口，使得子系统更易于使用。

facade.jpg

再简单地说，门面对象是外界访问子系统内部的唯一通道，不管子系统内部是多么杂乱无章，只要有门面对象在，就可以做到“金玉其外，败絮其中”。

角色：

Facade门面角色：客户端可以调用这个角色的方法。此角色知晓子系统的所有功能和责任。一般情况下，本角色会将所有从客户端发来的请求委派到相应的子系统去，也就说该角色没有实际的业务逻辑，只是一个委托类。

subsystem子系统角色：可以同时有一个或者多个子系统。每一个子系统都不是一个单独的类，而是一个类的集合。子系统并不知道门面的存在。对于子系统而言，门面仅仅是另外一个客户端而已。

    //子系统
    public class ClassA {
         public void doSomethingA(){
                 //业务逻辑
         }
    }
    public class ClassB {

         public void doSomethingB(){
                 //业务逻辑
         }
    }
    public class ClassC {

         public void doSomethingC(){
                 //业务逻辑
         }
    }

    //门面对象
    public class Facade {
         //被委托的对象
         private ClassA a = new ClassA();
         private ClassB b = new ClassB();
         private ClassC c = new ClassC();
         //提供给外部访问的方法
         public void methodA(){
                 this.a.doSomethingA();
         }

         public void methodB(){
                 this.b.doSomethingB();
         }

         public void methodC(){
                 this.c.doSomethingC();
         }
    }

优点：
减少系统的相互依赖，提高了灵活性，提高了灵活性。

缺点：
门面模式最大的缺点就是不符合开闭原则。

使用场景：
为一个复杂的模块或子系统提供一个供外界访问的接口，子系统相对独立——外界对子系统的访问只要黑箱操作即可

组合模式

也叫合成模式，有时又叫做部分-整体模式，主要是用来描述部分与整体的关系。

定义：将对象组合成树形结构以表示“部分-整体”的层次结构，使得用户对单个对象和组合对象的使用具有一致性。

角色：

Component抽象构件角色：定义参加组合对象的共有方法和属性，可以定义一些默认的行为或属性。

Leaf叶子构件：叶子对象，其下再也没有其他的分支，也就是遍历的最小单位。

Composite树枝构件：树枝对象，它的作用是组合树枝节点和叶子节点形成一个树形结构。

    //抽象构件
    public abstract class Component {
         //个体和整体都具有的共享
         public void doSomething(){
                 //编写业务逻辑
         }
    }

    public class Composite extends Component {
         //构件容器
         private ArrayList componentArrayList = new ArrayList();
         //增加一个叶子构件或树枝构件
         public void add(Component component){
                 this.componentArrayList.add(component);
         }
         //删除一个叶子构件或树枝构件
         public void remove(Component component){
                 this.componentArrayList.remove(component);
         }
         //获得分支下的所有叶子构件和树枝构件
         public ArrayList getChildren(){
                 return this.componentArrayList;
         }
         public void doSomething(){
                 System.out.println("我是树枝");
                 for(Component component:componentArrayList){
                     component.doSomething();
                 }
         }
    }

    public class Leaf extends Component {
         public void doSomething(){
                 System.out.println("我是叶子");
         }
    }

    public class Client {
         public static void main(String[] args) {
                //创建一个根节点
                 Composite root = new Composite();
                 root.doSomething();
                 //创建一个树枝构件
                 Composite branch = new Composite();
                 //创建一个叶子节点
                 Leaf leaf = new Leaf();
                 //建立整体
                 root.add(branch);
                 branch.add(leaf);
         }
    }

优点：

一棵树形机构中的所有节点都是Component，局部和整体对调用者来说没有任何区别，也就是说，高层模块不必关心自己处理的是单个对象还是整个组合结构，简化了高层模块的代码。

使用了组合模式后，我们可以看看，如果想增加一个树枝节点、树叶节点是不是都很容易，只要找到它的父节点就成，非常容易扩展，符合开闭原则，对以后的维护非常有利。

缺点：

直接使用了实现类(这里指树枝类)！这在面向接口编程上是很不恰当的，与依赖倒置原则冲突

使用场景：

维护和展示部分-整体关系的场景，如树形菜单、文件和文件夹管理。

从一个整体中能够独立出部分模块或功能的场景。

只要是树形结构，就要考虑使用组合模式，这个一定要记住，只要是要体现局部和整体的关系的时候，而且这种关系还可能比较深，考虑一下组合模式吧。

组合模式有两种不同的实现：透明模式和安全模式，上面讲的就是安全模式

透明模式实现：

    //抽象构件
    public abstract class Component {
         //个体和整体都具有的共享
         public void doSomething(){
                 //编写业务逻辑
         }
         //增加一个叶子构件或树枝构件
         public abstract void add(Component component);
         //删除一个叶子构件或树枝构件
         public abstract void remove(Component component);
         //获得分支下的所有叶子构件和树枝构件
         public abstract ArrayList getChildren();
    }

    public class Leaf extends Component {
         @Deprecated
         public void add(Component component) throws UnsupportedOperationException{
                 //空实现,直接抛弃一个"不支持请求"异常
                 throw new UnsupportedOperationException();
         }
         @Deprecated
         public void remove(Component component)throws UnsupportedOperationException{
                 //空实现
                 throw new UnsupportedOperationException();
         }
         @Deprecated
         public ArrayList getChildren()throws UnsupportedOperationException{
                 //空实现
                 throw new UnsupportedOperationException();
         }
    }

个人实现：

     public abstract class Component {
          //个体和整体都具有的共享
          public void doSomething(){
                  //编写业务逻辑
          }
     }

    //抽象构件
    public abstract class ComponentParent exteneds Component{
         //个体和整体都具有的共享
         public void doSomething(){
                 //编写业务逻辑
         }
         //增加一个叶子构件或树枝构件
         public abstract void add(Component component);
         //删除一个叶子构件或树枝构件
         public abstract void remove(Component component);
         //获得分支下的所有叶子构件和树枝构件
         public abstract ArrayList getChildren();
    }