外觀模式（10）

本篇博文，我們來說一下外觀模式。

一、案例

我們大家都買過股票嗎？即使沒有買過股票的，也大體知道炒股是什麼回事，說白了就是股票的買賣。

下麵我們用簡單的控制台應用程式來模擬一下股票買賣的場景。代碼如下：

 1     //股票1
 2     class Stock1
 3     {
 4         public void Sall()
 5         {
 6             Console.WriteLine("股票1賣出");
 7         }
 8 
 9         public void Buy()
10         {
11             Console.WriteLine("股票1買入");
12         }
13     }
14     //股票2
15     class Stock2
16     {
17         public void Sall()
18         {
19             Console.WriteLine("股票2賣出");
20         }
21 
22         public void Buy()
23         {
24             Console.WriteLine("股票2買入");
25         }
26 
27     }
28     //股票3
29     class Stock3
30     {
31         public void Sall()
32         {
33             Console.WriteLine("股票3賣出");
34         }
35 
36         public void Buy()
37         {
38             Console.WriteLine("股票3買入");
39         }
40     }
41     //國債1
42     class NationalDebt1
43     {
44         public void Sall()
45         {
46             Console.WriteLine("國債1賣出");
47         }
48 
49         public void Buy()
50         {
51             Console.WriteLine("國債1買入");
52         }
53     }
54     //房地產1
55     class Realty1
56     {
57         public void Sall()
58         {
59             Console.WriteLine("房地產1賣出");
60         }
61 
62         public void Buy()
63         {
64             Console.WriteLine("房地產1買入");
65         }
66     }

客戶端：

 1         public static void Main()
 2         {
 3             Stock1 gu1 = new Stock1();
 4             Stock2 gu2 = new Stock2();
 5             Stock3 gu3 = new Stock3();
 6             NationalDebt1 nd1 = new NationalDebt1();
 7             Realty1 rt1 = new Realty1();
 8 
 9             gu1.Buy();
10             gu2.Buy();
11             gu3.Buy();
12             nd1.Buy();
13             rt1.Buy();
14 
15             gu1.Sall();
16             gu2.Sall();
17             gu3.Sall();
18             nd1.Sall();
19             rt1.Sall();
20             Console.Read();
21         }

二、演繹

嗯，然而，對於不瞭解股票的朋友來說，面對這麼多支股票，他們也不知道改如何買賣這些股票，所以，他們通常會選擇購買基金，基金相對股票風險小一些。基金是什麼呢？（怎麼說呢，我比較笨一些，不知道怎麼解釋，大家可以百度一下 基金和股票的區別，哈哈）。

基金包含多只股票，好，下麵我們來改寫一下這個案例，我們現在不買賣股票了，我們現在來買賣基金。

好，我們新加一個基金類

 1     /// <summary>
 2     /// 基金類
 3     /// </summary>
 4     class Fund
 5     {
 6         private Stock1 gu1;
 7         private Stock2 gu2;
 8         private Stock3 gu3;
 9         private NationalDebt1 nd1;
10         private Realty1 rt1;
11 
12         public Fund()
13         {
14             gu1 = new Stock1();
15             gu2 = new Stock2();
16             gu3 = new Stock3();
17             nd1 = new NationalDebt1();
18             rt1 = new Realty1();
19         }
20 
21         public void BuyFund()
22         {
23             gu1.Buy();
24             gu2.Buy();
25             gu3.Buy();
26             nd1.Buy();
27             rt1.Buy();
28         }
29 
30         public void SellFund()
31         {
32             gu1.Sall();
33             gu2.Sall();
34             gu3.Sall();
35             nd1.Sall();
36             rt1.Sall();
37         }
38     }

那麼，客戶端這麼寫了：

 1         public static void Main()
 2         {
 3             //此時，用戶不需要瞭解股票，甚至可以對股票一無所知，買完基金回家睡覺，
 4             //過一段時間，再贖回就可以大把數錢玩了。
 5             Fund jijin = new Fund();
 6             //購買基金
 7             jijin.BuyFund();
 8             //基金贖回
 9             jijin.SellFund();
10             Console.Read();
11         }

以上這種寫法，就差不多是外觀模式的基本代碼了。好，下麵我們來正式給大家說一下什麼是外觀模式。

外觀模式：為子系統中的一組介面提供一個一致的界面，此模式定義了一個高級介面，這一介面使得子系統更加容易使用。

下麵我們來正式寫一下外觀模式的代碼：

 有很多的子系統：

 1     class SubSystemOne
 2     {
 3         public void MethodOne()
 4         {
 5             Console.WriteLine("子系統中的方法1");
 6         }
 7     }
 8 
 9     class SubSystemTwo
10     {
11         public void MethodTwo()
12         {
13             Console.WriteLine("子系統中的方法2");
14         }
15     }
16 
17     class SubSystemThree
18     {
19         public void MethodThree()
20         {
21             Console.WriteLine("子系統中的方法3");
22         }
23     }
24 
25     class SubSystemFour
26     {
27         public void MethodFour()
28         {
29             Console.WriteLine("子系統中的方法4");
30         }
31     }

有一個外觀類

 1     class Facade
 2     {
 3         private SubSystemOne one;
 4         private SubSystemTwo two;
 5         private SubSystemThree three;
 6         private SubSystemFour four;
 7 
 8         public Facade()
 9         {
10             one = new SubSystemOne();
11             two = new SubSystemTwo();
12             three = new SubSystemThree();
13             four = new SubSystemFour();
14         }
15 
16         public void MethodA()
17         {
18             Console.WriteLine("\n方法組A()--------");
19             one.MethodOne();
20             two.MethodTwo();
21             four.MethodFour();
22         }
23 
24         public void MethodB()
25         {
26             Console.WriteLine("\n方法組B()---------");
27             two.MethodTwo();
28             three.MethodThree();
29         }
30     }

客戶端調用：

1         public static void Main()
2         {
3             Facade facade = new Facade();
4             facade.MethodA();
5             facade.MethodB();
6             Console.ReadKey();
7         }

以上，便是外觀模式的代碼了。

外觀模式很好的體現了依賴倒轉原則和迪米特法則，所以，外觀模式是一種非常常用的設計模式。

ok，小伙伴們慢慢體會一下吧。今天就到這裡了。下篇博文，我們講解 建造者模式

本系列將持續更新，喜歡的小伙伴可以點一下關註和推薦，謝謝大家的支持。