面向对象设计原则三:里氏替换原则(LSP)

里氏替换原则(LSP)
定义:在任何父类出现的地方都可以用它的子类类替换,且不影响功能。
解释说明:
其实LSP是对开闭原则的一个扩展,在OO思想中,我们知道对象是由一系列的状态和行为组成的,里氏替换原则说的就是在一个继承体系中,对象应该具有共同的外在特性,使用LSP时,如果想让我们的程序达到一个父类出现的地方都可以用它的子类来替换且不影响功能,那么这个父类也应该尽量声明出子类所需要的一些公共的方法,父类被子类替换之后,会比较顺利,那么为什么说它是对开闭原则的一个扩展呢?因为我们在开闭原则中说尽量使用接口和抽象类,当然这个抽象类和接口也应该尽量定义得完整,这样我们这个接口和抽象类会比较稳定,这样既符合了开闭原则也满足了里氏替换原则。

错误案例1:

 1 using System;
 2 using System.Collections.Generic;
 3 using System.Linq;
 4 using System.Text;
 5 using System.Threading.Tasks;
 6
 7 namespace 里氏替换原则
 8 {
 9     /// <summary>
10     /// 鸟类
11     /// </summary>
12     public class Bird
13     {
14         /// <summary>
15         /// 吃的方法
16         /// </summary>
17         public void Eat()
18         { }
19
20         /// <summary>
21         /// 飞的方法
22         /// </summary>
23         public void Fly()
24         { }
25     }
26
27     /// <summary>
28     /// 定义一个企鹅类继承鸟类
29     /// </summary>
30     public class Penguin : Bird
31     {
32
33     }
34
35     public class Test
36     {
37         public static void ShowFly(Bird bird)
38         {
39             bird.Fly();
40         }
41
42         public static void Main()
43         {
44             ShowFly(new Penguin());
45         }
46     }
47 }

解释说明:

在上面的代码中,定义了一个鸟类,企鹅类继承自鸟类。鸟类里面有飞的方法,而企鹅不会飞,所以上面的代码违反了里氏替换原则。

错误案例2:

 1 using System;
 2 using System.Collections.Generic;
 3 using System.Linq;
 4 using System.Text;
 5 using System.Threading.Tasks;
 6
 7 namespace 里氏替换原则
 8 {
 9     /// <summary>
10     /// 定义一个父类宠物类
11     /// </summary>
12     public  class Pet
13     {
14     }
15
16     /// <summary>
17     /// 定义一个企鹅类继承自宠物类
18     /// </summary>
19     public class PenguinDemo : Pet
20     {
21         /// <summary>
22         /// 游泳的方法
23         /// </summary>
24         public void Swiming()
25         {
26             Console.WriteLine("可爱企鹅在游泳");
27         }
28     }
29
30     /// <summary>
31     /// 定义一个海豚类继承自宠物类
32     /// </summary>
33     public class Dolphin : Pet
34     {
35         /// <summary>
36         /// 玩游戏的方法
37         /// </summary>
38         public void PlayGame()
39         {
40             Console.WriteLine("神奇泡泡打砖块");
41         }
42     }
43
44     /// <summary>
45     /// 测试类
46     /// </summary>
47     public class Test
48     {
49         public static void ShowPlay(Pet pet)
50         {
51             if (pet is PenguinDemo)
52             {
53                 //类型转换
54                 PenguinDemo pen = (PenguinDemo)pet;
55                 pen.Swiming();
56             }
57             if (pet is Dolphin)
58             {
59                 //类型转换
60                 Dolphin dol = (Dolphin)pet;
61                 dol.PlayGame();
62             }
63         }
64     }
65 }

解释说明:
如果把河豚、企鹅当做宠物,我们可以定义一个宠物类,然后,让这些宠物继承这个类,我们知道每种宠物我们跟他玩耍的方式是不一样的。比如。企鹅有游泳的方法,河豚有游戏的方法,根据这个需求,我们设计一个系统,编写一个宠物类,让企鹅继承这个宠物类,在企鹅类里创建一个游泳的方法,这个方法不能放到宠物类里面,因为并不是所有宠物都会游泳。编写河豚类时,同样让他继承宠物类,在河豚类里面编写一个游戏的方法,这个时候客户端程序在使用宠物类和它的子类的时候,就需要做判断,具体是哪个子类,我们通过宠物类是无法调用具体的方法,要做一个判断和转型,如果在加一个狗类,狗类也会有一个独立的方法,要修改之前的代码(使用宠物类和它的子类的时候,要增加判断是狗类),这很明显不符合开闭原则,也不可能符合里氏替换原则,因为这里面的任何一个宠物都无法替换他的父类,因为他们的行为是不一样的,代码的可维护性和重用性很差!

时间: 08-11

面向对象设计原则三:里氏替换原则(LSP)的相关文章

设计原则之里氏替换原则

