Liskov substitution principle (里氏替换原则)

最新推荐文章于 2025-01-09 23:54:27 发布
最新推荐文章于 2025-01-09 23:54:27 发布 · 205 阅读 · 0

本文介绍了面向对象编程中的一项核心原则——里氏替换原则。该原则由Barbara Liskov提出，强调子类型应当能够在不改变程序正确性的前提下替换其基类型。文章详细阐述了这一原则的具体定义及其在软件设计中的重要性。

In object-oriented programming, the Liskov substitution principle is a particular definition of subtype that was introduced by Barbara Liskov in a 1987 conference keynote address entitled Data abstraction and hierarchy.

Liskov formulated the principle succinctly in a subsequent paper as follows:

Let q(x) be a property provable about objects x of type T. Then q(y) should be true for objects y of type S where S is a subtype of T.

Thus, Liskov's notion of "subtype" defines the notion of substitutability; that is, if S is a subtype of T, then objects of type T in a program may be replaced with objects of type S without altering any of the desirable properties of that program (e.g., correctness).

http://en.wikipedia.org/wiki/Liskov_substitution_principle

gpgong
关注
六大设计原则之 里氏替换原则 （Liskov Substitution Principle | LSP）
心有猛虎 细嗅蔷薇
07-18 582
目录 前言 里氏替换原则 定义 场景 特点 优点 栗子 正例 特例1 特例2 前言 OO(Object Oriented 面向对象) 设计的六大原则：OCP（开闭原则），DIP（依赖倒置原则），ISP（接口隔离原则），LSP（里氏替换原则），SRP（单一职责原则），LKP（迪米特法则） 里氏替换原则 定义 面向对象的基本设计原则之一，里氏替换原则中说，任何基类可以出现...
里氏替换原则（Liskov Substitution Principle）
aijianxie8808的博客
06-18 336
开放封闭原则（Open Closed Principle）是构建可维护性和可重用性代码的基础。它强调设计良好的代码可以不通过修改而扩展，新的功能通过添加新的代码来实现，而不需要更改已有的可工作的代码。抽象（Abstraction）和多态（Polymorphism）是实现这一原则的主要机制，而继承（Inheritance）则是实现抽象和多态的主要方法。 那么是什么设计规则在保证对继承的使...
Liskov Substitution Principle
Closed
03-08 1637
Liskov Substitution Principle, 由Barbara Liskov 和 Jeannette Wing在93年提出，其原文为：“Let q(x) be a property provable about objects x of type T. Then q(y) should be true for objects y of type S where S is a sub
Liskov替换原则（Liskov Substitution Principle）
wang2leee的博客
08-29 412
Liskov替换原则是由计算机科学家Barbara Liskov在1987年提出的，她的名字也因此得名。这个原则是面向对象编程中的重要原则之一，属于SOLID设计原则的一部分。
Java设计模式之里氏替换原则(Liskov Substitution principle)
weixin_33709609的博客
02-05 504
2019独角兽企业重金招聘Python工程师标准>>> ...
Java七大设计原则 - 里氏替换原则 （Liskov Substitution Principle）
12-26 579
里氏代换原则(Liskov Substitution Principle LSP)面向对象设计的基本原则之一。里氏代换原则中说，任何基类可以出现的地方，子类一定可以出现。LSP是继承复用的基石，只有当衍生类可以替换掉基类，软件单位的功能不受到影响时，基类才能真正被复用，而衍生类也能够在基类的基础上增加新的行为。- 任何基类出现的地方、子类一定可以出现- 在程序中尽量使用基类的类型来 定义对象、在运行时确认子类子类，用子类对象替换父类对象实现“开-闭”原则的关键步骤就是抽象化。
SOLID原则学习，里氏替换原则（Liskov Substitution Principle, LSP）
汽车电子软件领域知识分享
01-09 1242
里氏替换原则的核心是确保子类可以完全替换父类而不影响程序的正确性。通过合理设计类的继承关系，避免子类修改父类的行为，可以提高代码的可维护性和可扩展性。在实际开发中，如果发现子类无法完全替换父类，可能需要重新审视类的设计，考虑使用组合或其他设计模式来解决问题。
源码分析七大设计原则之里氏替换原则（Liskov Substitution Principle）
用善良的眼光看世界
12-15 378
一、里氏替换原则（Liskov Substitution Principle） 定义：子类型必须能够替换掉它们的父类型。一个软件实体如果使用的是一个父类的话，那么一定适用于其子类，且它察觉不出父类对象和子类对象的区别。也就是说，子类对象可以随时随地的替换父类对象，并且替换完以后，语法不会报错，业务逻辑不会出现问题。 只有当子类可以替换掉父类，软件功能不受影响时，父类才能真正被复用，而子类也能够在父类的基础上增加新的行为，正是有里氏代换原则，使得继承复用成为了可能。也正是由于子类型的可替换性才使得使用父类类型
设计模式系列（二）设计模式原则——里氏替换原则(Liskov Substitution Principle)
Jackie的博客
11-05 216
里氏替换原则用于规范类的继承，防止类父类的修改过多影响到子类而提出的一种设计原则。 里氏替换原则在1988年，由麻省理工学院的Liskov女士提出的。 如果对每个类型为T1的对象o1，都有类型为T2的对象o2，使得以T1定义的所有程序 P在所有的对象o1都代换成o2时，程序P的行为没有发生变化，那么类型T2是类型T1 的子类型。所有引用基类的地方必须能透明地使用其子类的对象。 在使用继承时，遵循里氏替换原则，在子类中尽量不要重写父类的方法 里氏替换原则告诉我们，继承实际上
Liskov substitution principle （里氏替換原則）
Jeff_的博客
04-23 772
文章目录背景Tom's Penguin Problem 背景 可替代性是面向对象程序设计中的一项原则，其指出在计算机程序中，如果S是T的子类型，则类型T的对象可以用类型S的对象替换 （即类型T的对象可以用子类型S的任何对象替换 (i.e.向上转型)）而不更改程序的任何期望属性（正确性，任务执行等）。 更正式地讲，Liskov替换原理（LSP）是子类型关系的特定定义，称为（强）行为子类型化，最初是由...
Java-Liskov Substitution Principle
Nick_kn的博客
11-09 243
Liskov Substitution Principle It formally states that -the preconditions of a subclass’s behaviour (methods) cannot be strengthened, meaning (among other things) that a sub-method cannot accept a narrower range of inputs than the original method. -The post
Liskov替换原则（Liskov Substitution principle）
一朝风月
12-17 3193
子类型（subtype）必须能够替换掉他们的基类型（base type）如果一个类承担的职责过多，就等于把这些职责耦合在了一起。一个职责的变化可能会削弱或者抑制这个类完成其他职责的能力。这种耦合会导致脆弱的（fragile）设计。当一个职责发生变化时，可能会影响其它的职责。另外，多个职责耦合在一起，会影响复用性。例如：要实现逻辑和界面的分离。...
Liskov替换原则
阿常呓语的专栏
01-14 2047
Liskov替换原则 文章目录Liskov替换原则案例引入如何理解 子类型可以替换 基类型 ?违反LSP的危害总结参考文档 今天我继续来说 软件设计的另一个原则，LSP原则 里氏代换原则 英文缩写: LSP , 全称: Liskov Substitution Principle 来源 : 它由芭芭拉·利斯科夫（Barbara Liskov）在1987年在一次会议上名为“数据的抽象与层次”的演说中首先提出. 子类型(sub_type) 必须能够替换掉它们的基类型(base type) 若对每个类型
026--python--类的简单继承
weixin_45515187的博客
11-01 239
class Person(object): """人""" def __init__(self, name, age): self._name = name self._age = age @property def name(self): return self._name @property def age(self): return self._age @age.setter
浅谈Liskov Substitution Principle (LSP)
yangwh123的博客
07-05 380
1.定义：对于LSP有一种更加好理解的定义 Functions that use pointers or references to base classes must be able to useobjects of derived classes without knowing it. 即：所有引用基类的地方必须能透明地使用其子类的对象。只要有父类出现的地方，都可以用子类来替代，而且不会出现任何错误和异常。但是反过来则不行，有子类出现的地方，不能用其父类替代。 2.针对的问题：继承的缺..
里氏代换原则（Liskov Substitution Principle）
软件设计专栏
11-18 1841
作用 它指导我们如何正确地进行继承与派生，并合理地重用代码! 定义 子类型必须能够替换掉它们的父类型、并出现在父类能够出现的任何地方。 这个就是尽量用多态的方法编程，也就是GRASP模式中的多态。 如果对于每一个类型为T1的对象o1，都有类型为T2的对象o2，使得以T1定义的所有程序P在所有的对象o1都代换成o2时，程序P的行为没有变化，那么类型T2是类型T1的子类型。 换言之，一个软
Liskov Substitution Principle 里氏替换原则
ai_0922的博客
04-12 305
Liskov Substitution Principle 里氏替换原则 简介 定义：如果对每一个类型为T1的对象o1，都有类型为T2的对象o2，使得以T1定义的所有程序P在所有的对象o1都替换成o2时，程序P的行为没有发生变化，那么类型T2是类型T1的子类型， 定义扩展：一个软件实体如果使用一个父类的话，那一定适用于其子类，所有引用父类的地方必须能透明地使用其子类的对象，子类对象能够替代父类对象，而程序逻辑不变。 主要核心思想 强调只和朋友交流，不和陌生人说话 朋友：出现在成员变量、方法的输入、输出
如何理解Liskov substitution principle (LSP)？
最新发布
12-14
<think>我们正在讨论单一职责原则（SRP），但用户现在提出了关于里氏替换原则（LSP）的问题，并且提供了一些关于LSP的引用内容。我们需要根据用户提供的引用内容来回答如何理解里氏替换原则（LSP）。 用户提供的引用内容： 引用[1]：里氏替换原则是开闭原则的基础，它保证了在程序中使用基类的地方，可以透明地替换成子类而不影响程序的行为。这是理解运行时多态的关键。 引用[2]：给出了里氏替换原则的原始定义：如果对于类型S的每个对象o1，存在类型T的对象o2，使得在所有针对T编写的程序P中，用o1替换o2后，程序P的行为不变，那么S是T的子类型。并且强调，只有当子类可以替换父类而不影响程序功能时，父类才能被复用，子类也才能在父类基础上增加新行为。 引用[3]：扩展定义：一个软件实体如果使用父类，那么一定适用于其子类，所有引用父类的地方必须能透明地使用子类对象，子类对象能够替代父类对象，而程序逻辑不变。 引用[4]：具体规则：子类可以增加方法，但不能删除父类的方法；子类必须完全实现父类的方法；子类重写父类方法时，返回值类型必须是父类方法返回值的子类型（协变）或相同类型；子类重写父类方法时，参数类型必须相同（不能改变参数类型，否则是新方法）；子类重写方法只能抛出父类方法声明的异常或其子异常（协变），不能抛出额外异常。还提到协变与反协变（但Java不支持反协变）。 因此，我们需要根据这些引用来解释里氏替换原则。 理解里氏替换原则（LSP）的关键点： 1. 核心思想：子类必须能够替换它们的父类，而不会破坏程序。也就是说，在程序中，任何使用父类对象的地方，都可以用子类对象来替换，且程序的行为不会改变。 2. 目的：确保继承关系的正确使用，使得父类可以被安全地复用，而子类可以在不改变父类原有行为的前提下进行扩展。 3. 规则（从引用[4]中总结）： - 子类必须完全实现父类的方法（不能删除父类的方法）。 - 子类可以增加自己特有的方法。 - 子类重写父类方法时，参数类型必须与父类方法相同（否则就是重载，而不是重写）。 - 子类重写父类方法时，返回类型可以是父类方法返回类型的子类型（协变返回类型，Java支持）或者相同类型。 - 子类重写父类方法时，不能抛出比父类方法更多的异常，只能抛出父类方法声明的异常或其子类异常（协变异常）。 - 子类重写父类方法时，不能加强前置条件（即不能对输入条件要求更严格），也不能减弱后置条件（即不能对输出结果承诺更少）。 举例说明： 假设有一个父类`Rectangle`（矩形）和子类`Square`（正方形）。按照数学定义，正方形是矩形的一种，所以从概念上，我们可能会设计成继承关系。但是，如果父类矩形有`setWidth`和`setHeight`两个方法，而正方形要求宽高相等，那么子类正方形重写这两个方法时，可能会同时设置宽和高（比如设置宽时，高也改变；设置高时，宽也改变）。这样，当我们使用矩形类的地方传入一个正方形对象，并调用`setWidth`和`setHeight`时，程序的行为就改变了（因为设置宽会同时改变高），这就违反了LSP。 因此，这个例子说明，即使正方形在数学上是矩形，但在程序中这样的继承关系可能导致违反LSP。所以设计时要注意，子类不能改变父类的行为。 如何保证LSP？ 1. 设计时，尽量使用抽象（接口或抽象类）来定义基类，这样可以让子类有明确的契约。 2. 在子类中，避免重写父类的方法时改变其行为（除了实现抽象方法）。 3. 使用设计模式（如策略模式、组合模式）来代替继承，以避免违反LSP。 总结： LSP是面向对象设计的重要原则，它确保了继承关系的正确性。只有遵守LSP，才能保证开闭原则（对扩展开放，对修改关闭）的实现。因为开闭原则要求通过扩展（如子类）来增加新功能，而不修改现有代码，而LSP保证了这些扩展不会破坏原有系统。 相关问题： 1. 里氏替换原则与多态有什么关系？ 2. 违反里氏替换原则的常见例子有哪些？ 3. 里氏替换原则在接口设计中的应用？ 4. 如何测试一个子类是否遵守里氏替换原则？ 5. 里氏替换原则和组合/聚合复用原则有何关联？ 注：在回答中，我们会引用用户提供的引用标记[^1]、[^2]、[^3]、[^4]。 </think> ### 如何理解里氏替换原则（Liskov Substitution Principle, LSP） 里氏替换原则（LSP）是面向对象设计的**核心原则**之一，由Barbara Liskov于1987年提出。其核心思想可概括为： > **子类对象必须能够替换父类对象，且不破坏程序的正确性** > （即：任何父类出现的位置，子类都能无缝替换且程序行为不变） #### 核心定义解析 根据原始定义[^3]： > 若对每个类型$T_1$的对象$o_1$，存在类型$T_2$的对象$o_2$，使得所有针对$T_1$编写的程序$P$在将$o_1$替换为$o_2$时行为不变，则$T_2$是$T_1$的子类型。 简单来说：**父类能用的地方，子类必须能直接替换使用，且系统功能不受影响**。 #### 核心规则与要求 1. **行为一致性** 子类必须完全实现父类的方法契约（输入/输出/异常行为）： ```java // 父类 class Bird { void fly(int speed) throws FlyException { ... } } // 合法子类（协变） class Sparrow extends Bird { // ✅ 返回值类型协变（String ← Object） @Override String fly(int speed) { ... } } // 非法子类 class Ostrich extends Bird { // ❌ 删除方法（违反LSP） // ❌ 改变参数类型（int→float）相当于新方法 // ❌ 抛出额外异常（父类未声明WeatherException） @Override void fly(float speed) throws WeatherException { ... } } ``` 2. **前置条件不能强化** 子类方法对输入的要求不能比父类更严格： ```java class Account { // 父类前置条件：amount>0即可 void withdraw(int amount) { if (amount <= 0) throw new Exception(); } } class SavingsAccount extends Account { // ❌ 违反LSP：强化前置条件（额外要求amount≤1000） @Override void withdraw(int amount) { if (amount > 1000) throw new Exception(); // 破坏替换性 } } ``` 3. **后置条件不能弱化** 子类方法对结果的承诺不能比父类更弱： ```java class Database { // 父类承诺：始终返回非空连接 Connection getConnection() { ... } } class FaultyDatabase extends Database { // ❌ 违反LSP：可能返回null（弱化后置条件） @Override Connection getConnection() { return Math.random() > 0.5 ? null : super.getConnection(); } } ``` 4. **不变量必须保持** 子类必须维护父类定义的状态约束： ```java class Rectangle { protected int width, height; // 不变量：width > 0 && height > 0 } class Square extends Rectangle { void setSide(int side) { width = side; height = side; // ✅ 维持不变量 } // ❌ 违反LSP：单独设置宽会破坏正方形约束 @Override void setWidth(int w) { setSide(w); // 需要重写所有相关方法 } } ``` #### 设计意义与价值 1. **开闭原则的基石** LSP是实现"对扩展开放，对修改关闭"的关键[^1]。当子类可安全替换父类时，系统能通过扩展而非修改来增强功能。 2. **多态性的正确实现** 确保运行时多态不会导致意外行为（如`List<String> list = new ArrayList<>()`的安全使用）[^3]。 3. **降低系统耦合** 客户端代码只需依赖父类/接口，无需感知具体子类： ```java // 客户端代码仅依赖PaymentProcessor void processOrder(PaymentProcessor processor) { processor.charge(100); // 可安全替换PayPal或Stripe子类 } ``` 4. **提高可测试性** 允许用Mock子类替换真实对象进行单元测试。 #### 典型违反场景与修复 **问题场景**：正方形(Square)继承矩形(Rectangle) ```java Rectangle rect = new Square(); rect.setWidth(5); rect.setHeight(4); // 意外将宽高都设为4，破坏矩形预期 ``` **修复方案**： - 方案1：放弃继承，使用组合 ```java class Square { private Rectangle rect; void setSide(int s) { rect = new Rectangle(s, s); } } ``` - 方案2：通过父类抽象约束 ```java abstract class Shape { abstract int getArea(); } ``` #### 与开闭原则的关系 LSP是开闭原则的**实现保障**： $$ \text{开闭原则} \implies \text{依赖抽象} \xrightarrow{\text{LSP保证}} \text{安全扩展} $$ 通过LSP确保子类扩展不破坏父类契约，才能真正实现"扩展开放，修改关闭"。 ---
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值