物件導向設計原則:SOLID

• 單一職責原則（Single Responsibility Principle）
• 里氏替換原則（Liskov Substitution Principle）
• 依賴反轉原則（Dependence Inversion Principle）
• 介面隔離原則（Interface Segregation Principle）
• 最少知識原則(得墨忒耳定律)（Law Of Demeter）
• 開放封閉原則(Open Closed Principle)

單一職責原則（Single Responsibility Principle)

原文定義：A class should have only one reason to change.

中文翻譯：一個模組應有且只有一個理由會使其改變。

 public class SRPShow
    {
        public static void Show()
        {
            {
                Animal animal = new AnimalChicken("雞");
                animal.Breath();
                animal.Action();
            }
            {
                Animal animal = new AnimalFish("魚");//呼吸水
                animal.Breath();
                animal.Action();
            }
        }
    }

/// <summary>
/// 封裝
/// 動物類別
/// 簡單意味者穩定
/// 
/// 都塞在一起，多個職責都在一起
/// </summary>
public  class Animal
{
    protected string _Name = null;
    public Animal(string name)
    {
        this._Name = name;
    }
    public void Breath()
    {
        if (this._Name.Equals("雞"))
        {
            Console.WriteLine($"{this._Name} 呼吸空气");
        }
        else if (this._Name.Equals("鱼"))
        {
            Console.WriteLine($"{this._Name} 呼吸水");
        }
    }
    //好多分支，好多固定分支，好多if else  三套東西
    //違背單一職責：一個類只做一件事，，一個方法也應該只做一件事
    public void Action()
    {
        if (this._Name.Equals("雞"))
        {
            Console.WriteLine($"{this._Name} flying");
        }
        else if (this._Name.Equals("魚"))
        {
            Console.WriteLine($"{this._Name} swimming");
        }
    }
}

public class SRPShow
    {
        public static void Show()
        {
            {
                Animal animal = new AnimalChicken("雞");
                animal.Breath();
                animal.Action();
            }
            {
                Animal animal = new AnimalFish("魚");//呼吸水
                animal.Breath();
                animal.Action();
            }
        }
    }
public abstract class Animal
{
    protected string _Name = null;
    public Animal(string name)
    {
        this._Name = name;
    }
    public abstract void Breath();
    public abstract void Action();
}

/// <summary>
/// 每個類都在做自己的事
/// </summary>
public class AnimalChicken : Animal
{
    public AnimalChicken(string name) : base(name)
    {
    }
    public override void Breath()
    {
        Console.WriteLine($"{this._Name} 呼吸空气");
    }
    public override void Action()
    {
        Console.WriteLine($"{this._Name} flying");
    }
}

/// <summary>
/// 封裝
/// 動物類別
/// 簡單意味者穩定
/// </summary>
public class AnimalFish : Animal
{
    public AnimalFish(string name) : base(name)
    {
    }
    public override void Breath()
    {
        Console.WriteLine($"{this._Name} 呼吸水");
    }
    public override void Action()
    {
        Console.WriteLine($"{this._Name} swimming");
    }
}

◀結論:

里氏替換原則（Liskov Substitution Principle）

原文定義：Subtypes must be substitutable for their base types.

中文翻譯：子類別必須要能取代它的父類別。

白話文：父類別出現的地方，子類別就能代替它，而且要能做到替換而不出現任何錯誤或異常。

▶情境:

    public class People
    {
        public int Id { get; set; }
        public string Name { get; set; }
        public void Traditional()
        {
            Console.WriteLine("仁義禮智信 溫良恭儉讓");
        }
        public void Show()
        { }
    }

    public class Chinese : People
    {
        public string Kuaizi { get; set; }
        public void SayHi()
        {
            Console.WriteLine("早上好，吃了嗎？");
        }
    }

    /// <summary>
    /// 擁有大部分的屬性和行為，但是Traditional没有
    /// </summary>
    public class Japanese : People
    {
        public int Id { get; set; }
        public string Name { get; set; }
        public new void Traditional()
        {
            throw new Excrption();
        }
        public void Ninja()
        {
            Console.WriteLine("忍者精神");
        }
    }

    public class LSPShow
    {
        public static void Show()
        {
            {
                Chinese people = new Chinese();
                people.Traditional();
            }
            {
                Chinese people = new Japanese();
                people.Traditional();
            }
        }
    }

