里氏替換原則(Liskov Substitution Principle)在1988年，由麻省理工學院的以為姓里的女士提出的。
如果對每個類型為Tl的對象o1，都有類型為T2的對象o2，使得以Tl定義的所有程序Р在所有的對象o1都代換成o2時，程序Р的行為沒有發(fā)生變化，那么類型T2是類型TI的子類型。換句話說，所有引用基類的地方必須能透明地使用其子類的對象。
在使用繼承時，遵循里氏替換原則，在子類中盡量不要重寫父類的方法。
里氏替換原則告訴我們，繼承實際上讓兩個類耦合性增強了，在適當?shù)那闆r下，可以通過聚合，組合，依賴來解決問題。

2.代碼案例

package com.szh.principle.liskov;
 
/**
 *
 */
// A類
class A {
    // 返回兩個數(shù)的差
    public int func1(int num1, int num2) {
        return num1 - num2;
    }
}
 
// B類繼承了A
// 增加了一個新功能：完成兩個數(shù)相加,然后和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;
    }
}
 
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();
        System.out.println("11-3=" + b.func1(11, 3));  //這里本意是求出11-3
        System.out.println("1-8=" + b.func1(1, 8));    //這里本意是求出1-8
        System.out.println("11+3+9=" + b.func2(11, 3));
    }
}

從代碼運行結果中看到，有兩行出了問題，這是因為B繼承A之后，并且重寫了func1方法，那么此時就不會再去執(zhí)行A類的func1方法了，而是執(zhí)行B自己的func1方法，而B中func1方法的邏輯是對兩個數(shù)求和，所以這里你以為的就不再是你以為的了。

3.改進代碼

我們發(fā)現(xiàn)原來運行正常的相減功能發(fā)生了錯誤。原因就是類B無意中重寫了父類的方法，造成原有功能出現(xiàn)錯誤。在實際編程中，我們常常會通過重寫父類的方法完成新的功能，這樣寫起來雖然簡單，但整個繼承體系的復用性會比較差。特別是運行多態(tài)比較頻繁的時候。

通用的做法是: 原來的父類和子類都繼承一個更通俗的基類，原有的繼承關系去掉，采用依賴，聚合，組合等關系代替。

package com.szh.principle.liskov.improve;
 
/**
 *
 */
//創(chuàng)建一個更加基礎的基類
class Base {
    //把更加基礎的方法和成員寫到Base類
}
 
// A類
class A extends Base {
    // 返回兩個數(shù)的差
    public int func1(int num1, int num2) {
        return num1 - num2;
    }
}
 
// B類繼承了A
// 增加了一個新功能：完成兩個數(shù)相加,然后和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);
    }
}
 
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方法是求減法
        //調用完成的功能就會很明確
        System.out.println("11+3=" + b.func1(11, 3));//這里本意是求出11+3
        System.out.println("1+8=" + b.func1(1, 8));//這里本意是求出1+8
        System.out.println("11+3+9=" + b.func2(11, 3));
        //使用組合仍然可以使用到A類相關方法
        System.out.println("11-3=" + b.func3(11, 3));// 這里本意是求出11-3
    }
 
}

此時我們創(chuàng)建一個更基礎的Base類，讓A和B都繼承這個類，如果還想像之前那樣在B中使用A，那么就采用組合來解決，即在B類中聲明一個私有的A類成員變量就可以了。