第一節：開閉原則和里氏替換原則

一. 開閉原則

1. 定義

　對擴展開放，對修改關閉。(當應用的需求改變時，在不修改軟件實體的源代碼前提下，可以擴展模塊的功能，使其滿足新的需求。)

2. 作用

(1). 對軟件測試的影響

　軟件遵守開閉原則的話，軟件測試時只需要對擴展的代碼進行測試就可以了，因為原有的測試代碼仍然能夠正常運行。

(2). 可以提高代碼的可復用性

　粒度越小，被復用的可能性就越大；在面向對象的程序設計中，根據原子和抽象編程可以提高代碼的可復用性。

(3). 可以提高軟件的可維護性

　遵守開閉原則的軟件，其穩定性高和延續性強，從而易於擴展和維護

3. 實現方法和案例 

　可以通過“抽象約束、封裝變化”來實現開閉原則，即通過接口或者抽象類為軟件實體定義一個相對穩定的抽象層，而將相同的可變因素封裝在相同的具體實現類中。

　因為抽象靈活性好，適應性廣，只要抽象的合理，可以基本保持軟件架構的穩定。而軟件中易變的細節可以從抽象派生來的實現類來進行擴展，當軟件需要發生變化時，只需要根據需求重新派生一個實現類來擴展就可以了。

PS: 依賴倒置原則就是對開閉原則很好的實現。

類似的案例太多了，此處不單獨提供了。

 

二. 里氏替換原則

1. 定義

　子類可以擴展父類的功能，但不要改變父類原有的功能。也就是說：子類繼承父類時，除添加新的方法完成新增功能外，不要重寫父類已經實現了的方法(抽象方法除外)。

2. 作用

(1). 里氏替換原則是實現開閉原則的重要方式之一。

(2). 它避免了繼承中重寫父類造成的可復用性變差的缺點。

(3). 它是動作正確性的保證。即類的擴展不會給已有的系統引入新的錯誤，降低了代碼出錯的可能性。

3. 實現方法和案例

父類和子類

  /// <summary>
    /// 計算父類
    /// </summary>
    public class FatherCalculate
    {
        /// <summary>
        /// 計算兩個數相加
        /// </summary>
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// <returns></returns>
        public int Cal1(int a,int b)
        {
            return a + b;
        }

        /// <summary>
        /// 計算兩個數相加
        /// </summary>
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// <returns></returns>
        public double Cal2(double a, double b)
        {
            return a + b;
        }

        /// <summary>
        /// 計算兩個數相加
        /// </summary>
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// <returns></returns>
        public virtual int Cal3(int a, int b)
        {
            return a + b;
        }

        /// <summary>
        /// 計算兩個數相乘
        /// </summary>
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// <returns></returns>
        public int Cal4(int a, int b)
        {
            return a * b;
        }
    }
public class ChildCalculate2 : FatherCalculate
    {
        /// <summary>
        /// 計算兩個數相減
        /// </summary>
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// <returns></returns>
        public int Cal4(int a, int b)
        {
            return a - b;
        }
    }

測試

            {
                Console.WriteLine("--------------------------里氏替換--------------------------------");
                //父類中有加法和乘法運算
                //1.執行加法運算
                ChildCalculate1 c1 = new ChildCalculate1();
                //計算錯誤,違背了里氏替換原則，子類重寫了父類已經實現的方法,覆蓋了父類
                Console.WriteLine($"10+6={c1.Cal1(10, 6)}");    //4

                //2.執行加法運算
                FatherCalculate f1 = new ChildCalculate1();
                //走的是父類的方法
                Console.WriteLine($"10+6={f1.Cal1(10, 6)}");    //16

                //3. 執行加法運算
                FatherCalculate f2 = new ChildCalculate2();
                //走的是父類的方法 (滿足 里氏替換原則)
                Console.WriteLine($"10+6={f2.Cal1(10, 6)}");     //16

                //4. 執行加法運算
                ChildCalculate2 c2 = new ChildCalculate2();
                //走的是父類的方法，子類繼承父類的 
                Console.WriteLine($"10+6={c2.Cal1(10, 6)}");      //16

                //5. 執行減法運算
                //走的是子類的方法
                Console.WriteLine($"10-6={c2.Cal4(10, 6)}");     //4
            }

運行結果

 

 

補充說明：如果通過重寫父類的方法來完成新的功能，這樣寫起來雖然簡單，但是整個繼承體系的可復用性會比較差，特別是運用多態比較頻繁時，程序運行出錯的概率會非常大。

　　　　　如果程序違背了里氏替換原則，則繼承類的對象在基類出現的地方會出現運行錯誤。這時其修正方法是：取消原來的繼承關系，重新設計它們之間的關系。

 

 

 

 

!

• 作       者 : Yaopengfei(姚鵬飛)
• 博客地址 : http://www.cnblogs.com/yaopengfei/
• 聲     明1 : 如有錯誤，歡迎討論，請勿謾罵^_^。
• 聲     明2 : 原創博客請在轉載時保留原文鏈接或在文章開頭加上本人博客地址，否則保留追究法律責任的權利。