Java设计模式之设计原则-里氏替换原则 (LSP)

黑豪Horace

已于 2024-02-05 11:28:03 修改

阅读量443

点赞数

分类专栏：设计模式文章标签：设计模式

于 2020-02-12 14:49:40 首次发布

本文链接：https://blog.csdn.net/Dh_Chao/article/details/104278704

版权

设计模式专栏收录该内容

31 篇文章 1 订阅

订阅专栏

👉文章示例代码👈

附链

你也可以在这些平台阅读本文：

定义

任何基类可以出现的地方，子类一定可以出现。

里氏替换原则是继承复用的基石，只有当子类可以替换掉基类且软件单位的功能不受到影响的时候，基类才能真正被复用，而子类也能够在基类的基础上去增加新的行为。

里氏替换原则通俗点来说就是：子类可以扩展父类的功能，但不能改变父类原有的功能。

通过以上这句话，可以引申出以下几点含义：

**含义一：**子类可以实现父类的抽象方法，但不能覆盖父类的非抽象方法。
**含义二：**子类中可以增加自己特有的方法。
**含义三：**当子类的方法重载父类的方法时，方法的前置条件(即方法的输入、入参)要比父类方法的输入参数更宽松。
**含义四：**当子类的方法实现父类的方法时(重写、重载或者实现抽象方法)，方法的后置条件(即方法的输出、返回值)要比父类更严格或相等。

如果程序违背了里氏替换原则，则继承类的对象在基类出现的地方会出现运行错误。这时其修正方法是：取消原来的继承关系，重新设计它们之间的关系(可以采用依赖、聚集、组合等关系)。

含义讲解

在讲解开闭原则时，笔者通过扩展子类来覆写父类方法，同时子类提供额外方法来实现需求改动。👉点击跳转

代码粘贴至此：

/**
 * @author zhh
 * @description 食品打折类
 * @date 2020-02-05 00:27
 */
public class FoodDiscount extends Food {

    public FoodDiscount(Integer id, String name, Double price) {
        super(id, name, price);
    }

    public Double getOriginPrice() {
        return super.getPrice();
    }

    @Override
    public Double getPrice() {
        return this.getOriginPrice() * 0.6;
    }
}

含义一讲解

子类可以实现父类的抽象方法，但不能覆盖父类的非抽象方法。

上段代码中 getPrice() 其实已经对于原来的 Food 类中的 getPrice() 含义发生了变化，对其进行了打折。但这并不符合里氏替换原则。所以这里我们将打折的方法放置到新增的方法中，调整后的代码如下：

/**
 * @author zhh
 * @description 食品打折类
 * @date 2020-02-05 00:27
 */
public class FoodDiscount extends Food {

    public FoodDiscount(Integer id, String name, Double price) {
        super(id, name, price);
    }

    public Double getDiscountPrice() {
        return super.getPrice() * 0.6;
    }
}

这样调整后，我们可以看到子类并没有覆盖父类的非抽象方法 getPrice()。

含义二讲解

子类中可以增加自己特有的方法。
**
含义一讲解的代码片段中 getDiscountPrice() 是子类新增的特有方法，其父类中并不存在该方法。

含义三讲解

当子类的方法重载父类的方法时，方法的前置条件(即方法的输入/入参)要比父类方法的输入参数更宽松。

/**
 * @author zhh
 * @description 父类
 * @date 2020-02-07 16:50
 */
public class Father {

    public void method(HashMap hashMap) {
        System.out.println("父类被执行");
    }
}

/**
 * @author zhh
 * @description 子类
 * @date 2020-02-07 16:51
 */
public class Child extends Father {

    // 重载方法
    public void method(Map map) {
        System.out.println("子类Map被执行");
    }
}

/**
 * @author zhh
 * @description 测试类
 * @date 2020-02-07 16:53
 */
public class Test {

    public static void main(String[] args) {
        Child child = new Child();
        HashMap hashMap = new HashMap();
        child.method(hashMap);
    }
}

测试类的输出结果如下：

父类被执行

这个输出结构是正确的。

父类的方法入参是 HashMap 类型，而子类的方法入参是 Map 类型，子类的方法入参类型范围比父类大，那么子类的方法永远也不会被执行。

那我们反过来试下，调整代码如下。

public class Father {

    public void method(Map map) {
        System.out.println("父类被执行");
    }
}

public class Child extends Father {

    // 重载方法
    public void method(HashMap hashMap) {
        System.out.println("子类HashMap被执行");
    }
}

public class Test {

    public static void main(String[] args) {
        Child child = new Child();
        HashMap hashMap = new HashMap();
        child.method(hashMap);
    }
}

测试类的输出结果如下：

子类HashMap被执行

可以看到这个时候程序执行了子类的 method 方法，这样就违反了里氏替换原则，在实际的开发过程当中很容易引起业务逻辑的混乱。

含义四讲解

当子类的方法实现父类的方法时(重写、重载或者实现抽象方法)，方法的后置条件(即方法的输出、返回值)要比父类更严格或相等。

/**
 * @author zhh
 * @description 父类
 * @date 2020-02-07 17:11
 */
public abstract class Father {

    public abstract Map method();
}

/**
 * @author zhh
 * @description 子类
 * @date 2020-02-08 11:13
 */
public class Child extends Father {

    @Override
    public HashMap method() {
        HashMap hashMap = new HashMap();
        System.out.println("子类method方法被执行");
        hashMap.put("username", "zhaohaihao");
        return hashMap;
    }
}

/**
 * @author zhh
 * @description 测试类
 * @date 2020-02-08 11:17
 */
public class Test {

    public static void main(String[] args) {
        Child child = new Child();
        System.out.println(child.method());
    }
}