官方定義：程序中的對象應該是可以在不改變程序正確性的前提下被它的子類所替換，也就是說所有引用基類的地方必須能透明地使用其子類的對象。通俗的來說，子類可以擴展父類的功能，但不能改變父類原有的功能。

自己理解：一個實體類如果使用的是一個父類的話，那麽一定適用於子類，在程序裏面把父類替換成他的子類，程序的行為沒有發生變化。

實例：

聲明兩個類，Numbers類寫一個加法的方法，Number寫一個減法的方法，Number繼承Numbers

 class Numbers
    {
        public int NumberSum(int a, int b)
        {
            
 
return a + b;
        }
    }

    class Number : Numbers
    {
        public int Subtraction(int a, int b)
        {
            return a - b;
        }
    }

直接調用父類

 class Program
    {
        static void Main(string[] args)
        {
            Numbers n = new Numbers();
            Console.WriteLine(n.NumberSum(
 
1,3));
        }
    }

結果等於4

裏氏替換原則，父類替換成子類，不改變結果：

 class Program
    {
        static void Main(string[] args)
        {
            Number n = new Number();
            Console.WriteLine(n.NumberSum(1,3));
        }
    }

結果沒有發生變化，輸出為4

個人總結：裏氏替換就是父類替換子類，不會不會改變原有的程序，這是學習繼承就要理解的概念，子類繼承了父類，子類就以父類的身份出現。

開閉原則：軟件實體，應該擴展而不是修改。

個人理解：這個也很好理解，其實就是面向對象的思想，拿之前計算器的例子來說，如果你把所有的運算寫在一個類裏面，將來改需求的時候，就要去改變整個類，不靈活

實例：

/// <summary>
    /// 運算類
    /// </summary>
    public class Operation
    {
        private double _numberA = 0;
        private double _numberB = 0;

        public double numberA
        {
            get { return _numberA; }
            set { _numberA = value; }
        }
        public double numberB
        {
            get { return _numberB; }
            set { _numberB = value; }
        }
        //虛方法（用於得到結果）
        public virtual double GetResult()
        {
            double result = 0;
            return result;
        }
    }

    /// <summary>
    /// 加法類
    /// </summary>
    class opearAdd: Operation
    {
        public override double GetResult()
        {
            double result = 0;
            result = numberA + numberB;
            return result;
        }
    }
   
    /// <summary>
    /// 減法類
    /// </summary>
    class opearSub : Operation
    {
        public override double GetResult()
        {
            double result = 0;
            result = numberA - numberB;
            return result;
        }
    }
    /// <summary>
    /// 乘法類
    /// </summary>
    class opearMui : Operation
    {
        public override double GetResult()
        {
            double result = 0;
            result = numberA * numberB;
            return result;
        }
    }

    /// <summary>
    /// 除法類
    /// </summary>
    class opearDiv : Operation
    {
        public override double GetResult()
        {
            double result = 0;
            if (numberB == 0)
            {
                throw new Exception("除數不能為0");
            }
            result = numberA / numberB;
            return result;
        }
    }

根據不用的運算符調用不同的實例

    /// <summary>
    /// 運算工廠
    /// </summary>
    public class OperationFactory
    {
        public static Operation creaoperation(string operate)
        {
            Operation oper = null;
            switch (operate)
            {
                case "+":
                    oper = new opearAdd();
                    break;
                case "-":
                    oper = new opearAdd();
                    break;
                case "*":
                    oper = new opearAdd();
                    break;
                case "/":
                    oper = new opearAdd();
                    break;
            }
            return oper;
        }
    }

開閉原則應該是面向對象的核心，遵循這個原則可以帶來維護復用的很多好處。

裏氏替換/開閉原則