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

188 0 0

作者:realyrare

概述

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

需求

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

分析需求

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);

总结

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

内容来源于网络如有侵权请私信删除

文章来源: 博客园

原文链接: https://www.cnblogs.com/mhg215/p/17095941.html

标签： C# C#开发 C#语言

你还没有登录，请先登录或注册！

还没有人评论，欢迎说说您的想法！

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