里氏替换原则

最新推荐文章于 2024-08-19 20:00:00 发布

愿时光不负.

最新推荐文章于 2024-08-19 20:00:00 发布

阅读量341

点赞数 4

分类专栏： # 面向对象的基本原则文章标签：里氏替换原则 java 开发语言

本文链接：https://blog.csdn.net/qq_27656927/article/details/141323871

版权

面向对象的基本原则专栏收录该内容

5 篇文章 0 订阅

订阅专栏

里氏替换原则（Liskov Substitution Principle, LSP） 是面向对象设计的五大基本原则之一，由计算机科学家 Barbara Liskov 提出。这个原则的核心思想是 子类对象必须能够替换掉父类对象，而不会导致程序逻辑错误或行为异常。换句话说，程序中的父类对象应该可以被其子类对象替换，而不改变程序的正确性。

里氏替换原则的解释

继承的正确性：如果类 B 是类 A 的子类，那么所有使用 A 的地方都可以使用 B，而不会影响程序的正确性。子类应当完全实现父类的行为。
行为一致性：子类应保持父类的行为，不能改变父类已经实现的功能或约定。子类在扩展父类功能的同时，不应削弱或修改父类的功能。
加强约束，放宽前提：子类在实现或重写父类的方法时，不能对输入参数有更严格的要求，也不能对输出结果的类型或范围有更宽松的定义。

为什么需要里氏替换原则？

提高代码的可靠性：遵循 LSP 可以确保子类的行为与父类一致，从而避免因为子类的不同实现而引发错误或不可预见的问题。
增强系统的可维护性：LSP 促使我们编写更加健壮的继承结构，使得代码更容易扩展和维护。
支持多态：LSP 是多态性的基础。遵循 LSP 的类层次结构，可以让我们更自信地使用多态设计，不必担心子类的实现会破坏系统的逻辑。

示例代码

为了更好地理解里氏替换原则，下面将通过一个简单的示例来展示。

场景：几何形状

假设我们有一个 Rectangle 类（矩形）和一个 Square 类（正方形），Square 类继承了 Rectangle 类。

违背里氏替换原则的实现：

class Rectangle {
    private int width;
    private int height;

    public void setWidth(int width) {
        this.width = width;
    }

    public void setHeight(int height) {
        this.height = height;
    }

    public int getArea() {
        return width * height;
    }
}

class Square extends Rectangle {
    @Override
    public void setWidth(int width) {
        super.setWidth(width);
        super.setHeight(width); // 正方形的高度和宽度必须相等
    }

    @Override
    public void setHeight(int height) {
        super.setWidth(height); // 正方形的宽度和高度必须相等
        super.setHeight(height);
    }
}

// 测试代码
public class Main {
    public static void main(String[] args) {
        Rectangle rectangle = new Rectangle();
        rectangle.setWidth(5);
        rectangle.setHeight(10);
        System.out.println(rectangle.getArea()); // 输出: 50

        Rectangle square = new Square();
        square.setWidth(5);
        square.setHeight(10);
        System.out.println(square.getArea()); // 理论上应该输出: 50，实际上输出: 100
    }
}

在这个例子中，Square 类继承了 Rectangle 类，但因为正方形的宽高必须相等，Square 类重写了 setWidth 和 setHeight 方法，使得 Square 对象不能替代 Rectangle 对象。这个设计违背了里氏替换原则，因为在使用 Square 替换 Rectangle 时，程序行为发生了变化。

遵循里氏替换原则的实现：

我们可以将 Rectangle 和 Square 分别实现为独立的类，而不是通过继承来实现关系，从而遵循 LSP。

// 抽象形状类
abstract class Shape {
    abstract int getArea();
}

// 矩形类实现
class Rectangle extends Shape {
    private int width;
    private int height;

    public Rectangle(int width, int height) {
        this.width = width;
        this.height = height;
    }

    @Override
    public int getArea() {
        return width * height;
    }

    public void setWidth(int width) {
        this.width = width;
    }

    public void setHeight(int height) {
        this.height = height;
    }
}

// 正方形类实现
class Square extends Shape {
    private int side;

    public Square(int side) {
        this.side = side;
    }

    @Override
    public int getArea() {
        return side * side;
    }

    public void setSide(int side) {
        this.side = side;
    }
}

// 测试代码
public class Main {
    public static void main(String[] args) {
        Shape rectangle = new Rectangle(5, 10);
        System.out.println(rectangle.getArea()); // 输出: 50

        Shape square = new Square(5);
        System.out.println(square.getArea()); // 输出: 25
    }
}