Java设计模式七大原则-里氏代换原则

猫十二懿

于 2023-06-02 12:15:06 发布

阅读量437

点赞数

分类专栏：设计模式文章标签： java 设计模式开发语言

本文链接：https://blog.csdn.net/qq_56098191/article/details/131004556

版权

设计模式专栏收录该内容

33 篇文章 2 订阅

订阅专栏

✨作者：猫十二懿

❤️‍🔥账号：CSDN 、掘金、个人博客、Github

🎉公众号：猫十二懿

里氏代换原则

1、里氏代换原则介绍

里氏代换原则(Liskov Substitution Principle, LSP)：子类型必须能够替换掉它们的父类型。

一个软件实体如果使用的是一个父类的话，那么一定适用于其子类，而且它察觉不出父类对象和子类对象的区别。也就是说，在软件里面，把父类都替换成它的子类，程序的行为没有变化，简单地说，子类型必须能够替换掉它们的父类型。
这个原则主要是为了保证在使用继承时，子类能够替换掉父类，并且在不影响系统原有功能的前提下，增加新的功能。也就是说，如果一个程序是建立在一个父类的基础上，那么通过替换成其子类，程序仍然能够正常运行，并达到预期的结果。
里氏代换原则的关键在于子类重写父类的方法必须保证父类所定义的方法的前置条件、后置条件以及副作用在子类中仍然成立。也就是说，子类对父类的方法进行重写时，不应该改变原有的约定、规范和契约，否则可能会破坏原有的功能。

2、案例说明

class Rectangle {
    protected int width = 0;
    protected int height = 0;

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

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

    public int getWidth() {
        return width;
    }

    public int getHeight() {
        return height;
    }

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

class Square extends Rectangle {
    public void setWidth(int width) {
        this.width = width;
        this.height = width;
    }

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

public class Main {
    public static void main(String[] args) {
        Rectangle r = new Square();
        r.setWidth(5);
        r.setHeight(10);

        System.out.println(r.getArea());
    }
}

在这个程序中，我们定义了一个矩形类和它的子类正方形。正方形是矩形的一种特殊情况，只不过长和宽相等而已。显然，正方形可以替换矩形的位置，但是，在这个例子中，如果我们以正方形对象来创建一个矩形对象的话，就会出现问题。因为矩形的宽和高是可以分别设置的，而正方形必须保证宽和高相等。由于正方形重写了父类矩形的设置宽、高的方法，因此矩形作为父类被替换成正方形的时候，就会出现宽高不符合期望的情况。

这个例子违反了LSP原则，因为父类与子类之间的行为不是完全一致的，父类中允许的某些操作在子类中并不适用。

3、使用LSP改进代码

abstract class Quadrilateral{
    protected int width = 0;
    protected int height = 0;

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

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

    public int getWidth() {
        return width;
    }

    public int getHeight() {
        return height;
    }

    public abstract int getArea();
}

class Rectangle extends Quadrilateral {
    public int getArea() {
        return width * height;
    }
}

class Square extends Quadrilateral {
    public void setWidth(int side) {
        this.width = side;
        this.height = side;
    }
    
    public void setHeight(int side) {
        this.width = side;
        this.height = side;
    }

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

public class Main {
    public static void main(String[] args) {
        Quadrilateral q1 = new Rectangle();
        q1.setWidth(5);
        q1.setHeight(10);

        Quadrilateral q2 = new Square();
        q2.setWidth(5);

        System.out.println(q1.getArea());
        System.out.println(q2.getArea());
    }
}

在这个程序中，我们定义了一个抽象的四边形类Quadrilateral，并且让Rectangle和Square分别继承这个类。因为两个类都共享了它们所包含的行为（getArea）。Square类重写了setWidth和setHeight方法以确保高度和宽度相等。这样，我们就能够根据需要使用Rectangle或Square对象来进行运算而不会改变程序的表现和结果。

这个程序遵循了LSP原则，因为Quadrilateral类和它的子类之间所共享的行为是完全一致的。在使用子类时，程序得到的结果与使用父类时是一样的。