定义:所有引用基类的地方必须能透明地使用其子类的对象. 问题:有一功能P1,由类A来完成.现在需要将功能P1进行扩展,扩展后的功能为P(P由原有功能P1和新功能P2组成). 功能P由类A的子类B来完成,子类B在完成新功能P2的同时有可能会导致原有功能P1发生故障. 解决:当使用继承时,遵循里氏替换原则.类B继承类A时,除添加新的方法完成新增功能P2外,尽量不要重写父类A的方法, 也尽量不要重载父类A的方法. 举个栗子:士兵使用武器进行射击,包括武器的类别和特点的介绍. 情况一:士兵使用手枪进行射

六大原则之里氏替换原则

阐述一下: 肯定有不少人跟我刚看到这项原则的时候一样,对这个原则的名字充满疑惑.其实原因就是这项原则最早是在1988年,由麻省理工学院的一位姓里的女士(Barbara Liskov)提出来的. 定义1:如果对每一个类型为 T1的对象 o1,都有类型为 T2 的对象o2,使得以 T1定义的所有程序 P 在所有的对象 o1 都代换成 o2 时,程序 P 的行为没有发生变化,那么类型 T2 是类型 T1 的子类型. 定义2:所有引用基类的地方必须能透明地使用其子类的对象. 问题由来:有一功能P1,由类

设计模式六大原则之里氏替换原则

一.概念: 里氏替换原则:LSP (Liskov Substitution Principle),如果对每一个类型为T1的对象o1,都有类型为T2的对象o2,使得以T1定义的所有程序P在所有的对象o1都换成o2时,程序P的行为没有变化,那么类型T2是类型T1的子类型. 通俗的定义:所有引用基类的地方必须能透明地使用其子类的对象. 二.例子: 以浇水为例.人,拿到工具[水管.水桶.瓶子],装水后都可以浇水.[水管.桶.瓶子]都可以获取水.应该有个loadWater方法.有watering 浇水功能

设计模式原则之里氏替换原则

里氏替换原则,OCP作为OO的高层原则,主张使用“抽象(Abstraction)”和“多态(Polymorphism)”将设计中的静态结构改为动态结构,维持设计的封闭性.“抽象”是语言提供的功能.“多态”由继承语义实现. 定义1:如果对每一个类型为T1的对象 o1,都有类型为 T2 的对象o2,使得以 T1定义的所有程序 P 在所有的对象 o1 都代换成 o2 时,程序 P 的行为没有发生变化,那么类型 T2 是类型 T1 的子类型. 定义2:所有引用基类的地方必须能透明地使用其子类的对象. 如

[OOD]违反里氏替换原则的解决方案

关于OOD中的里氏替换原则,大家耳熟能祥了,不再展开,可以参考设计模式的六大设计原则之里氏替换原则.这里尝试讨论常常违反的两种形式和解决方案. 违反里氏替换原则的根源是对子类及父类关系不明确.我们在设计继承关系常常受一些主观认识的左右,比如Robert C. Martin提到的线段与线的关系,以及被大家说到烂的正方形与矩形.从以前的经验我们认为它们符合继承关系,比如线段是线的较短形式,正方形是矩形的一个特例.但事实上它们并不能完全的包容和替代. 以集合的形式表示,左图是里氏替换的目标,子类可以完

面向对象五大原则_1.单一职责原则&amp;amp;2.里氏替换原则

单一职责原则:Single Responsibility Principle (SRP) 一个类.仅仅有一个引起它变化的原因.应该仅仅有一个职责.每个职责都是变化的一个轴线.假设一个类有一个以上的职责,这些职责就耦合在了一起.这会导致脆弱的设计.当一个职责发生变化时,可能会影响其他的职责.另外,多个职责耦合在一起,会影响复用性. 比如:要实现逻辑和界面的分离. T负责两个不同的职责:职责P1.职责P2.当因为职责P1需求发生改变而须要改动类T时.有可能会导致原本执行正常的职责P2功能发生问题.

Java设计原则—里氏替换原则(转)

里氏替换原则(Liskov Substitution Principel)是解决继承带来的问题. 继承的优点: 代码共享,减少创建类的工作量,每个子类都拥有父类的方法和属性: 提高代码的重用性: 子类可以形似父类,但又异于父类: 提高代码的可扩展性: 提高产品或项目的开放性. 继承的缺点: 继承是侵入性的,只要继承就必须拥有父类的所有属性和方法: 降低代码的灵活性,子类必须拥有父类的属性和方法,让子类增加了约束: 增强了耦合性,当父类的常量.变量和方法被修改时,必须考虑子类的修改. 定义: 所有

里氏替换原则(Liskov Substitution Principle, LSP)

以此回顾所读<设计模式之禅>与<高校程序员的45个习惯>中Liskov部分 定义: 第一种:If for each object O1 of type S there is an object O2 fo type T such that for all programs P defined in terms of T, the behavior of P is unchanged when O1 is substitueted for O2 then S is a subtype

里氏替换原则(Liskov Substitution Principle) LSP

using System; using System.Collections.Generic; using System.Text; namespace LiskovSubstitutionPrinciple { //里氏替换原则(Liskov Substitution Principle) LSP //If for each object o1 of type S there is an object o2 of type T such that for all programs P defi