《大话设计模式》之--第12章 牛市股票还会亏钱？----外观模式

http://blog.csdn.net/monkey_d_meng/article/details/5696192

第12章 牛市股票还会亏钱？----外观模式

12.1牛市股票还会亏钱？

“大鸟，你炒股票吗?”小菜问道。

“炒过，那是好几年前了，可借碰到熊市，亏得一塌糊涂。”大鸟坦诚地回答，“你怎么会问起股票来了？”

“我们公司的人现在都在炒股票，其实大部人都不太懂，就是因为现在股市行情很火，于是都在跟风呢。”

“那他们做得如何?”

“有一个好像还可以，赚了不少钱，具体不太清楚，但另外几个人都是刚入市的，什么都不懂，特别是一个叫顾韵梅的同事，她说得蛮搞笑的，‘今天看好了一只快涨停的股票，买进去，第二天马上就跌了。明天再去换另一只好的股票，几天都不涨，等一卖出，马上就涨停。’于是乎，在大好的牛市行情里，她却连连亏损，天天在我们面前抱怨呀。”

“哈，典型的新股民特征嘛。其实不会炒股票的话，买一只好股票放在那里所谓的‘悟股’是最好的做股票策略了。”

“自己的钱买了股票，天天都在变化，谁能不关心，特别是刚开始，都希望能涨涨涨。尽管不现实，不过赚钱的人还是有的是。不过一打开股票软件，一千多只股票，红红绿绿，又是指数大盘，又是个股K线指标.一下说基本面如何如何重要，一下又说什么有题材才可以赚大钱，头晕眼花，迷茫困惑呀。”

“小菜是不是也在做股票了？刚才提到的顾韵梅的经历，不会是说你自己的吧?”大鸟笑言道。

“哈，是真人真事，不是我。不过我也有点动心，但不知道如何炒，所以最近也下了一个软件，并小研究了一下。发现很复杂呀。”

“就算是你，也没什么不好意思的。其实股民，特别是新股民在没有足够了解证券知识的情况下去做股票，是很容易亏钱的。毕竟，需要学习的知识实在太多了，不具备这些知识就很难做好，再有就是心态也非常重要，刚开始接触股票的人一般都盼涨怕跌，于是心态很不稳定，这反而做不好股票。听说现在心理医生问病人的第一句话就是，‘你炒股票吗？”

“要是有懂行的人帮帮忙就好了。”

“哈，基金就是你的帮手呀。它将投资者分散的资金集中起来，交由专业的经理人进行管理，投资于股票、债券、外汇等领域，而基金投资的收益归持有投资者所有，管理机构收取一定比例的托管管理费用。想想看，这样做有什么好处？”

“我感觉，由于基金会买几十支好的股票，不会因为某个股票的大跌而影响收益，尽管每个人的钱不多，但大家放在一起，反而容易达到好的投资效果。”

“说得不错，那如果是你自己做股票，为什么风险反而大了？”

“因为我需要了解股票的各种信息，需要预测它的未来，还要买入和卖出的时机合适，这其实是很难做到的。专业的基金经理人相对专业，所以就不容易像散户那么盲目。”

“尽管我们在谈股票，我还是想问问你，投资者买股票，做不好的原因和软件开发当中的什么类似？而投资者买基金，基金经理人用这些钱去做投资，然后大家获利，这其实又体现了什么？”

“我知道了，你的意思是说，由于众多投资者对众多股票的联系太多，反而不利于操作，这在软件中是不是就称为耦合性过高。而有了基金以后，变成众多用户只和基金打交道，关心基金的上涨和下跌就可以了，而实际上的操作却是基金经理人在与上千支股票和其他投资产品打交道。”

“小菜越来越不简单了嘛，这段话说得非常好，由于投资者要面对这么多的股票，又不专业，所以很难做好，但要投资者买一支好的基金，这应该是不难的，说白了，投资的目的还不是为了赚钱，那干吗不稳妥一些呢？这里其实提到了一个在面向对象开发当中用得非常多的一个设计模式——外观模式，又叫门面模式。不过为了讲清楚它，你先试着把股民炒股票的代码写写看！”