ParentClass instance = new ChildClass();
ChildClass child = new ChildClass();
Console.WriteLine("下面是instance.CommonMethod()");
instance.CommonMethod();//『A』
typeof(ParentClass).GetMethod("CommonMethod").Invoke(instance, null);//『B』
typeof(ChildClass).GetMethod("CommonMethod").Invoke(instance, null);//『C』   
dynamic dInstance = new ChildClass();
dInstance.CommonMethod();//『D』
Console.WriteLine("下面是instance.VirtualMethod()");
instance.VirtualMethod();//『E』
Console.WriteLine("下面是instance.AbstractMethod()");
instance.AbstractMethod();//『F』

    public abstract class ParentClass
    {
        /// <summary>
        /// CommonMethod
        /// </summary>
        public void CommonMethod()
        {
            Console.WriteLine("ParentClass CommonMethod");
        }
        /// <summary>
        /// virtual  虛方法  必須包含實作 但是可以被重載
        /// </summary>
        public virtual void VirtualMethod()
        {
            Console.WriteLine("ParentClass VirtualMethod");
        }
        public virtual void VirtualMethod(string name)
        {
            Console.WriteLine("ParentClass VirtualMethod");
        }
        public abstract void AbstractMethod();
    }
    public class ChildClass : ParentClass
    {
        /// <summary>
        /// new 隱藏父類
        /// </summary>
        public new void CommonMethod()
        {
            Console.WriteLine("ChildClass CommonMethod");
        }
        /// <summary>
        /// virtual 可以被複寫
        /// </summary>
        /// <param name="obj"></param>
        /// <returns></returns>
        public override void VirtualMethod()
        {
            Console.WriteLine("ChildClass VirtualMethod");
            base.VirtualMethod();
        }
        public sealed override void AbstractMethod()
        {
            Console.WriteLine("ChildClass AbstractMethod");
        }
    }

答案:

『A』父類=>普通方法由左邊决定，編譯時决定

『B』父類

『C』子類

『D』子類=>運行時決定

『E』子類=>虛方法由右邊决定，運行時決定

『F』子類=>抽象方法由右邊决定，運行時決定

◀結論:

• 子類必須完全實作父類別所有的方法,如果子類沒有父類的某項東西，就斷掉繼承；
• 子類可以有父類沒有的東西，所以子類的出現的地方，不一定能用父類來代替；
• 透明，就是安全，父類的東西換成子類后不影響程序
• 父類已經實做的東西，子類不要去new
• 父類已經實做的東西，想改的话，就必須用virtual+override 避免埋雷

最少知識原則(得墨忒耳定律)（Law Of Demeter）

原文定義：Each unit should have only limited knowledge about other units: only units "closely" related to the current unit.

中文翻譯：每個單元應該對其他單元只能有有限的知識：只了解跟目前單元比較親近的單元。

白話文: 單元與單元之間是會有耦合的。這個原則在告訴我們該如何控制耦合的程度。

▶情境:

    /// <summary>
    /// 學校
    /// </summary>
    public class School
    {
        public int Id { get; set; }
        public string SchoolName { get; set; }
        public List<Class> ClassList { get; set; }
        public void Manage()
        {
            Console.WriteLine("Manage {0}", this.GetType().Name);
            foreach (Class c in this.ClassList)
            {
                Console.WriteLine(" {0}Manage {1} ", c.GetType().Name, c.ClassName);
                c.Manage();//『A』
                //List<Student> studentList = c.StudentList;//『B』
                //foreach (Student s in studentList)
                //{
                //    Console.WriteLine(" {0}Manage {1} ", s.GetType().Name, s.StudentName);
                //}
            }
        }
    }

    /// <summary>
    /// 班級
    /// </summary>
    public class Class
    {
        public int Id { get; set; }
        public string ClassName { get; set; }
        public List<Student> StudentList { get; set; }
        public void Manage()
        {
            foreach (Student s in this.StudentList)
            {
                Console.WriteLine(" {0}Manage {1} ", s.GetType().Name, s.StudentName);
            }
        }
    }

    /// <summary>
    /// 學生
    /// </summary>
    public class Student
    {
        public int Id { get; set; }
        public string StudentName { get; set; }
        protected int Tall { get; set; }
        private int Salary { get; set; }
    }

◀結論:

依賴反轉原則（Dependence Inversion Principle）

原文定義：

- High-level modules should not depend on low-level modules. Both should depend on abstractions.

- Abstractions should not depend on details. Details should depend on abstractions.

中文翻譯：

- 高層模組不應該依賴底層模組，它們都應該依賴抽象。

