里氏替换原则

一.什么是里氏替换原则

• 里氏替换原则最早是由Barbara Liskov在1987年OOPSLA上提出的。她指出:“若对每个类型S的对象o1，都存在一个类型T的对象o2，使得在所有针对T编写的程序P中，用o1替换o2后，程序P的行为不变，则S是T的子类型。”
• 一个软件实体如果适用一个父类的话，那一定适用于其子类，所有引用父类的方法必须能透明地使用其子类的对象，子类对象能够替换父类对象，而程序逻辑不变。
• 子类可以扩展父类的功能，但不能改变父类原有的功能。就是说，子类可以实现父类的抽象方法，但不能覆盖父类的非抽象方法。子类中可以增加自己特有的方法。
• 当子类的方法重载父类的方法时，方法的前置条件(即方法的输入/入参)要比父类方法的输入参数更加宽松。当子类的方法实现父类的方法时(重写/重载或实现抽象方法)，方法的后置条件(即方法的输出/返回值)要比父类更严格或相等。
• 里氏替换原则，约束继承泛滥，开闭原则的一种体现。它加强了程序的健壮性，同时变更时也可以做到非常好的兼容性提高程序的维护性，扩展性。降低需求变更时引入的风险。

二.代码实现

• 通常认为正方形是特殊的长方形，只是正方形的长和宽相等。但是在具体的问题中，可能会出现问题。

public class Rectangle {
    private long length;
    private long width;

    public long getLength() {
        return length;
    }

    public void setLength(long length) {
        this.length = length;
    }

    public long getWidth() {
        return width;
    }

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

public class Square extends Rectangle {

    private long sideLength;

    @Override
    public long getLength() {
        return sideLength;
    }

    @Override
    public void setLength(long length) {
        this.sideLength = length;
    }

    @Override
    public long getWidth() {
        return sideLength;
    }

    @Override
    public void setWidth(long width) {
        this.sideLength = width;
    }
}

• 在测试长方形时，代码不会出现问题

public class Test {
    public static void resize(Rectangle rectangle){
        while (rectangle.getWidth() <= rectangle.getLength()){
            rectangle.setWidth(rectangle.getWidth()+1);
            System.out.println("width:"+rectangle.getWidth() + " length:"+rectangle.getLength());
        }
        System.out.println("resize方法结束 width:"+rectangle.getWidth() + " length:"+rectangle.getLength());
    }
    public static void main(String[] args) {
        Rectangle rectangle = new Rectangle();
        rectangle.setWidth(10);
        rectangle.setLength(20);
        resize(rectangle);
   	 }
    }

• 但是将长方形换做正方形，程序就无法停止，一直循环。原因在于Square重写了Rectangle方法，正方形的特性使得程序出了问题。
• 当子类的方法重载父类的方法时，方法的前置条件(即方法的输入/入参)要比父类方法的输入参数更加宽松。

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

public class Child extends Base {
    public void method(Map map) {
        System.out.println("子类HashMap入参方法被执行");
    }
}

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

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

public abstract class Base {
    public abstract Map method();
}

public class Child extends Base {
    @Override
    public HashMap method() {
        HashMap hashMap = new HashMap();
        System.out.println("子类method被执行");
        hashMap.put("message","子类method被执行");
        return hashMap;
    }
}

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