解析Java实现设计模式六大原则之里氏替换原则

什么是里氏替换原则

里氏替换原则，简称LSP（Liskov Substitution Principle），是面向对象设计中非常重要的一条原则。它的定义如下：如果对于每个类型为S的对象o1，都有类型为T的对象o2，使得以T定义的所有程序P在所有对象o1都替换成o2时，程序P的行为没有发生变化，那么类型S是类型T的子类型。

简单来说，LSP原则就是说：子类必须能够替换它们的基类，且替换后不会产生任何错误或异常，否则就违反了LSP原则。

为什么需要里氏替换原则

遵循LSP原则可以提高代码的可维护性和可扩展性，同时也保证了系统的正确性。如果多个子类不能替换它们的基类，那么为了处理这些子类之间的差异，往往需要通过大量的条件判断和类型转换来实现，不仅使代码复杂度大大增加，也降低了系统的可扩展性。

如何在Java中实现里氏替换原则

在Java中实现LSP原则通常需要遵循以下几个规则：

1. 子类必须保留父类原有的行为，不得删除、修改或者限制父类的方法和属性。

2. 子类可以增加自己独有的方法和属性。

3. 子类覆写（重写）的方法应该保证：先决条件不能强于父类方法，后置条件不能弱于父类方法。

4. 子类不得抛出比父类更强的异常。

示例说明

示例1

// 父类 Animal
public class Animal {
    private String name;
    private int age;
    // 省略 getter 和 setter 方法 

    public void move() {
        System.out.println("动物移动");
    }
    public void eat() {
        System.out.println("动物进食");
    }
}

// 子类 Dog
public class Dog extends Animal {
    // 狗特有的方法
    public void bark() {
        System.out.println("狗叫");
    }
}

// 测试类
public class AnimalTest {
    public static void main(String[] args) {
        Animal animal = new Dog();
        animal.move();
        animal.eat();
        // animal.bark();  // 编译错误，不能调用子类特有的方法
    }
}

在上述示例中，我们定义了一个父类 Animal 和一个子类 Dog。Dog类继承了Animal类，并且增加了一种狗特有的方法 bark。在测试类中，我们创建了一个 Animal 类型的变量，通过 new 关键字来实例化一个 Dog 类的对象。然后调用了继承自父类的 move 和 eat 方法。这是符合LSP原则的，因为在子类中增加了一个独有的方法，但是没有删除、修改或者限制父类的原有方法。而且，通过父类类型的变量来引用子类对象，也可以保证子类能够替换父类。如果我们尝试调用 bark 方法，会导致编译错误，这也说明了子类的特有方法不能被直接调用。

示例2

// 父类 Shape
public abstract class Shape {
    public abstract void draw();

    public void setColor(String color) {
        // 设置颜色
    }
}

// 子类 Circle
public class Circle extends Shape {
    private double radius;

    public Circle(double radius) {
        this.radius = radius;
    }

    @Override
    public void draw() {
        System.out.println("画圆");
    }

    // 覆盖父类方法后置条件不能弱于父类方法
    @Override
    public void setColor(String color) {
        if ("红色".equals(color)) {
            super.setColor(color);
        } else {
            throw new RuntimeException("颜色必须是红色");
        }
    }
}

// 测试类
public class ShapeTest {
    public static void main(String[] args) {
        Shape shape = new Circle(5.0);
        shape.setColor("红色");
        shape.draw();
    }
}

在上述示例中，我们定义了一个抽象类 Shape 和一个子类 Circle。Shape 类中只声明了一个抽象方法 draw 和一个常规方法 setColor，setColor 方法用来设置形状的颜色。Circle 类继承了 Shape 类并且自定义了一个私有属性 radius。在 Circle 类中，我们重写了父类的 setColor 方法，并且在方法中增加了一个限制条件，即只能设置红色的颜色，否则将抛出一个运行时异常。这也符合LSP原则的后置条件不能弱于父类方法，因为重写的方法增加了限制条件，但是这个限制条件并不影响父类原有的行为，是在原有行为的基础上增加的。

在测试类中，我们创建了一个 Shape 类型的变量，通过 new 关键字来实例化一个 Circle 类的对象。然后我们调用了 setColor 方法，并传入了一个合法的颜色，最后调用 draw 方法，画出了一个圆形。这也说明了子类能够替换父类，且替换后没有产生任何错误或异常。