设计模式六大原则（二）：里氏替换原则

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

里氏替换原则针对的问题

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

里氏替换原则的解决方案

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

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

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

里氏替换原则的案例

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

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

代码如下：

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千米所要花费的时间。

修改后的代码如下：

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.当子类的方法重载父类的方法时，方法的前置条件（即方法的形参）要比父类方法的输入参数更加宽松。

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