“这有何难。”

12.2股民炒股代码

小菜写出股民投资的炒股代码结构图

 

[java]  view plain copy

1. //股票、国债、房地产代码  
2. public class Stock1  
3. {  
4.     public void sell()  
5.     {  
6.         System.out.println("股票1卖出");  
7.     }  
8.   
9.     public void buy()  
10.     {  
11.         System.out.println("股票1买入");  
12.     }  
13. }  
14. public class Stock2  
15. {  
16.     public void sell()  
17.     {  
18.         System.out.println("股票2卖出");  
19.     }  
20.   
21.     public void buy()  
22.     {  
23.         System.out.println("股票2买入");  
24.     }  
25. }  
26. public class Stock3  
27. {  
28.     public void sell()  
29.     {  
30.         System.out.println("股票3卖出");  
31.     }  
32.   
33.     public void buy()  
34.     {  
35.         System.out.println("股票3买入");  
36.     }  
37. }  
38. public class NationalDebt1  
39. {  
40.     public void sell()  
41.     {  
42.         System.out.println("国债1卖出");  
43.     }  
44.   
45.     public void buy()  
46.     {  
47.         System.out.println("国债1买入");  
48.     }  
49. }  
50. public class Realty1  
51. {  
52.     public void sell()  
53.     {  
54.         System.out.println("房地产1卖出");  
55.     }  
56.   
57.     public void buy()  
58.     {  
59.         System.out.println("房地产1买入");  
60.     }  
61. }  
62. //客户端代码  
63. public class Main  
64. {  
65.     public static void main(String[] args)  
66.     {  
67.         Stock1 gu1 = new Stock1();  
68.         Stock2 gu2 = new Stock2();  
69.         Stock3 gu3 = new Stock3();  
70.         NationalDebt1 nd1 = new NationalDebt1();  
71.         Realty1 rt1 = new Realty1();  
72.   
73.         gu1.buy();  
74.         gu2.buy();  
75.         gu3.buy();  
76.         nd1.buy();  
77.         rt1.buy();  
78.   
79.         gu1.sell();  
80.         gu2.sell();  
81.         gu3.sell();  
82.         nd1.sell();  
83.         rt1.sell();  
84.     }  
85. }  

大鸟总结道：“这样的代码，用户需要了解股票、国债、房产情况，需要参与这些项目的具体买和卖。耦合性很高。”

12.3投资基金代码

“很好，如果我们现在增加基金类，将如何做？”

“那就是这个样子了。”

小菜写出股民投资的基金版本代码结构图

 

[java]  view plain copy

1. //基金类  
2. public class Fund  
3. {  
4.     Stock1          gu1;  
5.     Stock2          gu2;  
6.     Stock3          gu3;  
7.     NationalDebt1   nd1;  
8.     Realty1         rt1;  
9.   
10.     public Fund()  
11.     {  
12.         gu1 = new Stock1();  
13.         gu2 = new Stock2();  
14.         gu3 = new Stock3();  
15.         nd1 = new NationalDebt1();  
16.         rt1 = new Realty1();  
17.     }  
18.   
19.     public void buyFund()  
20.     {  
21.         gu1.buy();  
22.         gu2.buy();  
23.         gu3.buy();  
24.         nd1.buy();  
25.         rt1.buy();  
26.     }  
27.   
28.     public void sellFund()  
29.     {  
30.         gu1.sell();  
31.         gu2.sell();  
32.         gu3.sell();  
33.         nd1.sell();  
34.         rt1.sell();  
35.     }  
36. }  
37. //客户端代码  
38. public class Main  
39. {  
40.     public static void main(String[] args)  
41.     {  
42.         Fund jijin = new Fund();  
43.         jijin.buyFund();  
44.         jijin.sellFund();  
45.     }  
46. }  

