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

里氏替换原则

首先，OO（Object Oriented：面向对象）中的继承性的思考和说明：

1. 继承包含这样一层含义：父类中凡是已经实现好的方法，实际上是在设定规范和契约，虽然它不强制要求所有的子类必须遵循这些契约，但是如果子类对这些已经实现的方法任意修改，就会对整个继承体系造成破坏

2. 继承在给程序设计带来便利的同时，也带来了弊端。比如使用继承会给程序带来侵入性，程序的可移植性降低，增加对象间的耦合性，如果一个类被其他的类所继承，则当这个类需要修改时，必须考虑到所有的子类，并且父类修改后，所有涉及到子类的功能都有可能产生故障

3. 问题提出：在编程中，如何正确的使用继承？=> 里氏替换原则

基本介绍：

       里氏替换原则主要阐述了有关继承的一些原则，也就是什么时候应该使用继承，什么时候不应该使用继承，以及其中蕴含的原理。里氏替换原是继承复用的基础，它反映了基类与子类之间的关系，是对开闭原则的补充，是对实现抽象化的具体步骤的规范。

1. 里氏替换原则（Liskov Substitution Principle）在1988年，由麻省理工学院的以为姓里的女士提出的

2. 如果对每个类型为T1的对象o1，都有类型为T2的对象o2，使得以T1定义的所有程序P在所有的对象o1都代换成o2时，程序P的行为没有发生变化，那么类型T2是类型T1的子类型。换句话说，所有引用基类的地方必须能透明地使用其子类的对象

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

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

里氏替换的作用：

里氏替换原则的主要作用如下：

1. 里氏替换原则是实现开闭原则的重要方式之一
2. 它克服了继承中重写父类造成的可复用性变差的缺点
3. 它是动作正确性的保证。即类的扩展不会给已有的系统引入新的错误，降低了代码出错的可能性

里氏替换的实现方法：

1. 里氏替换原则通俗来讲就是：子类可以扩展父类的功能，但不能改变父类原有的功能。也就是说：子类继承父类时，除添加新的方法完成新增功能外，尽量不要重写父类的方法
2. 如果通过重写父类的方法来完成新的功能，这样写起来虽然简单，但是整个继承体系的可复用性会比较差，特别是运用多态比较频繁时，程序运行出错的概率会非常大
3. 如果程序违背了里氏替换原则，则继承类的对象在基类出现的地方会出现运行错误。这时其修正方法是：取消原来的继承关系，重新设计它们之间的关系

一个程序引出的问题和思考：

package com.atguigu.principle.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();
        // 这里本意是求出 11-3
        System.out.println("11-3=" + b.func1(11, 3));
        // 1-8
        System.out.println("1-8=" + b.func1(1, 8));
        System.out.println("11+3+9=" + b.func2(11, 3));
    }
}

// A类 
class A {

    // 返回两个数的差
    public int func1(int num1, int num2) {
        return num1 - num2; 
    }
}

// B 类继承了 A
// 增加了一个新功能：完成两个数相加，然后和 9 求和 
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. 我们发现原来运行正常的相减功能发生了错误。原因就是类B不小心重写了父类的方法，造成原有功能出现错误。在实际编程中，我们常常会通过重写父类的方法完成新的功能，这样写起来虽然简单，但整个继承体系的复用性会比较差。特别是运行多态比较频繁的时候
2. 通用的做法是：原来的父类和子类都继承一个更通俗的基类，原有的继承关系去掉，采用依赖，聚合，组合等关系代替
3. 改进方案：

代码实现：

package com.atguigu.principle.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();
        // 因为 B 类不再继承 A 类，因此调用者，不会再 func1 是求减法 
        // 调用完成的功能就会很明确
        // 这里本意是求出 11+3
        System.out.println("11+3=" + b.func1(11, 3));
        // 1+8 
        System.out.println("1+8=" + b.func1(1, 8));
        System.out.println("11+3+9=" + b.func2(11, 3));
        // 使用组合仍然可以使用到 A 类相关方法
        // 这里本意是求出 11-3
        System.out.println("11-3=" + b.func3(11, 3));
    }
}

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

// A类
class A extends Base {

    // 返回两个数的差
    public int func1(int num1, int num2) {
        return num1 - num2; 
    }
}

// B 类继承了 A
// 增加了一个新功能：完成两个数相加，然后和 9 求和 
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); 
    }
}

 

部分引用：http://c.biancheng.net/view/1324.html