外观模式：为子系统的一组接口提供一个一致的界面，此模式定义了一个高层接口，使得这个子系统更加容易使用

    优点：知道哪些子系统类负责处理请求，并将请求代理给合适的子系统对象，降低用户操作与子系统类的耦合

    实现：散户炒股，很容易亏钱，因为需要学习的专业知识太多了，面对市场上成千上万的股票，不知道如何选择，这时候有一个相对保险的方案：买基金。基金的经理人，拥有专业的证券知识，了解各个股市的行情，他把散户的资金集中起来，去投资不同的股票。其实这就运用到了外观模式，散户炒股，需要了解各式各样的股票，这就意味着跟股票类的耦合度过高，而买基金，用户只需要了解基金类，而基金类去跟各式各样的股票类打交道，这就降低了耦合度。

    1、股票类

    1. /**
    2.  * 股票一
    3.  */
    4. public class StockOne {
    5.     public void buy(){
    6.         System.out.println("股票一买入");
    7.     }
    9.     public void sell(){
    10.         System.out.println("股票一卖出");
    11.     }
    12. }
    14. /**
    15.  * 股票二
    16.  */
    17. public class StockTwo {
    18.     public void buy(){
    19.         System.out.println("股票二买入");
    20.     }
    22.     public void sell(){
    23.         System.out.println("股票二卖出");
    24.     }
    25. }
    27. /**
    28.  * 股票三
    29.  */
    30. public class StockThree {
    31.     public void buy(){
    32.         System.out.println("股票三买入");
    33.     }
    35.     public void sell(){
    36.         System.out.println("股票三卖出");
    37.     }
    38. }

    2、基金类

    1. /**
    2.  * 基金类（外观类）
    3.  */
    4. public class Fund {
    5.     StockOne stockOne;
    6.     StockTwo stockTwo;
    7.     StockThree stockThree;
    9.     public Fund(){
    10.         stockOne = new StockOne();
    11.         stockTwo = new StockTwo();
    12.         stockThree = new StockThree();
    13.     }
    15.     /**
    16.      * 买入
    17.      */
    18.     public void buy(){
    19.         stockOne.buy();
    20.         stockTwo.buy();
    21.         stockThree.buy();
    22.     }
    24.     /**
    25.      * 卖出
    26.      */
    27.     public void sell(){
    28.         stockOne.sell();
    29.         stockTwo.sell();
    30.         stockThree.sell();
    31.     }
    32. }

    3、测试类

    1. /**
    2.  * 测试外观模式
    3.  */
    4. public class TestFacade {
    5.     public static void main(String [] args){
    6.         Fund fund = new Fund();
    7.         fund.buy();
    8.         fund.sell();
    9.     }
    10. }

    测试结果：
    image.png

    很多人可能没有了解过外观模式，但是在开发很多时候会使用到它，是非常常用的设计模式之一。
    外观模式通常的使用场景：
    1、在设计初期，需要有意识的将不同的层分离，比如经典的三层架构，层与层直接建立外观facade
    2、在开发阶段，子系统会因为不断的重构演化而变得越来越复杂，增加外观facade可以提供一个简单的接口，减少类之间的依赖
    3、在维护大型遗留系统时，可能这个系统已经很难维护和拓展了，但是又有非常重要的功能，新开发必须依赖它，这时候就可以用到外观模式，提供一个比较清晰的接口，新系统与facade交互，facade与遗留代码进行复杂交互