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#面向对象编程中的里氏替换原则是什么”的学习就结束了，希望能够解决大家的疑惑。理论与实践的搭配能更好的帮助大家学习，快去试试吧！若想继续学习更多相关知识，请继续关注亿速云网站，小编会继续努力为大家带来更多实用的文章！