簡單認識.NET框架
（1）首先我們得知道 .NET框架具有兩個主要組件：公共語言進行時CLR（Common Language Runtime）和框架類庫FCL（Framework Class Library）
配圖：
（2）.NET的編譯過程：
配圖：
其中，CLR還包括通用類型系統CTS（Common Type System）和公共語言規范CLS（Common Language Specification）
（3）.NET框架核心類庫及其功能
配圖：
（4）
C#語言要編程可以被CPU解析執行的代碼需要兩次編譯：
第一次編譯：將C#語言通過C#編譯器編譯成MSIL中間代碼
第二次編譯：將MSIL代碼通過即時編譯器（JIT）編譯成CPU可以解析執行的代碼，或者成為（平台專用代碼）
Java程序想要被CPU解析執行也需要兩次編譯：
第一次編譯：將後綴名為java的文件通過Java編譯器編譯成後綴名為.class（字節碼）文件
第二次編譯：將.class文件通過Java虛擬機（jvm）編譯成CPU可以解析的代碼
（5）面向對象
面向對象三大特性：封裝，繼承和多態
那些年我們學過的訪問修飾符：
public :任何位置，包括跨程序集
internal:在當前程序集（項目）中都可以訪問
private:只能在當前類中訪問（當前類的花括號中訪問）
protected:只能在當前類和子類中使用
（6）變量，類和方法的命名
駱駝命名法：第一個單詞的首字母小寫，後續有含義的單詞首字母大寫。 變量
帕斯卡命名法：每一個單詞的首字母大寫 類和方法
（7）new：代表的含義
1.創建對象
2.開辟空間
3.自動調用構造函數
（8）字段和屬性的區別
1.屬性不能保存數據，真正保存數據的是字段。
2.屬性是可有可無的，字段是必須的。
3.如果字段只是讓類內部訪問，那麼設置成private，如果想找一個中間者，在Main方法中訪問到類中的私有字段，那麼屬性可以是一種選擇。
（9）自動屬性
定義：當為我們不需要進行邏輯判斷時可以使用自動屬性。 定義自動屬性在後台會自動幫我們生成一個對應數據類型的私有字段
（10）CLR的主要用途：
CLR是所有.NET程序運行的環境，是所有.NET應用程序的編程基礎，所有.NET受CLR監管和處理，這些操作包括進程內的應用程序加載，將IL轉換為GG，
異常處理，垃圾回收，加載程序集
深入C#數據類型
（1）值類型和引用類型
值類型：是在棧上存儲真實的值 引用類型：在棧和堆上都開辟空間
值類型：int double float boolean char byte long short 枚舉(enum) 結構體(struct)
引用類型：int[] class 接口(interface) string
（2）結構
定義：
訪問修飾符 struct 結構名
{
// 結構體
}
例：
public struct Student
{
//結構體
}
（2）注意點：
1.在結構中可以有字段和方法
2.定義結構時，結構中的字段不能被賦初值
3.可以不用new，直接定義結構的對象即可
4.聲明結構的對象後，必須給結構的成員賦初值
5.結構體也是一種特殊的值類型
（3）裝箱和拆箱
將值類型轉換為引用類型的過程稱為裝箱，反之稱為拆箱
示例:
static void Main(String[] args)
{
int i=123;
oject o=i; //裝箱
i=456; //改變i的內容
Console.WriteLine("值類型的值：{0}",i);
Console.WriteLine("引用類型的值：{0}",o);
}
（4）不同類型的參數傳遞
值方式參數傳遞：傳遞數據類型是值類型,沒有ref在方法中不會保留
傳遞數據類型是引用類型,沒有ref在方法中會永久保留
引用方式傳遞：不管有沒有ref都會永久保留
例：
class Voter
{
public void Vote(SE se)
{
//人氣值+1
se.Popularity++;
}
}
/測試相關代碼
SE zhang=new SE();
zhang.Age=25;
zhang.Name="張梅";
zhang.Gender=Gender.female;
zhang.Popularity=10;
//投票前
MessageBox.Show(zhang.SayHi());
Voter voter=new Voter();
voter.Vote(zhang); //引用類型做參數
//投票後
MessageBox.Show(zhang.SayHi());
（5）結構和類的區別
1.結構是值類型而類是引用類型
2.結構和另外一個結構不能繼承和被繼承
3.結構沒有默認構造而類有
4.結構體沒有析構函數而類有
5.結構體可以不使用new初始化，而類不可以
使用集合組織相關數據
（1）定義：
集合：
某些特定的對象集中在一起就是集合
數組：
可以存儲相同數據類型的一堆數據的容器
（2）集合
集合分為泛型集合和非泛型集合
泛型集合分為單列和雙列集合 （List<T>和Dictionary<K,V>）
非泛型集合分為單列和雙列集合 （ArrayList和HashTable）
（3）常用的方法和屬性
Add(); //添加 Remove(); //刪除 RemobeAt(); //根據索引刪除 不適用 雙列集合 count //集合存儲元素的個數 Contains(); //檢測元素是否存在 ContainsKey(); // ContainsValue(); Capcity //集合占用空間
注意事項：如果刪除了集合中的某一個元素，那麼集合的索引會自動維護
（4）遍歷方案：
ArrayList list=new ArrayLIst();
Student stu1=new Student();
stu1.Name="jiejie";
stu1.Age=15;
list.Add(stu1);
Student stu2=new Student();
stu2.Name="jiji";
stu2.Age=18;
list.Add(stu2);
//foreach
foreach(Student item in list)
{
Console.WriteLine(item.Age+"\t"+item.Name);
}
//for
for(int i=0;i<list.Count;i++)
{
Console.WriteLine((Student)list[i].Name);
}
HashTable 遍歷三種方案
HashTable table=new HashTable();
第一種方式：遍歷所有的Keys
foreach(var item in table.Keys)
{
//一個item代表一個key
Console.WriteLine("key是{0}\tvalue是{1}"，item,table[item]);
}
第二種遍歷方式：遍歷所有的value集合
foreach(var item in table.Values)
{
//一個item代表一個value
Console.WriteLine("value是{0}"，item);
}
//遍歷整個table
foreach(DictionaryEntry item in table)
{
Console.WriteLine("key是{0}\tvalue是{1}"，item.Key,item.Value);
}
深入類的方法
（1）構造函數
方法名和類名相同，沒有返回值
注意：在C#中，當我們定義了一個類後，系統底層默認會生成一個和類名相同的無參構造，但是如果我們定義了一個帶參構造，系統將不生成無參構造，但是在
真正的開發中建議大家定義兩個構造函數，一個無參構造和帶參構造
public class SE
{
public SE()
{
}
public SE(string id,string name,int age,Gender gender,int popularity)
{
Id=id;
Name=name;
Age=age;
Gender=gender;
Popularity=popularity;
}
}
（2）方法的重載
在同一個類中，如果有多個方法方法名相同，但是參數的個數，順序，類型不同的多個方法可以構成重載和方法的返回值類型沒有關系。
public void Say(string name,int age)
{
}
public void Say(int age,string name)
{
}
（3）對象間的交互
//遙控器類
public class RemoteControl
{
//開機
public void TurnOn(Tv tv)
{
tv.Open(); //調用電視機對象的開機方法
}
//關機
public void TurnOff(Tv tv)
{
tv.TrunOff();
}
//換台
public void ChangeChannel(Tv tv)
{
Console.WriteLine("請輸入頻道：");
string ChannelNo=Console.ReadLine();
tv.Change(ChannelNo);
}
//電視機類
public class Tv
{
public boolean isOn=false; //是否開機
//打開電視機
public void Open()
{
if(isOn)
{
Console.WriteLine("電視機已打開");
}
else
{
Console.WriteLine("成功打開電視機");
isOm=true;
}
}
//關機
public void TurnOff()
{
if(isOn)
{
Console.WrteLine("電視機正在關機");
isOn=false;
}
else
{
Console.WriteLine("電視機已關閉");
}
}
//換台
public void Change(string channelNo)
{
if(isOn)
{
Console.WriteLine("正在切到{0}台",channelNo);
}
}
//測試Main()方法
static void Main(String[] args)
{
RemoteControl controler=new RemoteControl();
Tv tv=new Tv();
//開機
controler.TurnOn(tv);
//切換頻道
controler.ChangChannel(tv);
//關機
controler.TurnOff(tv);
Console.ReadLine();
}
看到這裡你明白了一點了沒有，回想一下上面所寫的，這是一個重復的事情，一遍不行就兩遍，再教你個小方法，沒事的時候你就想想你學了點什麼，看看自己還記得多少，忘記的就去看看自己寫的，好了接下來繼續吧！
第六章 初識繼承和多態
（1）
繼承的概念是什麼呢？就是一個類可以繼承另一個類的屬性和方法（成員）
繼承是面向對象編程中的一個非常重要的特性。
好了，廢話不多說，下面切入正題：
1.首先我們定義一個子類，給它創建兩個構造：一個無參構造和一個有參構造
定義一個枚舉類
在定義的子類中它有自己獨有的屬性：
在定義的父類中的屬性和構造：
在Main方法中：
同時要注意，在調用子類的帶參構造時，我們要想到調用子類構造的時候，沒有使用base關鍵字調用父類的指定的構造，默認調用父類的無參構造.
補充一下：
01.base代表父類對象，如果base()：調用父類的構造函數
02.base代表的是方法調用，是不需要參數類型的
03.base(傳參順序和父類構造一致，變量名和子類構造參數一致)
（2）在這裡補充一點訪問修飾符
我們所知道的：public private protected
下面我畫一個圖來簡單的描述一下（√表示可以，×表示不可以）
當前類 子類 其他類(Program)
private √ × ×
protected √ √ ×
public √ √ √
總結：我們可以清晰的明白三種訪問修飾符對類成員的訪問限制強度：private>protected>public
（3）new 子類底層原理圖
我簡單的用一個圖來描述一下：
用文字描述：
1.走到子類構造，不進入構造體
2.轉向父類，進入父類構造體執行
3.轉回子類構造，執行子類構造體
4.轉到Main，內存中構建出子類對象
（4）繼承還具有兩大特性這個我們也不要忘記了，就是單根性和傳遞性
單根性指的就是一個子類只有一個父類
傳遞性就是只要跟父類有繼承關系，就可以使用父類的屬性和方法
（5）接下來我們講一講多態
1.多態是什麼呢？字面上的意思就是多種形態
用專業一點的話來說就是指同一個操作作用於不同的對象時，可以有不同的解釋，產生不同的執行效果。
我們所接觸的方法重載也是多態的一種方式。
如何實現多態呢？不要急下面我來解說
（6）實現方法的重寫
在父類中定義的方法，用virtual關鍵字來定義為虛方法
在子類中定義自己的方法，用override關鍵字來修飾，實現對父類的方法的重寫
（7）定義父類變量，用子類變量初始化父類變量
下面來一個小案例：
//創建一個Person父類
public class Person
{
public virtual void SayHello()
{
//父類特有的方法
Console.WriteLine("父類打招呼方法");
}
}
//創建一個Korea子類
public class Korea:Person //在這裡要注意它繼承於Person類
{
public override void SayHello()
{
Console.WriteLine("金喜善打招呼方法");
}
}
//創建一個Chinese類
public class Chinese:Person //在這裡要注意它繼承於Person類
{
public override void SayHello()
{
Console.WriteLine("你好！");
}
}
//創建一個American類
public class American:Person //在這裡要注意它繼承於Person類
{
public override void SayHello()
{
Console.WriteLine("Hello");
}
}
前面我們也學過泛型了下面我們就用泛型來存儲
List<Person> list=new List<Person>();
Chinese chinese=new Chinese();
American usa=new American();
Korea korea=new Korea();
list.Add(chinese);
list.Add(usa);
list.Add(korea);
下面我們可以用foreach來遍歷
方式一：
foreach (Person person in list)
{
person.SayHello();
}
方式二：
foreach (Person person in list)
{
//方式二：不使用統一調用
if (person is Chinese)
{
Chinese chinese= person as Chinese;
chinese.SayHello();
}
if (person is Korea)
{
Korea chinese= person as Korea;
korea.SayHello();
}
if (person is American)
{
American chinese= person as American;
american.SayHello();
}
}
下面我再穿插個示例：
在Main方法中調用
看過我文章的人應該知道，在這裡我們又回顧了一下，你記住了嗎？
深入理解多態
（1）裡氏替換
定義：在一個軟件系統中，如果子類替換父類出現的位置，而對整個軟件系統功能沒有影響
//交通工具類
public class TrafficTool
{
public vartual void Run()
{
Console.WriteLine("車在行駛");
}
}
//地鐵類
public class Tube:TrafficTool
{
public voerride void Run()
{
Console.WriteLine("地鐵在行駛中");
}
}
//小汽車類
public class Car:TrafficTool
{
public voerride void Run()
{
Console.WriteLine("小汽車在行駛中");
}
}
//自行車類
public class Bicycle:TrafficTool
{
public override void Run()
{
Console.WriteLine("自行車在行駛中");
}
}
//給Employee類添加GoHome()方法：搭乘交通工具回家
public class Employee
{
//以父類類型作為參數
public void GoHome(TrafficTool tool)
{
Console.WriteLine("員工"+Name);
tool.Run();
}
}
//測試Main()方法
static void Main(String[] args)
{
SE ai=new SE("123","艾邊成",25,Gender.male,100);
SE joe=new SE("103","Joe",30,Gender.female,200);
//實例化PM對象
PM pm=new PM("890","蓋茨",50,Gender.female,30);
//定義員工集合
List<Employee> list=new List<Employee>();
list.Add(ai);
list.Add(joe);
list.Add(pm);
//員工選擇不同的交通工具回家：傳遞實際創建的子類對象
list[0].GoHome(new Bicycle());
list[1].GoHome(new Car());
list[2].GoHome(new Tube());
Console.ReadLine();
}
（2）抽象類和抽象方法
定義：抽象方法是一個沒有實現的方法，通過定義方法時增加的關鍵字abstract可以聲明抽象方法
語法：
訪問修飾符 abstract 返回類型 方法名();
注意：抽象方法沒有閉合的大括號，而是直接跟了一個分號；，也就是說它沒有方法體。
含有抽象方法的類必然是抽象類
語法：
訪問修飾符 abstract class 類名{}
簡單示例：
public abstract class TrafficTool
{
public abstract void Run();
}
/// <summary>
/// 父類 工作類
/// </summary>
public abstract class Job
{
//抽象方法
public abstract void Show();
//工作類型
public string Type { get; set; }
//工作名稱
public string Name { get; set; }
//工作描述
public string Describe { get; set; }
//無參構造
public Job()
{
}
//帶參構造
public Job(string type,string name,string des)
{
this.Type = type;
this.Name = name;
this.Describe = des;
}
}
public class Tests : Job
{
/// <summary>
/// 子類 測試類
/// </summary>
//測試類的方法
public override void Show()
{
FrmTests tt = new FrmTests();
tt.Show();
this.Num = Num;
this.BugNum = BugNum;
this.Time = Time;
}
//個數
public int Num { get; set; }
//bug數
public int BugNum { get; set; }
//時間
public string Time { get; set; }
//無參構造
public Tests()
{
}
//帶參構造
public Tests(string type,string name,string des):base(type,name,des)
{
}
}
總結：
1.一個類用abstract修飾，就是抽象類
2.抽象類不能實例化
3.抽象方法不能有方法體連{}不能有
4.抽象方法只能在抽象類中
5.抽象方法存在的目的就是為了約束類中方法存在的形式（返回值類型和參數列表）
6.抽象類不能是靜態類和密封類
7.抽象類中所有的抽象方法必須被子類重寫，除非子類本身也是抽象類
8.一鍵重寫所有抽象方法的快捷鍵 Ctrl+.（無輸入法情況下） Shift+Alt+F10
看完這章，你是不是覺得有收獲？
可擴展標記語言XML
（1）HTML和XML
HTML:Hyper Text Markup Language（超文本標記語言）
XML:Extensible Markup Language（可擴展標記語言）
（2）HTML和XML存儲和展示的角度來說
XML：側重數據存儲
HTML:側重數據顯示
（3）XML的注意點
1.XML文件嚴格區分大小寫
2.XML文檔只能有一個根節點
3.XML文件的標簽配對出現
4.我們可以自定義XML文檔中的標簽
