设计模式六大原则(二):里氏替换原则

里氏替换原则的定义是:所有引用基类的地方必须能透明化地使用其子类的对象。

里氏替换原则针对的问题

有一个功能P1,由类A完成。现需要将功能P1进行扩展,扩展后的功能为P,其中P由原有功能P1与新功能P2组成。新功能P由类A的子类B来完成,则子类B在完成新功能P2的同时,有可能会导致原有功能P1发生故障。

里氏替换原则的解决方案

当使用继承的时候,遵循里氏替换原则。类B继承类A的时候,除了添加新的方法完成新增功能P2外,尽量不要重写父类A的方法,也尽量不要重载父类A的方法。

继承包含这样一层含义:父类中范式已经实现好的方法(相对于抽象方法而言),实际上是在设定一系列的规范和契约,虽然它不强制要求所有的子类必须遵从这些契约,但是如果子类对这些非抽象方法任意修改,就会对整个继承体系造成破坏。而里氏替换原则就是表达了这一层含义。

继承作为面向对象的三大特征之一,在给程序设计带来巨大便利的同时,也带来了弊端。比如使用继承会给程序带来侵入性,程序的可移植性降低,增加了对象之间的耦合性。如果一个类被其他的类所继承,则当这个类需要修改时,必须考虑到所有的子类,并且父类修改后,所有涉及到子类的功能都有可能会产生故障。

里氏替换原则的案例

关于里氏替换原则的例子,最有名的是【正方形不是长方形】。当然,生活中也有很多类似的例子,例如,企鹅、鸵鸟和几维鸟从生物学的角度来划分,它们属于鸟类;但是从类的继承关系来看,由于它们不能继承鸟类会飞的功能,所以它们不能被定义成鸟类的子类。如果要强行定义为鸟类的子类,则有一些行为是需要重写鸟类的行为的,这样就违背了里氏替换原则。

这里以【几维鸟不是鸟】为例来说明里氏替换原则

设计模式六大原则(二):里氏替换原则_第1张图片

代码如下:

public class LspTest {
    public static void main(String[] args) {
        Bird bird1 = new Swallow();
        Bird bird2 = new BrownKiwi();
        bird1.setSpeed(120);
        bird2.setSpeed(120);
        System.out.println("如果飞行300公里:");
        try {
            System.out.println("燕子将飞行" + bird1.getFlyTime(300) + "小时。"); // 燕子将飞行2.5小时。
            System.out.println("几维鸟将飞行" + bird2.getFlyTime(300) + "小时。"); // 几维鸟将飞行Infinity小时。
        } catch (Exception err) {
            System.out.println("发生错误了!");
        }
    }
}

// 鸟类
class Bird {
    double flySpeed;

    public void setSpeed(double speed) {
        flySpeed = speed;
    }

    public double getFlyTime(double distance) {
        return (distance / flySpeed);
    }
}

// 燕子类
class Swallow extends Bird {
}

// 几维鸟类
class BrownKiwi extends Bird {
    public void setSpeed(double speed) {
        flySpeed = 0;
    }
}

这里,因为几维鸟类重写了鸟类的setSpeed方法,导致了程序发生错误,违背了里氏替换原则。正确的做法应该是取消几维鸟原来的继承关系,定义鸟类和几位鸟类的更一般的父类,比如动物类。他们都拥有奔跑的能力。几维鸟的飞行速度虽然为0,但是奔跑速度不为0,可以计算出其奔跑300千米所要花费的时间。

设计模式六大原则(二):里氏替换原则_第2张图片

修改后的代码如下:

public class LspTest2 {
    public static void main(String[] args) {
        Animal bird_swallow = new Bird_Swallow();
        Animal notBird_brownKiwi = new NotBird_BrownKiwi();
        bird_swallow.setSpeed(120);
        notBird_brownKiwi.setSpeed(120);
        System.out.println("如果移动300公里:");
        try {
            System.out.println("燕子将花费" + bird_swallow.getFlyTime(300) + "小时。"); // 燕子将花费2.5小时。
            System.out.println("几维鸟将花费" + notBird_brownKiwi.getFlyTime(300) + "小时。"); // 几维鸟将花费2.5小时。
        } catch (Exception err) {
            System.out.println("发生错误了!");
        }
    }
}

// 动物类
class Animal {
    private double speed;

    public void setSpeed(double speed) {
        this.speed = speed;
    }

    public double getFlyTime(double distance) {
        return (distance / speed);
    }
}

// 燕子类
class Bird_Swallow extends Animal {
}

// 几维鸟类
class NotBird_BrownKiwi extends Animal {

}

里氏替换原则的认识

里氏替换原则主要阐述了有关继承的一些原则,也就是什么时候应该使用继承,什么时候不应该使用继承,以及其中蕴含的原理。里氏替换原则是继承复用的基础,它反映了基类与子类之间的关系,是对开闭原则的补充,是对实现抽象化的具体步骤的规范。

里氏替换原则的通俗理解就是:子类可以扩展父类的功能,但是不能改变父类原有的功能。也就是说,在子类继承父类的时候,除了添加新的方法完成新增功能之外,尽量不要重写父类的方法。

如果通过重写父类的方法来完成新的功能,这样写起来虽然简单,但是整个继承体系的可复用性会比较差,特别是运用多态比较频繁时,程序运行出错的概率会非常大。

如果程序违背了里氏替换原则,则继承的对象在基类出现的地方会出现运行错误。这时其修正方法是:取消原来的继承关系,重新设计他们之间的关系。

它包含了以下4层含义:

1.子类可以实现父类的抽象方法,但是不能覆盖父类的非抽象方法。

2.子类中可以增加自己特有的方法。

3.当子类的方法重载父类的方法时,方法的前置条件(即方法的形参)要比父类方法的输入参数更加宽松。

 

"每天按部就班地做着自己的事,但是也会对你淡淡地想念。打开微信偶尔平常得聊几句,问问最近你过得怎么样,开心不开心,和你分享一些今天遇到的趣事,也不期待你能够秒回。只是因为分享的对象是你,我就会觉得很满足了。"

转载于:https://www.cnblogs.com/yanggb/p/10928309.html

你可能感兴趣的:(设计模式六大原则(二):里氏替换原则)