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

里氏替换原则

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

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

基本介绍
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);
    }
}

正确结果

来源：https://www.cnblogs.com/wf-zhang/p/12307646.html

标签

里氏替换原则

system