读《大话设计模式》－－－外观模式(Facade)

        

外观模式:

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

外观模式结构图

外观模式的一般实现方法：

1. #include <iostream>
2. using namespace std;
4. class SubSystemOne
5. {
6. public:
7. void MethodOne()
8. {
9. cout << " 子系统方法一" << endl;
10. }
11. };
12. class SubSystemTwo
13. {
14. public:
15. void MethodTwo()
16. {
17. cout << " 子系统方法二" << endl;
18. }
19. };
20. class SubSystemThree
21. {
22. public:
23. void MethodThree()
24. {
25. cout << " 子系统方法三" << endl;
26. }
27. };
28. class SubSystemFour
29. {
30. public:
31. void MethodFour()
32. {
33. cout << " 子系统方法四" << endl;
34. }
35. };
36. //外观类，它需要了解所有子系统的方法和属性，进行组合，以备外界使用。
37. class Facade
38. {
39. private:
40. SubSystemOne * one;
41. SubSystemTwo * two;
42. SubSystemThree * three;
43. SubSystemFour * four;
45. public:
46. Facade()
47. {
48. one = new SubSystemOne();
49. two = new SubSystemTwo();
50. three = new SubSystemThree();
51. four = new SubSystemFour();
52. }
53. ~Facade()
54. {
55. delete one;
56. delete two;
57. delete three;
58. delete four;
59. }
60. void MethodA()
61. {
62. cout << "/n方法组A() ---- " << endl;
63. one->MethodOne();
64. two->MethodTwo();
65. four->MethodFour();
66. }
68. void MethodB()
69. {
70. cout << "/n方法组B() ---- " << endl;
71. two->MethodTwo();
72. three->MethodThree();
73. }
74. };
76. //由于Facade的存在，客户端根本不需要知道子系统的存在
77. int main()
78. {
79. Facade * facade = new Facade();
80. facade->MethodA();
81. facade->MethodB();
82. delete facade;
83. return 0;
84. }

Facade模式的具体实现

1. //投资基金代码
3. #include <iostream>
4. using namespace std;
6. //股票1
7. class Stock1
8. {
9. //卖股票
10. public:
11. void Sell()
12. {
13. cout << " 股票1卖出" << endl;
14. }
16. //买股票
17. void Buy()
18. {
19. cout << " 股票1买入" << endl;
20. }
21. };
23. //股票2
24. class Stock2
25. {
26. //卖股票
27. public:
28. void Sell()
29. {
30. cout << " 股票2卖出" << endl;
31. }
33. //买股票
34. void Buy()
35. {
36. cout << " 股票2买入" << endl;
37. }
38. };
40. //股票3
41. class Stock3
42. {
43. //卖股票
44. public:
45. void Sell()
46. {
47. cout << " 股票3卖出" << endl;
48. }
50. //买股票
51. void Buy()
52. {
53. cout << " 股票3买入" << endl;
54. }
55. };
57. //国债1
58. class NationalDebt1
59. {
60. //卖国债
61. public:
62. void Sell()
63. {
64. cout << " 国债1卖出" << endl;
65. }
67. //买国债
68. void Buy()
69. {
70. cout << " 国债1买入" << endl;
71. }
72. };
74. //房地产1
75. class Realty1
76. {
77. //卖房地产
78. public:
79. void Sell()
80. {
81. cout << " 房产1卖出" << endl;
82. }
84. //买房地产
85. void Buy()
86. {
87. cout << " 房产1买入" << endl;
88. }
89. };
91. class Fund
92. {
93. private:
94. Stock1 * gu1;
95. Stock2 * gu2;
96. Stock3 * gu3;
97. NationalDebt1 * nd1;
98. Realty1 * rt1;
100. public:
101. Fund()
102. {
103. gu1 = new Stock1();
104. gu2 = new Stock2();
105. gu3 = new Stock3();
106. nd1 = new NationalDebt1();
107. rt1 = new Realty1();
108. }
109. ~Fund()
110. {
111. delete gu1;
112. delete gu2;
113. delete gu3;
114. delete nd1;
115. delete rt1;
116. }
117. void BuyFund()
118. {
119. gu1->Buy();
120. gu2->Buy();
121. gu3->Buy();
122. nd1->Buy();
123. rt1->Buy();
124. }
125. void SellFund()
126. {
127. gu1->Sell();
128. gu2->Sell();
129. gu3->Sell();
130. nd1->Sell();
131. rt1->Sell();
132. }
133. };
135. int main()
136. {
137. Fund * fund = new Fund();
139. fund->BuyFund();
140. fund->SellFund();
142. delete fund;
143. return 0;
144. }

何时使用外观模式:

1.在设计阶段初期，要有意识的将不同的两个层分离，比如经典的三层架构，就需要考虑在数据访问层和业务逻辑层、业务逻辑层和表示层的层与层之间建立外观Facade，这样可以为复杂的子系统提供一个简单的接口，使得耦合大大降低。

2.在开发阶段，子系统往往因为不断的重构演化而变得越来越复杂。增加外观Facade可以提供一个简单的接口，减少它们之间的依赖

3.在维护一个遗留的大型系统时，可能这个系统已经非常难以维护和扩展了，可以为新系统开发一个外观Facade类，来提供设计粗糙或高度复杂的遗留代码的比较清晰简单的接口，让新系统与Facade对象交互，Facade与遗留代码交互所有复杂的工作。