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

基本介绍

1）所有引用基类的地方必须能透明的使用其子类对象

2）在使用继承时，遵循里氏替换原则，在子类中尽量不要重写父类的方法

3）里氏替换原则告诉我们，继承实际上让两个类耦合性增强了，在适当的情况下，可以通过聚合，组合，依赖来解决问题

案列说明

package com.hy.principle.liskov;

/**
 * @author hanyong
 * @date 2020/9/17 0:35
 */
public class Liskov {
    public static void main(String[] args) {
        A a=new A();
        System.out.println("3-1="+a.fun1(1,3));

        B b=new B();
        //无意重写，但是不小心重写，导致报错
        System.out.println("5-2="+b.fun1(5,2));
        System.out.println("7+5+9="+b.fun2(7,5));
    }
}

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

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

    public int fun2(int a, int b) {
        return this.fun1(a, b) + 9;
    }
}

package com.hy.principle.liskov.improve;

/**
 * @author hanyong
 * @date 2020/9/17 0:35
 */
public class Liskov {
    public static void main(String[] args) {
        A a = new A();
        System.out.println("3-1=" + a.fun1(1, 3));

        B b = new B();
//B跟A没有继承，不易混用
        System.out.println("5+2=" + b.fun1(5, 2));
        System.out.println("7+5+9=" + b.fun2(7, 5));
        System.out.println("7-1=" + b.fun3(7, 1));
    }
}

class Base {
//把更加基础的方法和成员写到Base类
}

class A extends Base {
    public int fun1(int a, int b) {
        return a - b;
    }
}

/**
 * 使用组合调用A类的方法
 */
class B {

    private A a = new A();

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

    public int fun2(int a, int b) {
        return this.fun1(a, b) + 9;
    }

    public int fun3(int a, int b) {
        return this.a.fun1(a, b);
    }
}