设计原则之里氏替换原则

本文是极客时间里王争专栏《设计模式之美》的学习笔记，你可以通过链接阅读原文获取更加详尽的描述，也可以通过该链接进行订阅和购买获取优惠。

里氏替换原则（LSP）

今天来看看SOLID 中的L, 里氏替换原则。

如何理解“里式替换原则”？

里式替换原则（Liskov Substitution Principle），缩写为 LSP。最早是在 1986 年由 Barbara Liskov 提出。里氏替换原则的定义：

子类对象（object of subtype/derived class）能够替换程序（program）中父类对象（object of base/parent class）出现的任何地方，并且保证原来程序的逻辑行为（behavior）不变及正确性不被破坏。

举个例子来解释。如下代码，父类UserManager通过接口getUserInfo()来获取存储在本地的用户信息，子类SecurityUserManager增加了额外功能，将用户信息中的加密字段解密完成后，再返回给上层业务。

public class UserManager {
    /// 获取本地用户信息，如果获取出现错误，则返回`nil`，获取的值为空，则返回`[:]`
    public func getUserInfo() -> [String: Any]? {
        // 获取本地用户信息
        // ...
        print(#function)
        return nil
    }
}

public class SecurityUserManager: UserManager {
    private var decryptionKey: String
    init(decryptionKey: String) {
        self.decryptionKey = decryptionKey
    }
    public override func getUserInfo() -> [String: Any]? {
        if decryptionKey.isEmpty {
            return nil
        }
        print("SecurityUserManager: \(#function)")
        if var result = super.getUserInfo() {
            // 解密result中的加密字段，并将解密结果放入result中
            return result
        }
        return nil
    }
}

class XXViewModel {
    func getUserInfo(_ manager: UserManager) {
        _ = manager.getUserInfo()
    }
}

class XXViewController {
    let demo = XXViewModel()
    // 里氏替换原则
        demo.getUserInfo(SecurityUserManager(decryptionKey: "kkk"))
}

在上面的代码中，子类SecurityUserManager的设计完全符合里氏替换原则，可以替换父类出现的任何位置，并且原来代码的逻辑行为不变且正确性也没有被破坏。

不过，你可能会有这样的疑问，刚刚的代码设计不就是简单利用了面向对象的多态特性吗？多态和里式替换原则说的是不是一回事呢？里式替换原则跟多态看起来确实有点类似，但实际上它们完全是两回事。为什么这么说呢？

现在对上面SecurityUserManager中的接口getUserInfo()改造一下。改造前：获取本地用户信息，如果获取出现错误，则返回nil，获取的值为空，则返回[:]；改造后：获取本地用户信息，出现错误或者获取的值为空，都返回[:]

// 改造前：
public class SecurityUserManager: UserManager {
        // ...省略其他代码...
    public override func getUserInfo() -> [String: Any]? {
        if decryptionKey.isEmpty {
            return nil
        }
        print("SecurityUserManager: \(#function)")
        if var result = super.getUserInfo() {
            // 解密result中的加密字段，并将解密结果放入result中
            return result
        }
        return nil
    }
}

// 改造后：
public class SecurityUserManager: UserManager {
    // ...省略其他代码...
    public override func getUserInfo() -> [String: Any] {
        if decryptionKey.isEmpty {
            return [:]
        }
        print("SecurityUserManager: \(#function)")
        if var result = super.getUserInfo() {
            // 解密result中的加密字段，并将解密结果放入result中
            return result
        }
        return [:]
    }
}

在改造后的代码中，如果传递给XXViewModel.getUserInfo(:)函数的是SecurityUserManager对象，业务层获取到的数据含义发生改变，整个程序的逻辑行为有了改变。

虽然改造之后的代码仍然可以通过多态语法，动态地用子类SecurityUserManager来替换父类 UserManager，也并不会导致程序编译或者运行报错。但是，从设计思路上来讲，SecurityUserManager 的设计是不符合里式替换原则的。

总结：虽然从定义描述和代码实现上来看，多态和里式替换有点类似，但它们关注的角度是不一样的。多态是面向对象编程的一大特性，也是面向对象编程语言的一种语法。它是一种代码实现的思路。而里式替换是一种设计原则，是用来指导继承关系中子类该如何设计的，子类的设计要保证在替换父类的时候，不改变原有程序的逻辑以及不破坏原有程序的正确性。

哪些代码明显违背了 LSP？

实际上，里式替换原则还有另外一个更加能落地、更有指导意义的描述，那就是“Design By Contract”，中文翻译就是“按照协议来设计”。

子类在设计的时候，要遵守父类的行为约定（或者叫协议）。父类定义了函数的行为约定，那子类可以改变函数的内部实现逻辑，但不能改变函数原有的行为约定。这里的行为约定包括：

• 函数声明要实现的功能；

• 对输入、输出、异常的约定；

• 注释中所罗列的任何特殊说明。

实际上，定义中父类和子类之间的关系，也可以替换成接口和实现类之间的关系。

违反里氏替换原则的例子。

1. 子类违背父类声明要实现的功能

   父类中提供的 sortOrdersByAmount() 订单排序函数，是按照金额从小到大来给订单排序的，而子类重写这个 sortOrdersByAmount() 订单排序函数之后，是按照创建日期来给订单排序的。那子类的设计就违背里式替换原则。

2. 子类违背父类对输入、输出、异常的约定

   在父类中，某个函数约定：运行出错的时候返回 null；获取数据为空的时候返回空集合。而子类重载函数之后，实现变了，运行出错返回异常，获取不到数据返回 null。那子类的设计就违背里式替换原则。

   在父类中，某个函数约定，输入数据可以是任意整数，但子类实现的时候，只允许输入数据是正整数，负数就抛出，也就是说，子类对输入的数据的校验比父类更加严格，那子类的设计就违背了里式替换原则。

   在父类中，某个函数约定，只会抛出 ArgumentNullException 异常，那子类的设计实现中只允许抛出 ArgumentNullException 异常，任何其他异常的抛出，都会导致子类违背里式替换原则。

3. 子类违背父类注释中所罗列的任何特殊说明

   父类中定义的 withdraw() 提现函数的注释是这么写的：“用户的提现金额不得超过账户余额……”，而子类重写 withdraw() 函数之后，针对 VIP 账号实现了透支提现的功能，也就是提现金额可以大于账户余额，那这个子类的设计也是不符合里式替换原则的。

以上便是三种典型的违背里式替换原则的情况。除此之外，可以拿父类的单元测试去验证子类的代码。如果某些单元测试运行失败，就有可能说明，子类的设计实现没有完全地遵守父类的约定，子类有可能违背了里式替换原则。

重点回顾

里式替换原则是用来指导，继承关系中子类该如何设计的一个原则。理解里式替换原则，最核心的就是理解“design by contract，按照协议来设计”这几个字。父类定义了函数的“约定”（或者叫协议），那子类可以改变函数的内部实现逻辑，但不能改变函数原有的“约定”。这里的约定包括：函数声明要实现的功能；对输入、输出、异常的约定；甚至包括注释中所罗列的任何特殊说明。

理解里式替换原则跟多态的区别。多态和里式替换有点类似，但它们关注的角度是不一样的。多态是面向对象编程的一大特性，也是面向对象编程语言的一种语法。它是一种代码实现的思路。而里式替换是一种设计原则，用来指导继承关系中子类该如何设计，子类的设计要保证在替换父类的时候，不改变原有程序的逻辑及不破坏原有程序的正确性。