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

 设计原则系列文章 

1. 必知必会的设计原则——单一职责原则
2. 必知必会的设计原则——开放封闭原则
3. 必知必会的设计原则——依赖倒置原则
4. 必知必会的设计原则——里氏替换原则
5. 必知必会的设计原则——接口隔离原则
6. 必知必会的设计原则——迪米特原则
7. 必知必会的设计原则——合成复用原则

概述

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

需求

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

分析需求

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

未使用开放封闭原则的代码

public class BankClient
{
    public string?  BankType { get; set; }
}
public class BankStuff
{
    private BankProcess bankProcess =new BankProcess();
    public void HandleProcess(BankClient bankClient)
    {
       
        //调用银行的业务系统，处理我们用户的需求；
        switch (bankClient.BankType)
        {
            case "存款":
                bankProcess.Deposite();
                break;
            case "取款":
                bankProcess.DrowMoney();
                break;
            case "转账":
                bankProcess.Transfer();
                break;
            case "购买基金":
                bankProcess.BuyJiJin();
                break;
            default:
                break;
        }
    }
}
public class BankProcess
{ 
  public void Deposite()
    {
        Console.WriteLine("处理用户的存款");
    }
    public void DrowMoney()
    {
        Console.WriteLine("处理用户的取款");
    }
    public void Transfer()
    {
        Console.WriteLine("处理用户的转账");
    }
    public void BuyJiJin()
    {
        Console.WriteLine("处理用户的购买基金");
    }

//C#控制台调用
BankClient bankClient = new BankClient();
bankClient.BankType = "存款";
BankStuff bankStuff=new BankStuff();
bankStuff.HandleProcess(bankClient);

BankClient bankClient2 = new BankClient();
bankClient2.BankType = "取款";
BankStuff bankStuff2 = new BankStuff();
bankStuff2.HandleProcess(bankClient2);

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

使用开放封闭原则的代码

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

/*符合单一职责，开闭原则 */
    public interface IBankProcess
    {
        void Process();
    }
    public class Deposite : IBankProcess
    {
        public void Process()
        {
            Console.WriteLine("存款");
        }
    }
    public class DrowMoney : IBankProcess
    {
        public void Process()
        {
            Console.WriteLine("取款");
        }
       
    }
    public class BuyJiJin : IBankProcess
    {
        public void Process()
        {
            Console.WriteLine("购买基金");
        }
    }
    public class Transfer : IBankProcess
    {
        public void Process()
        {
            Console.WriteLine("转账");
        }
    }


    public class BankStuff3
    {
        private IBankProcess _bankProcess ;
        public void HandleProcess(BankClient bankClient)
        {

            //调用银行的业务系统，处理我们用户的需求；
            switch (bankClient.BankType)
            {
                case "存款":
                    _bankProcess=new Deposite();
                    _bankProcess.Process();
                    break;
                case "取款":
                    _bankProcess = new DrowMoney();
                    _bankProcess.Process();
                    break;
                case "转账":
                    _bankProcess = new Transfer();
                    _bankProcess.Process();
                    break;
                case "购买基金":
                    _bankProcess = new BuyJiJin();
                    _bankProcess.Process();
                    break;
                default:
                    Console.WriteLine("没有办法处理您的业务");
                    break;
            }
        }
    }

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

结论：符合单一职责，开闭原则 。但是switch并没有解决。

解决stitch case后的代码

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

 　　/// <summary>
    /// 解决switch  case问题
    /// </summary>
    public interface IBankClient
    {
        IBankProcess GetBankClient();
    }
    public class DepositeClient : IBankClient
    {
        public IBankProcess GetBankClient()
        {
            return new Deposite();
        }
    }
    public class DrowMoneyClient : IBankClient
    {
        public IBankProcess GetBankClient()
        {
            return new DrowMoney();
        }
    }
    public class BuyJiJinClient : IBankClient
    {
        public IBankProcess GetBankClient()
        {
            return new BuyJiJin();
        }
    }
    public class TransferClient : IBankClient
    {
        public IBankProcess GetBankClient()
        {
            return new Transfer();
        }
    }
    public class BankStuff4
    {
        private IBankProcess _bankProcess;
        public void HandleProcess(IBankClient bankClient)
        {
            //调用银行的业务系统，处理我们用户的需求；
            _bankProcess = bankClient.GetBankClient();
            _bankProcess.Process();
        }
    }

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

总结

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