肯定有不少人跟我剛看到這項原則的時候一樣，對這個原則的名字充滿疑惑。其實原因就是這項原則最早是在1988年，由麻省理工學院的一位姓裡的女士（Barbara Liskov）提出來的。

定義1：如果對每一個型別為 T1的物件 o1，都有型別為 T2 的物件o2，使得以 T1定義的所有程式 P 在所有的物件 o1 都代換成 o2 時，程式 P 的行為沒有發生變化，那麼型別 T2 是型別 T1 的子型別。

定義2：所有引用基類的地方必須能透明地使用其子類的物件。

問題由來：有一功能P1，由類A完成。現需要將功能P1進行擴充套件，擴充套件後的功能為P，其中P由原有功能P1與新功能P2組成。新功能P由類A的子類B來完成，則子類B在完成新功能P2的同時，有可能會導致原有功能P1發生故障。

解決方案：當使用繼承時，遵循里氏替換原則。類B繼承類A時，除新增新的方法完成新增功能P2外，儘量不要重寫父類A的方法，也儘量不要過載父類A的方法。

         繼承包含這樣一層含義：父類中凡是已經實現好的方法（相對於抽象方法而言），實際上是在設定一系列的規範和契約，雖然它不強制要求所有的子類必須遵從這些契約，但是如果子類對這些非抽象方法任意修改，就會對整個繼承體系造成破壞。而里氏替換原則就是表達了這一層含義。

        繼承作為面向物件三大特性之一，在給程式設計帶來巨大便利的同時，也帶來了弊端。比如使用繼承會給程式帶來侵入性，程式的可移植性降低，增加了物件間的耦合性，如果一個類被其他的類所繼承，則當這個類需要修改時，必須考慮到所有的子類，並且父類修改後，所有涉及到子類的功能都有可能會產生故障。

        舉例說明繼承的風險，我們需要完成一個兩數相減的功能，由類A來負責。

1. class A{  
2.     publicint func1(int a, int b){  
3.         return a-b;  
4.     }  
5. }  
6. publicclass Client{  
7.     publicstaticvoid main(String[] args){  
8.         A a = new A();  
9.         System.out.println("100-50="+a.func1(100, 50));  
10.         System.out.println("100-80="
    +a.func1(100, 80));  
11.     }  
12. }  

 執行結果：

100-50=50
100-80=20

        後來，我們需要增加一個新的功能：完成兩數相加，然後再與100求和，由類B來負責。即類B需要完成兩個功能：

• 兩數相減。
• 兩數相加，然後再加100。

        由於類A已經實現了第一個功能，所以類B繼承類A後，只需要再完成第二個功能就可以了，程式碼如下：

1. class B extends A{  
2.     publicint func1(int a, int b){  
3.         return a+b;  
4.     }  
5.     publicint func2(int a, int b){  
6.         return func1(a,b)+100;  
7.     }  
8. }  
9. publicclass Client{  
10.     publicstaticvoid main(String[] args){  
11.         B b = new B();  
12.         System.out.println("100-50="+b.func1(100, 50));  
13.         System.out.println("100-80="+b.func1(100, 80));  
14.         System.out.println("100+20+100="+b.func2(100, 20));  
15.     }  
16. }  

類B完成後，執行結果：

100-50=150
100-80=180
100+20+100=220

        我們發現原本執行正常的相減功能發生了錯誤。原因就是類B在給方法起名時無意中重寫了父類的方法，造成所有執行相減功能的程式碼全部呼叫了類B重寫後的方法，造成原本執行正常的功能出現了錯誤。在本例中，引用基類A完成的功能，換成子類B之後，發生了異常。在實際程式設計中，我們常常會通過重寫父類的方法來完成新的功能，這樣寫起來雖然簡單，但是整個繼承體系的可複用性會比較差，特別是運用多型比較頻繁時，程式執行出錯的機率非常大。如果非要重寫父類的方法，比較通用的做法是：原來的父類和子類都繼承一個更通俗的基類，原有的繼承關係去掉，採用依賴、聚合，組合等關係代替。

        里氏替換原則通俗的來講就是：子類可以擴充套件父類的功能，但不能改變父類原有的功能。它包含以下4層含義：

• 子類可以實現父類的抽象方法，但不能覆蓋父類的非抽象方法。
• 子類中可以增加自己特有的方法。
• 當子類的方法過載父類的方法時，方法的前置條件（即方法的形參）要比父類方法的輸入引數更寬鬆。
• 當子類的方法實現父類的抽象方法時，方法的後置條件（即方法的返回值）要比父類更嚴格。

        看上去很不可思議，因為我們會發現在自己程式設計中常常會違反里氏替換原則，程式照樣跑的好好的。所以大家都會產生這樣的疑問，假如我非要不遵循里氏替換原則會有什麼後果？

        後果就是：你寫的程式碼出問題的機率將會大大增加。