Read big talk design patterns --- Facade)

Appearance mode:

Provides a consistent interface for a group of interfaces in the subsystem. This mode defines a high-level interface, which makes it easier for a subsystem to use.

 

Visual mode structure

 

The general implementation of the appearance mode:

1. # Include <iostream>
2. Using namespace STD;
4. Class subsystemone
5. {
6. Public:
7. Void methodone ()
8. {
9. Cout <"Subsystem Method 1" <Endl;
10. }
11. };
12. Class subsystemtwo
13. {
14. Public:
15. Void methodtwo ()
16. {
17. Cout <"Subsystem Method 2" <Endl;
18. }
19. };
20. Class subsystemthree
21. {
22. Public:
23. Void methodthree ()
24. {
25. Cout <"Subsystem Method 3" <Endl;
26. }
27. };
28. Class subsystemfour
29. {
30. Public:
31. Void methodfour ()
32. {
33. Cout <"Subsystem Method 4" <Endl;
34. }
35. };
36. // Appearance class. It needs to understand the methods and attributes of all subsystems and combine them for external use.
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 method group A () ----" <Endl;
63. One-> methodone ();
64. Two-> methodtwo ();
65. Four-> methodfour ();
66. }
68. Void methodb ()
69. {
70. Cout <"/n method group B () ----" <Endl;
71. Two-> methodtwo ();
72. Three-> methodthree ();
73. }
74. };
76. // Because of the existence of facade, the client does not need to know the existence of the subsystem.
77. Int main ()
78. {
79. Facade * facade = new facade ();
80. Facade-> methoda ();
81. Facade-> methodb ();
82. Delete facade;
83. Return 0;
84. }

Specific implementation of the facade Mode

1. // Investment fund code
3. # Include <iostream>
4. Using namespace STD;
6. // Stock 1
7. Class stock1
8. {
9. // Sell stocks
10. Public:
11. Void Merge ()
12. {
13. Cout <"stock 1 sold" <Endl;
14. }
16. // Buy stock
17. Void buy ()
18. {
19. Cout <"stock 1 buy" <Endl;
20. }
21. };
23. // Stock 2
24. Class stock2
25. {
26. // Sell stocks
27. Public:
28. Void Merge ()
29. {
30. Cout <"stock 2 sold" <Endl;
31. }
33. // Buy stock
34. Void buy ()
35. {
36. Cout <"stock 2 buy" <Endl;
37. }
38. };
40. // Stock 3
41. Class stock3
42. {
43. // Sell stocks
44. Public:
45. Void Merge ()
46. {
47. Cout <"stock 3 sold" <Endl;
48. }
50. // Buy stock
51. Void buy ()
52. {
53. Cout <"stock 3 buy" <Endl;
54. }
55. };
57. // National debt 1
58. Class nationaldebt1
59. {
60. // Sell government bonds
61. Public:
62. Void Merge ()
63. {
64. Cout <" 1 sold" <Endl;
65. }
67. // Buy government bonds
68. Void buy ()
69. {
70. Cout <"National Debt 1 buy" <Endl;
71. }
72. };
74. // Real Estate 1
75. Class realty1
76. {
77. // Sell real estate
78. Public:
79. Void Merge ()
80. {
81. Cout <"property 1 sold" <Endl;
82. }
84. // Buy real estate
85. Void buy ()
86. {
87. Cout <"buy 1 Property" <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-> callback ();
128. Gu2-> callback ();
129. Gu3-> callback ();
130. Nd1-> encrypt ();
131. Rt1-> Reset ();
132. }
133. };
135. Int main ()
136. {
137. Fund * Fund = new fund ();
139. Fund-> buyfund ();
140. Fund-> sellfund ();
142. Delete fund;
143. Return 0;
144. }

When to use the appearance mode:

1. at the early stage of the design stage, we must consciously separate two different layers, such as the classic three-layer architecture, you need to consider establishing an external facade between the data access layer and the business logic layer, the business logic layer, and the presentation layer Layer. In this way, you can provide a simple interface for complicated subsystems, this greatly reduces coupling.

2. In the development stage, subsystems often become more and more complex due to continuous reconstruction and evolution. By adding a facade, you can provide a simple interface to reduce the dependency between them.

3. when maintaining a legacy large system, it may be very difficult to maintain and expand. You can develop a facade class for the new system, to provide clear and simple interfaces for the design of rough or highly complex legacy code, so that the new system can interact with the facade object, and the facade and legacy code can interact with all the complicated work.