七大原则四-->里氏替换原则

里氏替换原则

解决类继承(对象)代码耦合性问题

继承关系中 父类修改 会影响子类

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

以下代码 违背了里氏替换原则

package com.wf.zhang.Liskov;

public class Liskov {

    public static void main(String[] args) {

        A a = new A();
        System.out.println("11-3=" + a.func1(11, 3));
        System.out.println("1-8=" + a.func1(1, 8));
        System.out.println("-----------------------");
        B b = new B();
        /***
         * B类 继承 A类  并重写了func1  违背了里氏替换原则
         * B类中的func1方法 和 A类 func1方法 不一样了
         * 代码结果就出问题了
         */
        System.out.println("11-3=" + b.func1(11, 3));
        System.out.println("1-8=" + b.func1(1, 8));
        System.out.println("11+3+9=" + b.func2(11, 3));
    }
}

class A {
    public int func1(int num1, int num2) {
        return num1 - num2;
    }
}

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

    public int func2(int a, int b) {
        return func1(a, b) + 9;
    }
}

错误的结果

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

 具体实现  原来父类 子类 都继承一个基类  去掉原来继承关系   采用组合的关系替代

package com.wf.zhang.Liskov.improve;

public class Liskov {

    public static void main(String[] args) {

        A a = new A();
        System.out.println("11-3=" + a.func1(11, 3));
        System.out.println("1-8=" + a.func1(1, 8));
        System.out.println("-----------------------");
        B b = new B();
        /***
         *    A类   B类 (没有继承关系) 
         * B类中的func1方法  就是 重写的两数之和
         */
        System.out.println("11+3=" + b.func1(11, 3));
        System.out.println("1+8=" + b.func1(1, 8));
        System.out.println("11+3+9=" + b.func2(11, 3));
        
        /**
         * 在B中组合A(组合关系)
         * 仍然需要使用A的方法  求得两数之差
         * 调用func3
         */
        System.out.println("11-3=" + b.func3(11, 3));
    }
}
/**
 * 建立基类   A类   B类 (没有继承关系)  都继承 基类
 *
 */
class Base{
    
}


class A extends Base{
    public int func1(int num1, int num2) {
        return num1 - num2;
    }
}

class B extends Base {
    //需要使用A的方法  在B中组合A(组合关系)
    private A a = new A();
    
    public int func1(int a, int b) {
        return a + b;
    }

    public int func2(int a, int b) {
        return func1(a, b) + 9;
    }
    //新建func3  使用A的方法
    public int func3(int a, int b) {
        return this.a.func1(a, b);
    }
}

正确结果