必知必会的设计原则——开放封闭原则

概述

开放封闭原则是面向对象所有原则的核心。
对功能扩展开放，面向修改代码封闭。
需求改变时，在小改变软件实体源代码（类、接口、方法等）的前提下通过扩展功能使其满足新的需求。
需求

描述不同需求的用户去银行办理不同的业务
分析需求

1、在这段程序中 会有多少个对象
2、每个对象的属性和行为
对象1： 用户：属性记录不同类型的用户（存钱、取钱、转账....）
对象2： 银行专员：帮助我们用户处理不同的需求
对象3： 银行业务系统：处理存钱、取钱、转账等需求的操作系统
未使用开放封闭原则的代码

1. public class BankClient
2. {
3.     public string?  BankType { get; set; }
4. }
5. public class BankStuff
6. {
7.     private BankProcess bankProcess =new BankProcess();
8.     public void HandleProcess(BankClient bankClient)
9.     {
10.       
11.         //调用银行的业务系统，处理我们用户的需求；
12.         switch (bankClient.BankType)
13.         {
14.             case "存款":
15.                 bankProcess.Deposite();
16.                 break;
17.             case "取款":
18.                 bankProcess.DrowMoney();
19.                 break;
20.             case "转账":
21.                 bankProcess.Transfer();
22.                 break;
23.             case "购买基金":
24.                 bankProcess.BuyJiJin();
25.                 break;
26.             default:
27.                 break;
28.         }
29.     }
30. }
31. public class BankProcess
32. {
33.   public void Deposite()
34.     {
35.         Console.WriteLine("处理用户的存款");
36.     }
37.     public void DrowMoney()
38.     {
39.         Console.WriteLine("处理用户的取款");
40.     }
41.     public void Transfer()
42.     {
43.         Console.WriteLine("处理用户的转账");
44.     }
45.     public void BuyJiJin()
46.     {
47.         Console.WriteLine("处理用户的购买基金");
48.     }<br>

复制代码

1. //C#控制台调用
2. BankClient bankClient = new BankClient();
3. bankClient.BankType = "存款";
4. BankStuff bankStuff=new BankStuff();
5. bankStuff.HandleProcess(bankClient);
7. BankClient bankClient2 = new BankClient();
8. bankClient2.BankType = "取款";
9. BankStuff bankStuff2 = new BankStuff();
10. bankStuff2.HandleProcess(bankClient2);

复制代码

结论：  虽然满足需求，不符合开放封闭原则。增加功能需要对内修改。
使用开放封闭原则的代码

抽取接口，面向抽象/接口编程(类的每一个方法都抽象成接口都比较极端，需根据业务进行合理的封装)。

1. /*符合单一职责，开闭原则 */
2.     public interface IBankProcess
3.     {
4.         void Process();
5.     }
6.     public class Deposite : IBankProcess
7.     {
8.         public void Process()
9.         {
10.             Console.WriteLine("存款");
11.         }
12.     }
13.     public class DrowMoney : IBankProcess
14.     {
15.         public void Process()
16.         {
17.             Console.WriteLine("取款");
18.         }
19.       
20.     }
21.     public class BuyJiJin : IBankProcess
22.     {
23.         public void Process()
24.         {
25.             Console.WriteLine("购买基金");
26.         }
27.     }
28.     public class Transfer : IBankProcess
29.     {
30.         public void Process()
31.         {
32.             Console.WriteLine("转账");
33.         }
34.     }
37.     public class BankStuff3
38.     {
39.         private IBankProcess _bankProcess ;
40.         public void HandleProcess(BankClient bankClient)
41.         {
43.             //调用银行的业务系统，处理我们用户的需求；
44.             switch (bankClient.BankType)
45.             {
46.                 case "存款":
47.                     _bankProcess=new Deposite();
48.                     _bankProcess.Process();
49.                     break;
50.                 case "取款":
51.                     _bankProcess = new DrowMoney();
52.                     _bankProcess.Process();
53.                     break;
54.                 case "转账":
55.                     _bankProcess = new Transfer();
56.                     _bankProcess.Process();
57.                     break;
58.                 case "购买基金":
59.                     _bankProcess = new BuyJiJin();
60.                     _bankProcess.Process();
61.                     break;
62.                 default:
63.                     Console.WriteLine("没有办法处理您的业务");
64.                     break;
65.             }
66.         }
67.     }<br>

复制代码

1. //C#控制台调用
2. BankClient bankClient3 = new BankClient();
3. bankClient3.BankType = "取款";
4. BankStuff3 bankStuff3 = new BankStuff3();
5. bankStuff3.HandleProcess(bankClient3);

复制代码

结论：符合单一职责，开闭原则 。但是switch并没有解决。
解决stitch case后的代码

解决switch case问题 封装不是目的，只有 封装变化 才能做到单一职责 ，开放封闭等原则。

1. 　　/// <summary>
2.     /// 解决switch  case问题
3.     /// </summary>
4.     public interface IBankClient
5.     {
6.         IBankProcess GetBankClient();
7.     }
8.     public class DepositeClient : IBankClient
9.     {
10.         public IBankProcess GetBankClient()
11.         {
12.             return new Deposite();
13.         }
14.     }
15.     public class DrowMoneyClient : IBankClient
16.     {
17.         public IBankProcess GetBankClient()
18.         {
19.             return new DrowMoney();
20.         }
21.     }
22.     public class BuyJiJinClient : IBankClient
23.     {
24.         public IBankProcess GetBankClient()
25.         {
26.             return new BuyJiJin();
27.         }
28.     }
29.     public class TransferClient : IBankClient
30.     {
31.         public IBankProcess GetBankClient()
32.         {
33.             return new Transfer();
34.         }
35.     }
36.     public class BankStuff4
37.     {
38.         private IBankProcess _bankProcess;
39.         public void HandleProcess(IBankClient bankClient)
40.         {
41.             //调用银行的业务系统，处理我们用户的需求；
42.             _bankProcess = bankClient.GetBankClient();
43.             _bankProcess.Process();
44.         }
45.     }

复制代码

1. //C#控制台调用
2. IBankClient bankClient4=new BuyJiJinClient(); //变化点  需要特别注意  //DepositeClient
3. new BankStuff4().HandleProcess(bankClient4);

复制代码

总结

关于开放封闭原则，通过分析不同需求的用户去银行办理不同的业务来进行了三版实现，不知道大家写的代码是其中的哪一种呢？有何疑问，欢迎交流！
 

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！

继续阅读请点击广告