- 抽象不應該依賴細節。細節應該依賴抽象。

▶情境:

//Student高層--手機低層
Student student = new Student()
{
    Id = 191,
    Name = "老司機"
};
AbstractPhone phone = new iPhone();
student.PlayiPhone(phone);
AbstractPhone phone = new Lumia();
student.PlayLumia(phone);
```
```csharp=
 public class Student
    {
        public int Id { get; set; }
        public string Name { get; set; }
        /// <summary>
        /// 依賴細節
        /// </summary>
        /// <param name="phone"></param>
        public void PlayiPhone(iPhone phone)
        {
            Console.WriteLine("這裡是{0}", this.Name);
            phone.Call();
            phone.Text();
        }
        /// <summary>
        /// 依賴細節
        /// </summary>
        /// <param name="phone"></param>
        public void PlayLumia(Lumia phone)
        {
            Console.WriteLine("這裡是{0}", this.Name);
            phone.Call();
            phone.Text();
        }
    }

    public abstract class AbstractPhone
    {
        public int Id { get; set; }
        public string Branch { get; set; }
        public abstract void Call();
        public abstract void Text();
    }

    /// <summary>
    /// iPhone
    /// </summary>
    public class iPhone : AbstractPhone
    {
        public override void Call()
        {
            Console.WriteLine("User {0} Call", this.GetType().Name);
        }
        public override void Text()
        {
            Console.WriteLine("User {0} Call", this.GetType().Name);
        }
    }
    public class Lumia : AbstractPhone
    {
        public override void Call()
        {
            Console.WriteLine("User {0} Call", this.GetType().Name);
        }
        public override void Text()
        {
            Console.WriteLine("User {0} Text", this.GetType().Name);
        }
    }

public class Student
    {
        public int Id { get; set; }
        public string Name { get; set; }
        /// <summary>
        /// 依赖抽象
        /// </summary>
        /// <param name="phone"></param>
        public void Play(AbstractPhone phone)
        {
            Console.WriteLine("這裡是{0}", this.Name);
            phone.Call();
            phone.Text();
        }
    }

◀結論:

介面隔離原則（Interface Segregation Principle）

原文定義：Clients should not be forced to depend on methods that they do not use.

中文翻譯：客戶不應該被強迫依賴他們不使用的方法

▶情境:

public abstract class AbstractPhone
{
    public int Id { get; set; }
    public string Branch { get; set; }
    public abstract void Call();
    public abstract void Text();
    public void Show()
    { }
}
public interface IExtend
{
    void Movie();
}
public interface IExtendGame
{
    void Online();
    void Game();
}
public interface IExtendPhotography//: IExtendGame 介面可以繼承介面 方法疊加
{
    void Photo();
    void Record();
}
public interface IExtendAdvanced
{
    void Show();
    void Map();//導航
    void Pay();
}

/// <summary>
    /// iPhone
    /// </summary>
    public class iPhone : AbstractPhone, IExtend, IExtendAdvanced, IExtendPhotography
    {
        //net框架有时候明明看到已经继承了某个接口，却找不到实现在哪里
        //實現在父類別
        public override void Call()
        {
            Console.WriteLine("User {0} Call", this.GetType().Name);
        }
        public override void Text()
        {
            Console.WriteLine("User {0} Call", this.GetType().Name);
        }
        public void Photo()//隐式实现
        {
            Console.WriteLine("User {0} Photo", this.GetType().Name);
        }
        //void IExtendAdvanced.Photo()//显示实现
        //{
        //    Console.WriteLine("User {0} Photo", this.GetType().Name);
        //}
        public void Online()
        {
            Console.WriteLine("User {0} Online", this.GetType().Name);
        }
        public void Game()
        {
            Console.WriteLine("User {0} Game", this.GetType().Name);
        }
        public void Map()
        {
            Console.WriteLine("User {0} Map", this.GetType().Name);
        }
        public void Pay()
        {
            Console.WriteLine("User {0} Pay", this.GetType().Name);
        }
        public void Record()
        {
            Console.WriteLine("User {0} Record", this.GetType().Name);
        }
        public void Movie()
        {
            Console.WriteLine("User {0} Movie", this.GetType().Name);
        }
    }

◀結論:

開放封閉原則(Open Closed Principle)

原文定義：Software entities (class, modules, functions, etc.) should be open for extension, but closed for modification.

中文翻譯：軟體實體應該對擴展開放，對修改關閉

◀結論: