C#面向对象编程中的里氏替换原则是什么

这篇文章主要介绍“C#面向对象编程中的里氏替换原则是什么”,在日常操作中,相信很多人在C#面向对象编程中的里氏替换原则是什么问题上存在疑惑,小编查阅了各式资料,整理出简单好用的操作方法,希望对大家解答”C#面向对象编程中

这篇文章主要介绍“C#面向对象编程中的里氏替换原则是什么”,在日常操作中,相信很多人在C#面向对象编程中的里氏替换原则是什么问题上存在疑惑,小编查阅了各式资料,整理出简单好用的操作方法,希望对大家解答”C#面向对象编程中的里氏替换原则是什么”的疑惑有所帮助!接下来,请跟着小编一起来学习吧!

    在面向对象编程中,SOLID 是五个设计原则的首字母缩写,旨在使软件设计更易于理解、灵活和可维护。这些原则是由美国软件工程师和讲师罗伯特·C·马丁(Robert Cecil Martin)提出的许多原则的子集,在他2000年的论文《设计原则与设计模式》中首次提出。

    SOLID 原则包含:

    • S:单一功能原则(single-responsibility principle)

    • O:开闭原则(open-closed principle)

    • L:里氏替换原则(Liskov substitution principle)

    • I:接口隔离原则(Interface segregation principle)

    • D:依赖反转原则(Dependency inversion principle)

    里氏替换原则

    在面向对象的程序设计中,里氏替换原则(Liskov Substitution principle)是对子类型的特别定义。它由芭芭拉·利斯科夫(Barbara Liskov)在1987年的一次会议上,在名为“数据的抽象与层次”的演说中首次提出。

    里氏替换原则的内容可以描述为:派生类(子类)对象可以在程序中代替其基类(超类)对象。

    也就是说,程序中的对象不管出现在什么地方,都应该可以使用其派生类(子类)的对象进行替换,而不影响程序运行的正确性。

    C# 示例

    我们看这样一个示例,假设一个企业有三种员工,一种是拿铁饭碗的永久雇员,一种是合同工,一种是临时工。我们设计几个类来表示这三种员工。

    糟糕的示范

    先定义一个 Employee 基类。

    public abstract class Employee
    {
        public string Name { get; set; }
        /// <summary>
        /// 计算奖金
        /// </summary>
        /// <returns></returns>
        public abstract decimal CalculateBonus();
    }

    再定义该基类的三个子类:

    /// <summary>
    /// 永久雇员
    /// </summary>
    public class PermanentEmployee : Employee
    {
        public override decimal CalculateBonus()
        {
            return 80000;
        }
    }
    
    /// <summary>
    /// 合同工
    /// </summary>
    public class ContractEmployee : Employee
    {
        public override decimal CalculateBonus()
        {
            return 2000;
        }
    }
    
    /// <summary>
    /// 临时工(临时工没有奖金)
    /// </summary>
    public class TemporaryEmployee : Employee
    {
        public override decimal CalculateBonus()
        {
            throw new NotImplementedException(); //违反里氏替换原则
        }
    }

    接下来在 Main 方法中调用它们。

    先定义一个类型为基类 Employee 的变量 e,再分别使用其子类 PermanentEmployee、ContractEmployee 和 TemporaryEmployee 创建对象赋值给基类变量 e,然后调用 e 的 CalculateBonus() 方法。

    static void Main(string[] args)
    {
        Employee e;
    
        e = new PermanentEmployee() { Name = "张三" };
        Console.WriteLine($"{e.Name} 的年终奖是 {e.CalculateBonus()} 元");
    
        e = new ContractEmployee() { Name = "李四" };
        Console.WriteLine($"{e.Name} 的年终奖是 {e.CalculateBonus()} 元");
    
        e = new TemporaryEmployee() { Name = "王五" };
        Console.WriteLine($"{e.Name} 的年终奖是 {e.CalculateBonus()} 元");
    }

    运行一下可以观察到(显而易见的),当使用 PermanentEmployee 和 ContractEmployee 类创建的对象替换基类型 Employee 的变量 e 时,调用 CalculateBonus() 方法可以正常运行,但是使用 TemporaryEmployee 类创建的对象替换变量 e 时,调用 CalculateBonus() 方法抛出了异常,导致程序无法正常运行。这就明显违反了里氏替换原则。

    那么,应该如何改进一下呢?

    正确的示范

    我们看到,每种员工都有基本信息 Name 属性,但是由于临时工 TemporaryEmployee 没有奖金,所以不需要计算奖金。因此我们应该把计算奖金的方法 CalculateBonus 单独抽象出去,而不是让它们都继承于同一个基类,并将 TemporaryEmployee 子类中的 CalculateBonus 方法抛出一个异常。

    改进后的代码:

    interface IEmployee
    {
        /// <summary>
        /// 计算年终奖
        /// </summary>
        /// <returns></returns>
        public decimal CalculateBonus();
    }
    
    public abstract class Employee
    {
        public string Name { get; set; }
    }
    
    /// <summary>
    /// 永久雇员
    /// </summary>
    public class PermanentEmployee : Employee, IEmployee
    {
        public decimal CalculateBonus()
        {
            return 80000;
        }
    }
    
    /// <summary>
    /// 合同工
    /// </summary>
    public class ContractEmployee : Employee, IEmployee
    {
        public decimal CalculateBonus()
        {
            return 2000;
        }
    }
    
    /// <summary>
    /// 临时工
    /// </summary>
    public class TemporaryEmployee : Employee
    {
    }

    在 Main 方法中,将调用它们的测试代码改为:

    static void Main(string[] args)
    {
        Employee e;
        IEmployee ie;
    
        var p = new PermanentEmployee() { Name = "张三" };
        e = p;
        ie = p;
        Console.WriteLine($"{e.Name} 的年终奖是 {ie.CalculateBonus()} 元");
    
        var c = new ContractEmployee() { Name = "李四" };
        e = c;
        ie = c;
        Console.WriteLine($"{e.Name} 的年终奖是 {ie.CalculateBonus()} 元");
    
        e = new TemporaryEmployee() { Name = "王五" };
        Console.WriteLine($"{e.Name} 是临时工,无年终奖。");
    }

    程序运行正常。

    这样,这些子类的设计便遵循了里氏替换原则。

    到此,关于“C#面向对象编程中的里氏替换原则是什么”的学习就结束了,希望能够解决大家的疑惑。理论与实践的搭配能更好的帮助大家学习,快去试试吧!若想继续学习更多相关知识,请继续关注恰卡网网站,小编会继续努力为大家带来更多实用的文章!

    本站部分文章来自网络或用户投稿,如无特殊说明或标注,均为本站原创发布。涉及资源下载的,本站旨在共享仅供大家学习与参考,如您想商用请获取官网版权,如若本站内容侵犯了原著者的合法权益,可联系我们进行处理。
    后端

    C#面向对象编程中的接口隔离原则是什么

    2022-7-16 9:03:52

    后端

    python怎么使用seaborn绘制直方图,密度图,散点图

    2022-7-16 9:03:54

    搜索