繼承

繼承主要實現重用代碼，來節省開發時間。

1 繼承基本概念

一個類B繼承一個類A，被繼承的類A稱為 父類、基類、超類，繼承的類B稱為 子類、派生類。

• 子類會繼承父類的所有成員
• 子類擁有父類的所有特征和行為
• 子類可以有自己的特征行為
• C#中允許子類和父類存在同名的成員，但不建議使用

特點：

• 單根性 子類只能有一個父類，不能多繼承
• 傳遞性 子類可以間接繼承父類的父類

1.1 基本語法

class Teacher
{
    public string name;
    public int number;

    public void SpeakName()
    {
        Console.WriteLine(name);
    }
}

class TeachingTeacher : Teacher
{
    public string subject;//科目

    public void SpeakSubject()
    {
        Console.WriteLine($"我是{subject}老師");
    }
}

class ChineseTeacher : TeachingTeacher
{
    public void Skill()
    {
        Console.WriteLine("餘幼時即嗜學");
    }
}

1.2 使用

TeachingTeacher tt = new TeachingTeacher();
tt.name = "abc";
tt.number = 1;
tt.SpeakName();
tt.subject = "C#";
tt.SpeakSubject();

ChineseTeacher ct = new ChineseTeacher();
ct.name = "def";
ct.number = 2;
ct.SpeakName();
ct.subject = "Chinese";
ct.SpeakSubject();
ct.Skill();

2 里氏替換原則

里氏替換原則（Liskov Substitution principle）：子類可以擴展父類的功能,但不能改變父類原有的功能，是面向對象七大原則中最重要的原則。
概念：任何父類出現的地方，子類都可以替代
重點：語法表現一父類容器裝子類對象,因為子類對象包含了父類的所有內容
作用：方便進行對象存儲和管理

2.1 基本語法

class GameObject
{

}

class Player : GameObject
{
    public void PlayerAttack()
    {
        Console.WriteLine("玩家攻擊");
    }
}

class Monster : GameObject
{
    public void MonsterAttack()
    {
        Console.WriteLine("怪物攻擊");
    }
}

class Boss : GameObject
{
    public void BossAttack()
    {
        Console.WriteLine("Boss攻擊");
    }
}

//Main
//里氏替換原則 用父類容器裝載子類對象
GameObject p = new Player();
GameObject m = new Monster();
GameObject b = new Boss();

2.2 is 和 as

is：判斷一個對象是否為指定對象，返回：bool，是為真，不是為假

as：將一個對象轉換為指定類對象，返回：成功返回指定類對象，失敗返回null

基本語法：

• 類對象 is 類名，語句返回真或假
• 類對象 as 類名，語句返回對象或null

if(p is Player)
{
    Player p1 = p as Player;
    p1.PlayerAttack();
}

3 繼承的構造函數

3.1 基本概念

子類聲明子類對象時，先執行父類的構造函數，再執行子類的構造函數。

• 父類的無參構造很重要，有參構造函數會自動頂掉無參構造函數，若寫了有參構造，則最好還要寫無參構造
• 子類可以通過base關鍵字代表父類調用父類構造函數
• 構造函數執行順序：父類的父類的構造函數——父類的構造函數——子類的構造函數

class GameObject
{
    public GameObject()
    {
        Console.WriteLine("GameObject的構造函數");
    }
}
class Player : GameObject
{
    public Player()
    {
        Console.WriteLine("Player的構造函數");
    }
}
class MainPlayer : Player
{
    public MainPlayer()
    {
        Console.WriteLine("MainPlayer的構造函數");
    }
}

//Main
MainPlayer mp = new MainPlayer();
/*
輸出：
GameObject的構造函數
Player的構造函數
MainPlayer的構造函數
*/
Father構造
Son一個參數構造
Son兩個個參數構造

3.2 base關鍵字

通過 base(參數) 可以調用指定父類構造。

class Father
{
    /*public Father()
    {

    }*/
    public Father(int i)//有參構造函數會自動頂掉無參構造函數
    {
        Console.WriteLine("Father構造");
    }
}
//子類實例化時預設先調用父類的無參構造，如果父類無參構造被頂掉，就會報錯
class Son : Father
{
    //通過base改變預設調用父類的無參構造，指定為有參構造
    public Son(int i) : base(i)
    {
        Console.WriteLine("Son一個參數構造");
    }

    public Son(int i, string str) : this(i)//this(i)表示調用一個參數的構造函數public Son(int i) : base(i){}
    {
        Console.WriteLine("Son兩個個參數構造");
    }
}

//Main
Son s = new Son(1, "123");
/*
輸出：
Father構造
Son一個參數構造
Son兩個個參數構造
*/

4 object 和裝箱拆箱

4.1 object

object 是所有類型的父類，它是一個類（引用類型）。

作用：

• 利用里氏替換原則，用object容器裝所有對象
• 表示不確定類型，作為函數參數類型

4.2 使用

class Father
{

}

class Son : Father
{
    public void Speak()
    {

    }
}

//Main
Father f = new Son();//用父類容器裝載子類
if(f is Son)
{
    (f as Son).Speak();
}

//用object裝載萬物，然後轉換成所需類型來使用
//1、引用類型
object o = new Son();
//用is和as來判斷和轉換即可
if(o is Son)
{
    (o as Son).Speak();
}

//2、值類型
object o2 = 1f;
//用強轉
float fl = (float)o2;

//特殊string類型
object str = "123";
string str2 = str as string;

//數組
object arr = new int[10];
int[] ar = arr as int[];

4.3 裝箱和拆箱

• 裝箱：用object來存值類型，即值類型轉換為object類型 ，棧記憶體會遷移到堆記憶體中
• 拆箱：再把object轉為值類型 ，堆記憶體會遷移到棧記憶體中
• 好處：不確定類型時可以方便參數的存儲和傳遞
• 壞處：存在記憶體遷移，增加性能消耗

object v = 3;//裝箱
int a = (int)v;//拆箱

5 sealed 密封類

• 使用 sealed 關鍵字修飾的類，讓類無法被繼承
• 在面向對象程式的設計中，密封類的主要作用就是不允許最底層子類被繼承，可以保證程式的規範性、安全性

sealed class Father
{

}

class Son : Father//報錯，無法繼承
{

}