设计模式六大原则之四：里氏替换原则

1 基本介绍

java中的继承大家都用过，子类可以继承父类的方法和属性，其实继承还有一层隐藏的含义：父类已经写好了的方法，就是定义了自己的规范，虽然没有要求规定子类必循遵循这些规范，但是如果子类对这些方法进行了修改，就会对整个继承体系造成破坏。另外子类继承父类，也降低了程序的可移植性，增加了耦合性，如果父类想要改变这些方法，就需要考虑到子类的功能是否会出现bug或者是存在bug的隐患。

里氏替换原则：所有引用基类的地方必须能透明地使用其子类的对象。在使用继承时，在子类中尽量不要重写父类的方法。继承实际上是让两个类耦合性增强了，在适当的情况下，可以通过聚合，组合，依赖来解决问题。

2 案例演示

public class TCase {
    public static void main(String[] args) {
        A a = new A();
        System.out.println("10+4=" + a.fun1(10,4));
        System.out.println("8+2=" + a.fun1(8,2));
        
        B b = new B();
        System.out.println("10+4=" + b.fun1(10,4));
        System.out.println("8+2=" + b.fun1(8,2));
        System.out.println("(8+2)*2=" + b.fun2(8,2));
    }
}

class A {
    public int fun1(int a, int b) {return a + b;}
}

class B extends A {
    public int fun1(int a, int b) {return a - b;}
    public int fun2(int a, int b) {return fun1(a,b) * 2;}
}

从上面可以看出来类B继承类A，并无意改写了A中的fun1，而在我们的功能中，原来的功能是计算两数之和，现在B把fun1改写了，现在功能就出现了问题，导致后面的功能也计算错误了。

优化：

public class TCase {
    public static void main(String[] args) {
        A a = new A();
        System.out.println("10+4=" + a.fun1(10,4));
        System.out.println("8+2=" + a.fun1(8,2));
        
        B b = new B();
        System.out.println("10+4=" + b.fun1(10,4));
        System.out.println("8+2=" + b.fun1(8,2));
        System.out.println("(8+2)*2=" + b.fun2(8,2));
    }
}

/*
创建一个更加基础的基类，让更加基础的方法和成员写到这个基类中
*/
class BaseFun {
    public int fun1(int a, int b) {return a + b;}
}

class A extends BaseFun {
    public int fun1(int a, int b) {return a + b;}
}

class B extends BaseFun {
    private A a = new A();
    public int fun1(int a, int b) {return a - b;}
    public int fun2(int a, int b) {return fun1(a,b) * 2;}
    // 如果B仍然想使用A中的方法
    public int fun3(int a, int b) {return this.a.fun1(a, b);}
}