Liskov替换原则

最新推荐文章于 2024-09-26 10:54:32 发布

阿常呓语

最新推荐文章于 2024-09-26 10:54:32 发布

阅读量1.8k

点赞数 3

分类专栏：设计原则文章标签： python 设计模式设计原则

本文链接：https://blog.csdn.net/u010339879/article/details/122499075

版权

设计原则专栏收录该内容

5 篇文章 0 订阅

订阅专栏

Liskov替换原则

文章目录

Liskov替换原则

今天我继续来说软件设计的另一个原则， LSP原则

里氏代换原则英文缩写: LSP , 全称: Liskov Substitution Principle

来源 : 它由芭芭拉·利斯科夫（Barbara Liskov）在1987年在一次会议上名为“数据的抽象与层次”的演说中首先提出.

子类型(sub_type) 必须能够替换掉它们的基类型(base type)

若对每个类型S 的对象 o₁, 都存在一个类型T的对象o₂, 使得在所有针对T编写的程序P中, 用o₁替换o₂后,程序P行为功能不变, 则S是T的子类型 .
子类型(sub_type ) 必须能够替换掉它们的基类型(base type)

这个原则看起来理所当然, 子类继承于父类, 自然包含父类的所有的公开的方法与属性. 父类可以使用的地方,子类也当然可以使用了. 看起来非常合理. 然而，在我们实际编程的过程中, 就有可能违反这个原则.

案例引入

来看下面的一个小例子

有一个类Animal 派生出子类 Bird ,Dog 这些子类. Animal 有一个 bark 叫的方法. 但是子类Bird 也想有自己的bark的方法. 就是不同的子类的bark 方法不太一样,于是就有了下面的代码.


class Animal:
    def __init__(self, name):
        self.name = name

    def bark(self):
        print('animal bark')
        return 'animal bark'


class Bird(Animal):
    def __init__(self, name):
        super(Bird, self).__init__(name)

    def bark(self):
        print('Bird ji ji ji')
        return 'Bird ji ji ji'


class Dog(Animal):
    def __init__(self, name):
        super(Dog, self).__init__(name)

    pass

    def bark(self):
        print('Dog wang wang wang')
        return 'Dog wang wang wang'



if __name__ == '__main__':
    animal = Animal('animal')
    dog = Dog('dog')
    bird = Bird('bird')
    animal.bark()
    dog.bark()
    bird.bark()

继承关系图如下:
请添加图片描述

继承的含义就是子类中拥有一个父类的所有的公开的属性,方法. 如下图:

请添加图片描述

每个子类中都有自己的bark 方法,即每个子类重写的了父类Animal 的方法. 下面来运行这段代码

结果如下:

在这里插入图片描述

下面我们来思考一下这个问题, 现在有一个函数bark, 如下:


def bark(animal: Animal):
    """
    对于 bark 方法来说 应该有理由相信  animal 叫的方法 返回 animal bark

    :param animal:
    :return:
    """
    assert animal.bark() == 'animal bark'

对于编写 bark函数的人来说, 只要是 Animal 对象,就应该有我这样的断言应该没有任何问题的.

想想刚刚说的 LSP 原则突然有一天, 我把Animal 的子类传入的bark 函数中

if __name__ == '__main__':
    animal = Animal('animal')
    dog = Dog('dog')
    bird = Dog('bird')
    bark(animal)
    bark(dog)

发现当传入dog 的时候代码就报错了.

在这里插入图片描述

LSP 原则要求: 子类必须能够替换掉它们的基类 . 这里我传入了子类发现代码就崩溃了.

所以这样的代码编码就是有问题的,或者不是那么好的代码. 因为这里子类并不能替换父类的角色. 父类可以正常运行的程序, 放入子类后,代码就崩溃了. 这就是说子类的行为和父类的行为有不一样的结果. 才导致的代码崩溃.

再来看一下 LSP 原则

所有引用基类（父类）的地方必须能透明地使用其子类的对象。通俗的说，子类可以扩展父类功能，但不能改变父类原有功能。

如何理解子类型可以替换基类型 ?

