12.牛市股票还亏钱? - 外观模式(Facade Pattern)

12.1 牛市股票还亏钱?

  • 时间: 4月9日19点   地点: 小菜大鸟住所的客厅   人物: 小菜, 大鸟

     “大鸟, 你抄过股票吗?” 小菜问道.

     “炒过, 那是好几年前了, 可惜碰到熊市, 亏得一塌糊涂.” 大鸟坦诚的回答, “你怎么会问起股票来了?”
     ….



  • 具体股票房地产类

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    // 股票1
    public class Stock1 {
    // 买股票
    public void sell() {
    System.out.println("股票1卖出");
    }
    // 买股票
    public void buy() {
    System.out.println("股票1买入");
    }
    }
    // 股票2等类似, 代码略.
  • 客户端代码调用

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    public static void main(String[] args) {
    Stock1 gu1 = new Stock1();
    Stock2 gu2 = new Stock2();
    Stock3 gu3 = new Stock3();
    NationalDebt1 nd1 = new NationalDebt1();
    Realty1 rt1 = new Realty1();
    gu1.buy();
    gu2.buy();
    gu3.buy();
    nd1.buy();
    rt1.buy();
    gu1.sell();
    gu2.sell();
    gu3.sell();
    nd1.sell();
    rt1.sell();
    }

12. 3 投资基金的代码

     “很好, 如果我们现在增加基金类, 将如何做?”
     “那就应该是这个样子了.”
     “小菜写出了股民投资基金的模板”



  • 基金类如下

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    public class Fund {
    Stock1 gu1 = new Stock1();
    Stock2 gu2 = new Stock2();
    Stock3 gu3 = new Stock3();
    NationalDebt1 nd1 = new NationalDebt1();
    Realty1 rt1 = new Realty1();
    public void buyFund() {
    gu1.buy();
    gu2.buy();
    gu3.buy();
    nd1.buy();
    rt1.buy();
    }
    public void sellFund() {
    gu1.sell();
    gu2.sell();
    gu3.sell();
    nd1.sell();
    rt1.sell();
    }
    }
  • 客户端如下

    1
    2
    3
    4
    5
    6
    7
    public static void main(String[] args) {
    Fund jijin = new Fund();
    // 基金购买
    jijin.buyFund();
    // 基金赎回
    jijin.sellFund();
    }

     “很好很好, 你这样的写法, 基本就是外观模式的基本代码结构了. 现在我们来看看什么叫外观模式.”

12. 3 外观模式

外观模式(Facade), 为子系统中的一组接口提供一个一致的界面, 此模式定义了一个高层接口, 这个接口使得这一子系统更加容易使用.[DP]

  • 四个系统子类

    1
    2
    3
    4
    5
    6
    public class SubSystemOne {
    public void methodOne() {
    System.out.println("子系统方法一");
    }
    }
    // 其余的子系统类似, 略.
  • 外观类

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    public class Facade {
    SubSystemOne one = new SubSystemOne();
    SubSystemTwo two = new SubSystemTwo();
    SubSystemThree three = new SubSystemThree();
    SubSystemFour four = new SubSystemFour();
    public void methodA() {
    System.out.println("方法组A-----");
    one.methodOne();
    two.methodOne();
    four.methodOne();
    }
    public void methodB() {
    System.out.println("方法组B-----");
    two.methodOne();
    three.methodOne();
    }
    }
  • 客户端调用

    1
    2
    3
    4
    5
    6
    public static void main(String[] args) {
    Facade facade = new Facade();
    facade.methodA();
    facade.methodB();
    }

     “对于面向对象有一定的基础的朋友, 及时没有听说过外观模式, 也完全有可能在很多时候使用它, 因为它完美的体现了依赖倒转原则迪米特原则的思想, 是非常常用的模式之一.”



12. 5 何时使用外观模式

     “那外观模式在什么时候使用最好呢?” 小菜问道.
     “这要分三个阶段来说, 首先, 在设计初期阶段, 应该要有意识地将不同的两个层分离, 比如经典的三层架构, 就需要考虑在数据访问层和业务逻辑层, 业务逻辑层和表示层的层与层之间建立外观模式, 这样就可以为复杂的子系统提供一个简单的借口, 是的耦合大大降低. 其次, 在开发阶段, 子系统往往因为不断的重构演化而变得越来越复杂, 大多数的模式使用时也都会产生很多小类, 这本是好事, 但也给外部调用它们的用户程序带来了使用上困难, 增加外观可以提供一个简单的接口, 减少他们之间的依赖. 第三, 在维护一个遗留的大型系统时, 可能这个系统已经非常难以维护和扩展了, 但是因为他包含非常重要的功能, 新的需求开发必须要依赖于他. 此时使用外观模式也是非常合适的. 你可以为新的系统开发一个外观类, 来提供设计粗糙或高度复杂的遗留代码的比较清晰简单的接口, 让新系统与外观对象交互, 外观对象与遗留代码交互所有复杂的工作.[R2P]
     “恩, 对的, 对于复杂难以维护的老系统, 直接去改或去扩展都可能产生很多问题, 分两个小组, 一个开发 Facade 与老系统的交互, 拎一个只要了解 Facade 的接口, 直接开开发新系统调用这些接口即可, 确实可以减少很多不必要的麻烦.”
     “OK, 我明白了, 明天把股票卖了, 该去买基金.” 小菜感觉到了方向.
     “哈, 小菜呀小菜, 该不是你自己炒股票亏钱了吧?” 大鸟微笑的看着小菜.
     “嘿嘿,” 小菜脸通红, “我当然也是参与了一点点. 谁叫你补觉外观模式, 害得我好容易攒了点钱却白白亏了不少.”
     “啊, 怪我喽?” 大鸟一脸无辜.

~感谢捧场,您的支持将鼓励我继续创作~