【23种设计模式】里氏替换原则

个人主页：金鳞踏雨

个人简介：大家好，我是金鳞，一个初出茅庐的Java小白

目前状况：22届普通本科毕业生，几经波折了，现在任职于一家国内大型知名日化公司，从事Java开发工作

我的博客：这里是CSDN，是我学习技术，总结知识的地方。希望和各位大佬交流，共同进步 ~

本文来自抖音《IT楠老师》设计模式课程，下面是本人结合原课件的一些学习心得。

一、原理概述

子类对象能够替换程序中父类对象出现的任何地方，并且保证原来程序的逻辑行为不变及正确性不被破坏。

举一个最简单的例子，就是我们定义了一个函数，它的参数是 XXX(List list)，当我们传入ArrayList的对象（它的子类）,不会有任何问题！

案例分析

案例一

// 基类：鸟类
public class Bird {
    public void fly() {
        System.out.println("I can fly");
    }
}
 
// 子类：企鹅类
public class Penguin extends Bird {
    // 企鹅不能飞，所以覆盖了基类的fly方法，但这违反了里氏替换原则
    public void fly() {
        throw new UnsupportedOperationException("Penguins can't fly");
    }
}

企鹅不会飞，所以在企鹅类中重写的fly()，会抛出异常。那么这个子类并不能很好的替代父类，因为它执行fly() 方法会报错！！！

为了遵循LSP，我们可以重新设计类结构，将能飞的行为抽象到一个接口中，让需要飞行能力的鸟类实现这个接口，对于企鹅，就不实现这个方法！

// 飞行行为接口
public interface Flyable {
    void fly();
}
 
// 基类：鸟类
public class Bird {
}
 
// 子类：能飞的鸟类
public class FlyingBird extends Bird implements Flyable {
    @Override
    public void fly() {
        System.out.println("I can fly");
    }
}
 
// 子类：企鹅类，不实现Flyable接口！！！
public class Penguin extends Bird {
}

通过这样的设计，我们遵循了里氏替换原则，同时也保证了代码的可维护性和复用性。

案例二

假设我们正在开发一个支持多种数据库的程序，包括MySQL、PostgreSQL和SQLite。我们可以使用里氏替换原则来设计合适的类结构，确保代码的可维护性和扩展性。

首先，我们定义一个抽象的Database基类，它包含一些通用的数据库操作方法，如connect()、disconnect()和executeQuery()。这些方法的具体实现将在子类中完成。

public abstract class Database {
    public abstract void connect();
    public abstract void disconnect();
    public abstract void executeQuery(String query);
}

然后，为每种数据库类型创建一个子类，继承自Database基类。这些子类需要实现基类中定义的抽象方法，并可以添加特定于各自数据库的方法。

public class MySQLDatabase extends Database {
    @Override
    public void connect() {
        // 实现MySQL的连接逻辑
    }
 
    @Override
    public void disconnect() {
        // 实现MySQL的断开连接逻辑
    }
 
    @Override
    public void executeQuery(String query) {
        // 实现MySQL的查询逻辑
    }
 
    // 其他针对MySQL的特定方法
}
 
public class PostgreSQLDatabase extends Database {
    // 类似地，为PostgreSQL实现相应的方法
}
 
public class SQLiteDatabase extends Database {
    // 类似地，为SQLite实现相应的方法
}

这样设计的好处是，我们可以在不同的数据库类型之间灵活切换，而不需要修改大量代码。只要这些子类遵循里氏替换原则，我们就可以放心地使用基类的引用来操作不同类型的数据库。例如：

public class DatabaseClient {
    private Database database;
 
    public DatabaseClient(Database database) {
        this.database = database;
    }
 
    public void performDatabaseOperations() {
        database.connect();
        database.executeQuery("SELECT * FROM users");
        database.disconnect();
    }
}
 
public class Main {
    public static void main(String[] args) {
        // 使用MySQL数据库
        DatabaseClient client1 = new DatabaseClient(new MySQLDatabase());
        client1.performDatabaseOperations();
 
        // 切换到PostgreSQL数据库
        DatabaseClient client2 = new DatabaseClient(new PostgreSQLDatabase());
        client2.performDatabaseOperations();
 
        // 切换到SQLite数据库
        DatabaseClient client3 = new DatabaseClient(new SQLiteDatabase());
        client3.performDatabaseOperations();
    }
}

通过遵循里氏替换原则，我们确保了代码的可维护性和扩展性。如果需要支持新的数据库类型，只需创建一个新的子类，实现Database基类中定义的抽象方法即可。

好了，我们稍微总结一下。虽然从定义描述和代码实现上来看，多态和里式替换有点类似，但它们关注的角度是不一样的。

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

二、哪些代码明显违背了 LSP？

1. 子类覆盖或修改了基类的方法

当子类覆盖或修改基类的方法时，可能导致子类无法替换基类的实例而不引起问题。这违反了LSP，会导致代码变得脆弱和不易维护。

public class Bird {
    public void fly() {
        System.out.println("I can fly");
    }
}
 
public class Penguin extends Bird {
    @Override
    public void fly() {
        throw new UnsupportedOperationException("Penguins can't fly");
    }
}

在这个例子中，Penguin类覆盖了Bird类的fly()方法，抛出了一个异常。这违反了LSP，因为现在Penguin实例无法替换Bird实例。

2. 子类违反了基类的约束条件

当子类违反了基类中定义的约束条件（如输入、输出或异常等），也会违反LSP。

// 栈
public class Stack {
    private int top;
    private int[] elements;
 
    public Stack(int size) {
        elements = new int[size];
        top = -1;
    }
 
    public void push(int value) {
        if (top >= elements.length - 1) {
            throw new IllegalStateException("Stack is full");
        }
        elements[++top] = value;
    }
 
    public int pop() {
        if (top < 0) {
            throw new IllegalStateException("Stack is empty");
        }
        return elements[top--];
    }
}
 
// 正数的栈
public class NonNegativeStack extends Stack {
    public NonNegativeStack(int size) {
        super(size);
    }
 
    @Override
    public void push(int value) {
        if (value < 0) {
            throw new IllegalArgumentException("Only non-negative values are allowed");
        }
        super.push(value);
    }
}

在这个例子中，NonNegativeStack子类违反了Stack基类的约束条件，因为它在push()方法中添加了一个新的约束，即只允许非负数入栈。这使得NonNegativeStack实例无法替换Stack实例而不引发问题，违反了LSP。

正确的写法应该是：

public class NonNegativeStack extends Stack {
    public NonNegativeStack(int size) {
        super(size);
    }
 
    @Override
    public void push(int value) {
        super.push(value);
    }
 
    // 定义新的约束条件
    public void pushNonNegative(int value) {
        if (value < 0) {
            throw new IllegalArgumentException("Only non-negative values are allowed");
        }
        super.push(value);
    }
}

3. 子类与基类之间缺乏"is-a"关系

当子类与基类之间缺乏真正的"is-a"关系时，也可能导致违反LSP。例如，如果一个类继承自另一个类，仅仅因为它们具有部分相似性，而不是完全的"is-a"关系，那么这种继承关系可能不满足LSP。

为了避免违反LSP，我们需要在设计和实现过程中注意以下几点：

• 确保子类和基类之间存在真正的"is-a"关系。(你就是一个它)
• 遵循其他设计原则，如单一职责原则、开闭原则和依赖倒置原则。

文章到这里就结束了，如果有什么疑问的地方，可以在评论区指出~

希望能和大佬们一起努力，诸君顶峰相见

再次感谢各位小伙伴儿们的支持！！！