里氏替换原则

Posted on Edited on Views:

里氏替换原则

Liskov Substitution Principle

  • 里氏替换原则在1988年，由麻省理工学院的一位姓里的女士提出的。

  • 如果对每个类型为T1的对象o1，都有类型为T2的对象o2，使得以T1定义的所有程序P在所有的对象o1都代换成o2时，程序P的行为没有发生变化，那么类型T2是类型T1的子类型。所有引用基类的地方必须能透明地使用其子类的对象。换句话说，既然抽象出来当作共同的实现方法就不应再具体实现类中重写。

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

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

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    //A类
    class A{
        //返回两个数的差
        public in func1(int num1,int num2){
            return num1 - num2;
        }
    }
    //B类继承了A类
    class B extends A{
        //    ↓重写了A的方法
        public int func1(int a,int b){
            return a + b;
        }
        public int func2(int a,int b){
            return func1(a,b)+9;
        }
    }

    改进：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    class Base{
        //把更加基础的方法和成员写到Base类
    }

    //A类
    class A extends Base{
        //返回两个数的差
        public in func1(int num1,int num2){
            return num1 - num2;
        }
    }
    //B类继承了A类
    class B extends Base{
        //如果B需要使用A类的方法，使用组合关系
        private A a = new A();
        //    ↓重写了A的方法
        public int func1(int a,int b){
            return a + b;
        }
        public int func2(int a,int b){
            return func1(a,b)+9;
        }
        
        //使用A的方法
        public int func3(int a,int b){
            return this.a.func1(a,b);
        }
    }