大鸟总结道：“此时，用户不需要了解股票，甚至可以对股票一无所知，买了基金就可以回家睡大觉了，一段时间后再赎回就可以大把数钱了。参与股票的具体买卖都由基金公司完成。客户端代码也非常简洁明了。你这样写的很好，基本就是外观模式的基本代码结构了。现在我们来看看什么叫外观模式。”

12.4外观模式

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

 

[java]  view plain copy

1. //四个子系统的类  
2. public class SubSystemOne  
3. {  
4.     public void methodOne()  
5.     {  
6.         System.out.println("子系统方法1");  
7.     }  
8. }  
9. public class SubSystemTwo  
10. {  
11.     public void methodTwo()  
12.     {  
13.         System.out.println("子系统方法2");  
14.     }  
15. }  
16. public class SubSystemThree  
17. {  
18.     public void methodThree()  
19.     {  
20.         System.out.println("子系统方法3");  
21.     }  
22. }  
23. public class SubSystemFour  
24. {  
25.     public void methodFour()  
26.     {  
27.         System.out.println("子系统方法4");  
28.     }  
29. }  
30. //外观类  
31. public class Facade  
32. {  
33.     SubSystemOne    one;  
34.     SubSystemTwo    two;  
35.     SubSystemThree  three;  
36.     SubSystemFour   four;  
37.   
38.     public Facade()  
39.     {  
40.         one = new SubSystemOne();  
41.         two = new SubSystemTwo();  
42.         three = new SubSystemThree();  
43.         four = new SubSystemFour();  
44.     }  
45.   
46.     public void methodA()  
47.     {  
48.         System.out.println("方法组A");  
49.         one.methodOne();  
50.         two.methodTwo();  
51.         four.methodFour();  
52.     }  
53.   
54.     public void methodB()  
55.     {  
56.         System.out.println("方法组B");  
57.         two.methodTwo();  
58.         three.methodThree();  
59.     }  
60. }  
61. //客户端代码  
62. public class Main  
63. {  
64.     public static void main(String[] args)  
65.     {  
66.         Facade facade = new Facade();  
67.           
68.         facade.methodA();  
69.         facade.methodB();  
70.     }  
71. }  

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

12.5何时使用外观模式

“那外观模式在什么时候使用最好呢？”

“这要分三个阶段来说，首先，在设计初期阶段，应该要有意识将不同的两个层分离，比如经典的三层架构，就需要考虑在数据访问层和业务逻辑层、业务逻辑层和表示层的层与层之间建立外观Facade，这样可以为复杂的子系统提供一个简单的接口，使得耦合度大大降低。其次，在开发阶段，子系统往往因为不断的重构演化而变得越来越复杂，大多数的模式使用时也都会产生很多很小的类，这本是好事，但也给外部调用它们的用户程序带来了使用上的困难，增加外观Facade可以提供一个简单的接口，减少它们之间的依赖。第三，在维护一个遗留的大型系统时，可能这个系统已经非常难以维护和扩展了，但因为它包含非常重要的功能，新的需求开发必须要依赖于它。此时，用外观模式Facade也是非常合适的。你可以为新系统开发一个外观Facade类，来提供设计粗糙或高度复杂的遗留代码的比较清晰的简单接口，让新系统与Facade对象交互，Facade与遗留代码交互所有复杂的工作。”

 

“嗯，对的，对于复杂难以维护的老系统，直接去改或去扩展都可能产生很多问题，分两个小组，一个开发Façade与老系统交互，另一个只要了解Façade的接口，直接开发新系统调用这些接口即可，确实可以减少很多不必要的麻烦。”

“OK，我明白了，明天把股票卖了，改去买基金。”小菜感觉找到了方向。

“哈，小菜呀小菜，该不是你自己炒股票亏钱了吧？”大鸟微笑地看着小菜。

“嘿嘿，”小菜脸通红，“我当然也是参与了一点点。谁叫你不教我外观模式，害得我好容易攒了点钱却白白亏了不少。”

“啊，赖我呀！”大鸟一脸无辜。