里氏替換原則，OCP作為OO的高層原則，主張使用“抽象(Abstraction)”和“多態(Polymorphism)”將設計中的靜態結構改為動態結構，維持設計的封閉性。“抽象”是語言提供的功能。“多態”由繼承語義實現。

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

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

如果你覺得定義說的模糊了點，不太清楚，沒關系，我們慢慢說明白。里氏替換原則的另一個簡短的定義是“所有引用基類的地方必須能透明地使用其子類的對象”。這個可能更清楚點。如果你熟悉的掌握一門面向對象的語言，你應該都可以明白面向對象的繼承，子類繼承自父類的話，自然的就會繼承父類的所有方法（當然前提是父類不要把方法聲明為PRivate）。

在面向對象中，繼承有很多優點：

1代碼共享，減少創建類的工作量，每個子類都擁有父類的方法和屬性；

2提高代碼的重用性；

3子類可以形似父類，但又異于父類，“龍生龍，鳳生鳳，老鼠生來會打洞”是說子擁有父的“種”，“世界上沒有兩片完全相同的葉子”是指明子與父的不同；

4提高代碼的可擴展性，實現父類的方法就可以“為所欲為”了，君不見很多開源框架的擴展接口都是通過繼承父類來完成的；

5提高產品或項目的開放性。

而里氏替換原則希望，你在寫一個類繼承自原有的類的同時，盡量不要去更改原有的方法。話說那么多，那么肯定會有疑問。

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

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

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

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

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

class A{    public int func1(int a, int b){        return a-b;    }}public class Client{    public static void main(String[] args){        A a = new A();        System.out.println("100-50="+a.func1(100, 50));        System.out.println("100-80="+a.func1(100, 80));    }}

運行結果：

100-50=50100-80=20

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

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

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

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)+100;    }}public class Client{    public static void main(String[] args){        B b = new B();        System.out.println("100-50="+b.func1(100, 50));        System.out.println("100-80="+b.func1(100, 80));        System.out.println("100+20+100="+b.func2(100, 20));    }}

類B完成后，運行結果：

100-50=150100-80=180100+20+100=220

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

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

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

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

后果就是：你寫的代碼出問題的幾率將會大大增加。

轉載于http://blog.csdn.net/zhengzhb/article/details/7281833