当前位置：首页 > news >正文

设计原则学习之里氏替换原则

news 2025/8/4 13:42:25

以下内容均来自抖音号【it楠老师教java】的设计模式课程。

1、原理概述

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

2、简单的示例1

// 基类：鸟类

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" );

}

}

为了遵循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 {

}

这里就该明确那些方法是通用的，哪些方法是部分能用的。

比如通用的方法可以放到class bird里。

public void say(){ System.out.println("我属于鸟科")}

public void say(){ System.out.println("我又一双翅膀，尽管不能飞")}

不同的用的方法，可以放到接口里比如有的鸟很小有的鸟很大

interface BigBird{ double height()}

interface SmallBird{ double height()}

上述可能不太准确，但是核心思想就是抽取公共的方法到类里，抽取特殊的方法到接口里。

再举个例比如

class door{

//核心方法只要是门不管你啥样的你肯定又面积吧，有价格吧

int price();

int area();

}

但是有的门市防火门有的是防盗门，有的是....

interface FangHuo{ void canFangHuo()};

interface FangDao{ void canFangDao()};

3、示例2

我们再来看一个基于数据库操作的案例。假设我们正在开发一个支持多种数据库的程序，包括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 基类。这些子类需要实现基类中定义的抽象方法，并可以添加特定于各自数据库的方法。

这里新手要思考下为什么用abstract class 怎么不用class 怎么不用interface

不用class，因为我这里还没有具体到那类数据源，其实可以定义个jdbcDatabase ，定义属性driver，url，user ,password。就是更一部的抽取

不用interface 因为connect close 和query是所有数据源都有操作！！！

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 ();

}

}

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

2 、哪些代码明显违背了 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 );

}

}

// 正确的写法

public class NonNegativeStack extends Stack {

public NonNegativeStack ( int size ) {

super ( size );

}

public void pushNonNegative ( int value ) {

if ( value < 0 ) {

throw new IllegalArgumentException ( "Only non-negative values are allowed" );

}

super . push ( value );

}

}