设计模式之里氏替换原则

OO中的继承性的思考和说明

• 继承包含这样一层含义： 父类中凡是已经实现好的方法，实际上是在设计规范，虽然它不强制要求所有子类必须遵循这些规范，但是如果子类如果对这些已经实现的方法任意修改，就会对整个继承体系造成破坏。

• 继承给程序设计带来便利的同时，也带来了弊端。比如使用了继承，父类的任何改动都得考虑到所有继承的子类，并且父类修改后，所有涉及到的子类功能都有可能产生故障。

问题提出：如何正确使用继承？ 里氏替换原则

OO中的继承性的思考和说明

1. 里氏替换原则（Liskov Substitution Principle）在1988年，由麻省理工学院的一位姓里的女士提出的。
2. 如果对每个类型为T1的对象o1，都有类型为T2的对象o2，使得以T1定义的所有程序P在所有的对象o1都换成o2时，程序P的行为没有发生变化，那么类型T2是类型T1的子类型。换句话说，所有引用基类的地方都必须能透明地使用其子类对象。
3. 在使用继承时，遵循里氏替换原则，在子类中尽量不要重写父类的方法。
4. 里氏替换原则告诉我们，继承实际上让两个类耦合性增强了，在适当的情况下，可以通过聚合，组合，依赖来解决问题。

反例：

public class A {

    //a + b
    public Integer function1(int a,int b){

        return a + b;

    }
}

public class B extends A{

    //change function1 of A by accident
    @Override
    public Integer function1(int a, int b) {
        return a-b;
    }
}

public class Main {

    public static void main(String[] args) {
        A a = new A();
        System.out.println("1+2="+a.function1(1, 2));
        System.out.println("2+3="+a.function1(2, 3));

        System.out.println("-------------------------");

        A b = new B();
        System.out.println("1+2="+b.function1(1, 2)); //没想到B 已经改了继承的方法，造成结果错误
        System.out.println("2+3="+b.function1(2, 3));

    }
}

测试结果：

解决方法：

1. B类不小心改了A类的方法，导致调用出错。在实际开发中，我们常常会通过修改父类的方法完成新的功能，这样写起来虽然简单，但是整个继承体系复用性比较差。
2. 通用的做法是：将原来的父类和子类都继承一个更加通用的基类，原有的继承关系去掉，采用依赖，聚合，组合等方式代替。

改进后的方案如下：

正例：

public abstract class Base {
    public abstract Integer function1(int a, int b);

}

public class A extends Base{
    //a + b
    @Override
    public Integer function1(int a,int b){

        return a + b;

    }
}

public class B extends Base {

    A a = new A();

    //a-b
    @Override
    public Integer function1(int a, int b) {
        return a-b;
    }

    public Integer function2(int i, int j){
        return a.function1(i, j);
    }
}

public class Main {

    public static void main(String[] args) {
        Base a = new A();
        System.out.println("1+2="+a.function1(1, 2));
        System.out.println("2+3="+a.function1(2, 3));

        System.out.println("-------------------------");

        Base b = new B();
        System.out.println("1-2="+b.function1(1, 2));
        System.out.println("2-3="+b.function1(2, 3));

    }
}

总之，里氏替换原则告诉我们，子类中尽量不要重写父类的方法！

代码地址：https://github.com/GilbertXiao/JavaDesignPatterns