要求使用基类的程序P中, 把程序P中的所有基类换成派生的子类对象, 代码运行的结果应该保持一样,不应该有任何的差异.

在我们理解继承的关系的时候, 有时候用 is-a 来辨别是否用于继承. 比如: 人是动物, 狗狗是动物 , 因此写代码的时候我们就好使用继承这种关系. 大部分情况下这种方法是没有问题的. 好像也很符合逻辑的. 但是有的时候并不是这样的. 比如说长方形与正方形的关系 , 正方形是长方形吗? 逻辑上来说可以算是正方形就是一种特殊的长方形.



class Rectangle:
    """
    长方形
    """

    def __init__(self, width=0, height=0):
        self.width = width
        self.height = height

    def set_width(self, width):
        self.width = width
        pass

    def set_height(self, height):
        self.height = height
        pass

    def area(self):
        return self.width * self.height


class Square(Rectangle):
    """
    正方形
    """

    def set_width(self, width):
        super(Square, self).set_width(width)
        super(Square, self).set_height(width)
        pass

    def set_height(self, height):
        super(Square, self).set_width(height)
        super(Square, self).set_height(height)
        pass

类图关系如下：

在这里插入图片描述

现在有一个编写 g 函数的小伙子 ,写了如下代码:


def g(r: Rectangle):
    """
    """
    r.set_height(5)
    r.set_width(4)
    assert r.area() == 20, "assert error"

在g 的编写小伙子认为, 长方形就可以分别设置长和宽, 并且通过设置长和宽, 最后可以计算出面积.

我们开始跑这个 g函数, 发现当传入正放心的对象就报错了. 结果不是20 了? 为什么呢?

if __name__ == '__main__':
    r = Rectangle()
    sqare = Square()

    g(r)
    g(sqare)

在编写g函数的小伙子, 如果传递Rectangle 的对象,就可以分别设置长与宽 , 然后计算面积, 此函数运行是没有问题的. 但是如果此时传入 Square 对象就会断言错误. 所以问题就在于编写g 函数的小伙子认为长与宽是两个相互独立的变量, 两者不会相互有关联,有影响.

很显然改变一个长方形的长 ,宽度可以不受影响. 这个假设是合理的. 若是传入Square对象, 这个时候设置长的时候宽度也被设置了. 两者是有关联的. 这就是问题, 也就是程序失败的原因.

你可能会对g 函数 asertion 进行争辩, g 函数应该不能假设长与宽是独立变化的. 编写 g 函数的小伙子是不会同意这种说法的. 函数g 以 Rectangle为参数.并且确实有一些不变的性质的原理说明明显适用于 Rectangle 类 . 其中一个不变的性质就是 width 与 height 是独立变化,相互不应该影响. 所以小伙子完全可以使用断言认为面积就是长乘以宽 . 而恰好的是, Square 类违反了这种不变性 , 所以才导致了assertion 失败.

所以在LSP 原则下这种设计是有问题的. 那我们有什么办法解决这个问题呢?

我们可以让这两个类继承一个共同的类就好了.

# -*- coding: utf-8 -*-

class Quadrangle:
    """
    四边形
    """

    def __init__(self, width=0, height=0):
        self.width = width
        self.height = height

    def set_width(self, width):
        self.width = width

    def set_height(self, height):
        self.height = height

    def area(self):
        return self.width * self.height


class Rectangle(Quadrangle):
    """
    长方形
    """


class Square(Quadrangle):
    """
    正方形
    """

    def __init__(self, side=0):
        super(Square, self).__init__(side, side)
        # 拓展子类
        self.side = side

    def set_side(self, side):
        """
        添加 方法
        :param side: 边长
        :return:
        """
        self.side = side

    def my_area(self):
        """
        use my_area 的方法来计算 面积
        :return:
        """
        return self.side * self.side


def g1(q: Quadrangle):
    """
    """
    q.set_height(5)
    q.set_width(4)
    assert q.area() == 20, "assert error "


if __name__ == '__main__':
    r = Rectangle()
    sqare = Square()
    g1(r)
    g1(sqare)
    pass