一、類
1.0對象初始化器
class Student
{public String name;public int age { get; set; }
}
internal class Program
{static void Main(string[] args){ //寫法一Student stu=new Student();stu.name="Tom";stu.age=20;//寫法二Student stu2 = new Student { name = "Tom", age = 20 };在 C# 中，?Student stu2 = new Student { name = "Tom", age = 20 }中的?{}?稱為對象初始化器（Object Initializer），它是 C# 3.0 引入的語法糖，用于在創建對象時使用鍵對值方式直接初始化對象的公共屬性或公共字段，簡化代碼書寫,等同于寫法一；
1.1構造器（構造函數）
特點：
與類同名，沒有返回值
不自己定義系統會生成一個默認的構造器，就是將給成員屬性賦該類型默認值
自己定義默認構造器會被覆蓋，而不是重載（因為無法再調用系統自動生成的構造器）
1.1.1實例構造器和靜態構造器
靜態構造器不能有修飾限定符
靜態構造器不能有參數
靜態構造器不能重載
class student{public int score { get; set; }public static int num { get; set; }//實例構造器public student(int score){this.score = score;num++;}//靜態構造器static student(){num = 100;}}1.1.2實例構造器和靜態構造器的調用時機
實例構造器
- 每次使用?
new?關鍵字創建類的實例時，必然會調用實例構造器（如果有多個重載，會根據new?后的參數匹配對應的構造器）。 - 若類有繼承關系，創建派生類實例時，會先調用基類的實例構造器，再調用派生類的實例構造器（確保基類的實例成員先初始化）
靜態構造器
靜態構造器是類被首次 “訪問” 時自動調用的方法，用于初始化類的靜態成員（靜態字段、靜態屬性等），與實例無關
- 首次創建該類的實例（
new實例時）。 - 首次訪問該類的靜態成員（靜態字段、靜態屬性、靜態方法）。
- 首次使用該類作為泛型類型參數（如?
List<MyClass>?首次被使用時，若?MyClass?未初始化則觸發其靜態構造器 - 類有繼承關系，基類的靜態構造器先于派生類的靜態構造器執行
1.2析構器（析構函數）
不加修飾限定符，使用（~類名）方式來定義函數
c#有資源回收器（GC），但是調用底層資源時有用
2、類的聲明
c#類的聲明和定義不分家
聲明位置
- 把類聲明在名稱空間中
- 也可以把類聲明在文件的名稱空間外，但是c#有一個global名稱空間，因此也在名稱空間內部（不推薦）
- 可以聲明在類中（成員類）
3、類的繼承和類成員的訪問控制
“是一個”規則：父類引用變量可以存儲子類實例的地址，含義為：car是一個vehicle? ?
static void Main(string[] args){vehicle v = new car();object o = new vehicle();object o1 = new car(); }}class vehicle
{}
class car : vehicle
{}- sealed關鍵字：封閉類，不能當作基類來使用，下例：編譯器報錯
- 一個類只能繼承一個基類
- 一個類可以實現多個基接口
- 子類的訪問級別不能超過基類
- 父類的構造器是不能被繼承的
3.2編譯器的調用規則
當創建子類實例時，父類的構造器先被啟動，作用是初始化子類中繼承的屬性的值，下例中我們可以看到car中沒有對owner進行賦值，但是任然可以輸出值vehicle，而如果子類構造器對他賦值了，那么會覆蓋這個結果。
static void Main(string[] args){car mycar = new car();Console.WriteLine(mycar.owner); }
}class vehicle
{ public vehicle() { this.owner = "vehilce";}public string owner { get; set; }}
class car : vehicle
{public car(){ }
}上例是父與子類構造函數無需參數情況，需要參數時需要使用base關鍵字，下例
class vehicle
{ public vehicle(string own) { this.owner = own;}public string owner { get; set; }}
class car : vehicle
{public car(string own):base(own){ }
}3.3類的訪問級別和類成員的關系
類成員的訪問級別的上限是類的訪問級別
類的默認訪問級別是internal，成員的默認訪問級別是private
protected：是可以跨程序集的，也就是說實際上，四種訪問級別并不是嚴格的大小關系
3.4類的重寫和多態
重寫就是對父類成員的版本更新
重寫需要父類成員對子類是可見的，即不能為private
需要重寫的父類類成員（字段除外），要加關鍵字virtual（標識為可重寫），子類類成員要加override
注意：我們使用父類的引用變量指向了子類的實例，這個方法調用的版本是由子類實例來決定的，在這時調用的重寫的方法是繼承鏈上最新的（到這個類），這就是多態，下例中將car的實例給到父類的引用變量，調用的是繼承鏈到car的最新函數。
static void Main(string[] args){vehicle c = new car();c.run();//運行結果為：I am driving}
}class vehicle
{public virtual void run(){Console.WriteLine("I am running");}
}
class car : vehicle
{ public override void run(){Console.WriteLine("I am driving");}
}
class racecar : car
{public override void run(){Console.WriteLine("I am racing");}
}3.5類的組合
在類的繼承中，我們提到了”是一個“原則，即car是子類，vehicle是父類，那么car是一個vehicle，同時父類引用變量可以指向子類的實例；類的組合是”有一個“原則，一個類完全可以將另一個類作為自己的屬性。
舉個栗子：
class people {public Address address { get; set; }}class Address { public string city { get; set; }}internal class Program{static void Main(string[] args){ //分別實例化兩個類people p=new people();Address a = new Address { city = "New York" };p.address = a;Console.WriteLine(p.address.city);//簡化寫法people p2 = new people { address=new Address { city="AAA" } };Console.WriteLine(p2.address.city);}}上面代碼定義了兩個類，people這個類直接使用Address作為他的屬性，在我們給people這個類賦值的時候，有兩種方式：
方式一：分別實例化兩個類，將a這個Address類的引用變量賦值給p.address。
方式二：直接嵌套兩個初始化器，在people的初始化器中給address創建一個實例，并且也使用初始化器。
二、抽象類和開閉原則
抽象類
含有抽象方法的類叫做抽象類（只要有一個就行），抽象類和抽象方法要用abstract來修飾，抽象類不能被實例化
抽象方法是指沒有方法體的方法，抽象方法不能是private的，沒有意義
開閉原則
應該將固定的，穩定的成員封裝，不確定的成員應該聲明為抽象成員，留給子類實現
實例：
- 類和方法都要加abstract
- 對抽象方法的重新也要加override
抽象類無法創建實例
abstract class vehicle
{public abstract void run();
}
class car : vehicle
{ public override void run(){Console.WriteLine("car am driving");}
}三、接口
- 接口使用interface來定義，類似于類的class，接口本身的訪問修飾符是可以定義的
- 接口的成員的訪問修飾符固定為public的，不需要寫，也不允許寫
- 在抽象類和抽象函數中，我們需要加上abstract來修飾這是一個抽象類（函數），但是接口不能寫，直接就是最簡單的函數寫法，下例
- 接口的方法不行全部被實現，如果一個類實現了接口但是沒有實現全部方法，也就是說內部有抽象方法，這個類是抽象類（符合定義），在繼承鏈上想要實例化一個類，那么這個類肯定是這個抽象類的子孫類
interface Iphone{void Dail();void Pickup();void Send();void Receive();}class Nokia : Iphone{public void Dail(){Console.WriteLine("Nokia is dailing");}public void Pickup(){Console.WriteLine("Nokia is picking up");}public void Receive(){Console.WriteLine("Nokia is receiving");}public void Send(){Console.WriteLine("Nokia is sending");}}class userphone{private Iphone _phone;public userphone(Iphone phone){_phone = phone;}public void Usephone() { _phone.Dail();_phone.Pickup();_phone.Send();_phone.Receive();}}internal class Program{static void Main(string[] args){userphone user = new userphone(new Nokia());}}在這個例子中，我們可以看到雖然無法創建接口的實例，但是可以創建接口類型的引用變量指向子類實例實現多態，在userphone中調用Nokia類中函數
如果再有一個另外品牌的手機我們只需要修改傳入的實例即可，例如：（new huawei（）），這樣我們可以通過
3.2依賴反轉
由這張圖解釋上面代碼
不使用接口時：
例如：有兩個品牌的手機（Nokia和huawei）需要創建兩個類（這一步都一樣），手機的使用者（userphone）需要使用不同的手機（在這個類中調用手機類的方法）那么要不然就是創建兩個（userphone）類似的類分別實例化，要不只能在一個類中寫兩個不同名的方法（不同點1），這時，手機和手機的使用者，是手機使用者依賴于手機，因為需要在手機使用者方法（Usephone）中實例化手機類才能調用手機中的方法（不同點2）對應圖中左上角
使用接口時：
我們創建一個接口（Iphone），兩個品牌的手機依賴于Iphone因為實現接口，使用者（userphone）依賴于（Iphone），這時依賴關系發生了變化，并且現在在使用者（userphone）中想要實現不同手機類中的方法，只需要使用接口類的引用類型，當實例時傳入Nokia時調用Nokia的方法，傳入huawei時調用huawei的方法
使用接口的優勢：
當我們需要增加一個手機品牌例如三星，不使用接口時，除了寫上三星類，我們需要修改手機使用者類，增加函數，或者直接專門寫一個三星手機使用者的類，對應上圖左上角
使用接口時：只需要寫上三星類，然后調用時把三星類的實例作為實際參數傳給使用者類中的函數的接口的引用變量就可以了（對應上圖右上角）
在修改代碼時不需要改變userphone類的成員，因為userphone不依賴于某個手機品牌的類，只依賴于接口，這樣增加了類的獨立性，我們稱為解耦合
