例題：（劍指offer）

（1）類中的靜態成員，在第一次使用類的時候進行初始化；

（2）靜態構造函數：

靜態構造函數不能手動調用，而是在第一次使用靜態類或者靜態成員的時候自動調用。所以不能爲靜態構造函數添加任何修飾符，默認爲private；

因爲靜態構造函數是系統自動調用的，所以不需要也不能添加任何參數。

靜態構造函數的特點：

1）靜態構造函數只能執行一次；

2）在第一次使用靜態類或者靜態成員之前使用。

例題分析：在調用B的代碼之前先執行靜態構造函數，在執行靜態構造函數之前先初始化靜態成員變量；所以先打印a1,再打印a3;接下來執行B b=new B()；調用B的普通構造函數，先初始化成員變量，再執行構造函數，先打印a2,再打印a4，執行結果是：a1,a3,a2,a4。

接紅皮7頁

Struct和class的區別：struct是值類型，class是引用類型。值類型的實例在棧上分配內存，引用類型的實例在堆上分配內存。

一、流程控制

1. 異常捕獲

異常：在語法上沒有錯誤，在程序運行過程中，由於某些原因程序出現了錯誤，不能再正常運行。所以在代碼中需要在可能出現異常的位置使用try-catch來進行異常捕獲。

語法：

try

{

可能會出現異常的代碼

}

Catch

{

出現異常後要執行的代碼

{

執行過程：在try中的代碼出錯，後面的就不執行了，直接跳到catch中執行。

2. switch-case

用於處理多條件的定值的判斷。（對於存在範圍的，可以轉化爲定值，比如成績等級的判斷，可根據成績用%或者/來定值）

Switch(變量或表達式的值)

{

Case值1：要執行的代碼；

Break;

Case 值2：要執行的代碼；

Break；

Case 值3：要執行的代碼；

Break；

…………

Default：要執行的代碼；

Break；

}

執行過程：執行到switch處，首先將括號中變量或者表達式的值計算出來，與case中的值依次與case進行匹配，匹配成功執行，直接跳出switch-case結構，如果無case匹配，則執行default（可省略）。

3. while //知道循環的條件

while(循環條件)

{

循環體;

}

執行過程：先判斷後執行。在使用之前先想好循環條件和循環體。

4. break

(1) 跳出switch結構

(2) 跳出當前while循環

Break一般不單獨使用，而是配好if使用，表示當滿足

5. do-while循環。

語法：

{

循環體;

}while(循環條件);

執行過程:程序首先會執行do中的循環體，執行完成後，去判斷do-while循環的循環條件，

如果成立，則繼續執行do中的循環體，如果不成立，則跳出do-while循環。

特點：先循環，再判斷，最少執行一遍循環體。

6. *程序調試

1)、寫完一段程序後，想看一下這段程序的執行過程。

2)、當你寫完這段程序後，發現，程序並沒有按照你想象的樣子去執行。

調試方法：

1)、F11逐語句調試(單步調試)

2)、F10逐過程調試

3)、斷點調試

7. for循環 //知道循環的次數

語法:

for(表達式1;表達式2;表達式3)

{

循環體;

}

表達式1一般爲聲明循環變量，記錄循環的次數(int i=0;)

表達式2一般爲循環條件(i<10)

表達式3一般爲改變循環條件的代碼，使循環條件終有一天不再成立(i++)。

執行過程：程序首先執行表達式1，聲明瞭一個循環變量用來記錄循環的次數，

然後執行表達式2，判斷循環條件是否成立，如果表達式2返回的結果爲true，

則執行循環體。當執行完循環體後，執行表達式3，然後執行表達式2繼續判斷循環條件是否成立，如果成立則繼續執行循環體，如果不成立，則跳出for循環。

8. 類型轉換

Convert.toInt32(); //面上得看得過去，轉換失敗則拋出異常

int.parse

int.tryparse(“123”,out number) //將”123”轉化爲數字，賦值給number，返回bool類型true；若轉化失敗，則把0賦值給number，返回false；

嘗試着將一個字符串轉換成int類型。

9. 三元表達式

語法:

表達式1?表達式2:表達式3;

表達式1一般爲一個關係表達式。

如果表達式1的值爲true，那麼表達式2的值就是整個三元表達式的值。

如果表達式1的值爲false，那麼表達式3的值就是整個三元表達式的值。

注意：表達式2的結果類型必須跟表達式3的結果類型一致，並且也要跟整個三元表達式的結果類型一致。

10. Continue

跳出本次循環，進入下一循環。

11. 隨機數產生

Random r=new Random();

Int number=r.Next(1,10);產生1-10的數

二、複雜數據類型

1. 變量類型

int double string char bool decimal

變量的使用規則：先聲明再賦值最後使用

int number;

number=10;

number=20;

Console.WriteLine(number);

2. Camel Pascal

3. 運算符

賦值運算符：=

複合賦值運算符：+= -= *= /= %= sum+=age; sum=sum+age;

算數運算符： + - * / % ++ --

關係運算符： > < >= <= == !=

邏輯運算符： && || !

4. c#中的語法結構

分支結構：

if if-else

選擇結構：

while do-while for

5. 常量

聲明的常量的語法：

const 變量類型變量名=值;

什麼時候會用到常量？不會隨意改變的量需要用常量，比如：π

6. 枚舉：

確定數量、確定值的幾個取值：東西南北、男女、上中下。

語法：

聲明：[public] enum 枚舉名

{

值1,

值2,

值3,

........

}

例子：public enum Gender

{

男， //可以用男=1，將默認的int初值設爲1

女

}

賦值：Gender gender=Gender.男；

Public 訪問修飾符，公開的公共的，那都可以訪問；

enum枚舉的關鍵字；

枚舉名符合pascal命名規範。

將枚舉聲明到命名空間的下面，類的外面，表示這個命名空間裏面都可以使用此枚舉變量

枚舉也是一個變量類型，只是聲明、賦值和使用的方式不同。

枚舉類型可以與int類型之間強制類型轉換，他們之間是兼容的；

將string類型轉換爲枚舉類型例外：

1）先轉化爲int類型再轉化爲枚舉類型：Convert.toInt32();int.parse(),int.tryParse();

2）利用parse()：

如果要轉換的爲數字，超出範圍也不會報異常；如果轉換的爲字符串，超出範圍則拋出異常；

所有類型都可以轉化爲字符串類型，利用toString()

7. 結構

可以幫助我們一次性聲明多個不同類型的變量。

語法：

[public] struct 結構名

{

成員;//字段

}

變量與字段的區別：變量在程序運行期間只能存儲一個值，而字段可以存儲多個值。

在結構類型中，可以使用枚舉類型；

8. 數組

一次性存儲多個相同類型的變量。

語法：

數組類型[] 數組名=new 數組類型[數組長度];

如果需要訪問數組的某一塊元素，需要通過這個股元素的下標或者索引來訪問；

***數組的長度一旦固定了，就不能再被改變了

9. 冒泡排序

：就是將一個數組中的元素按照從大到小或者從小到大的順序進行排列。

int[] nums={9,8,7,6,5,4,3,2,1,0}; 0 1 2 3 45 6 7 8 9

第一趟比較：8 7 6 5 4 3 2 1 0 9 交換了9次 i=0 j=nums.Length-1-i

第二趟比較：7 6 5 4 3 2 1 0 8 9 交換了8次 i=1 j=nums.Length-1-i

第三趟比較：6 5 4 3 2 1 0 7 8 9 交換了7次 i=2 j=nums.Length-1-i

第四趟比較：5 4 3 2 1 0 6 7 8 9 交換了6次 i=3 j=nums.Length-1-i

第五趟比較：4 3 2 1 0 5 6 7 8 9 交換了5次

第六趟比較：3 2 1 0 4 5 6 7 8 9 交換了4次

第七趟比較：2 1 0 3 4 5 6 7 8 9 交換了3次

第八趟比較：1 0 2 3 4 5 6 7 8 9 交換了2次

第九趟比較：0 1 2 3 4 5 6 7 8 9 交換了1次

for(int i=0;i<number.Length-1;i++)

{

for(intj=0;j<nums.Length-1-i;j++)

{

if(nums[j]>nums[j+1])

{

inttemp=nums[j];

nums[j]=nums[j+1];

nums[j+1]=temp;

}

10. 方法

函數就是將一堆代碼進行重用的一種機制。

函數的語法：

[public] static 返回值類型方法名([參數列表])

{

方法體；

}

public:訪問修飾符，公開的，公共的，哪都可以訪問。

static：靜態的

返回值類型：如果不需要寫返回值，寫void

方法名：Pascal 每個單詞的首字母都大些。其餘字母小寫

參數列表：完成這個方法所必須要提供給這個方法的條件。如果沒有參數，小括號也不能省略。

方法寫好後，如果想要被執行，必須要在Main()函數中調用。

方法的調用語法：

類名.方法名([參數]);

***在某些情況下，類名是可以省略的，如果你寫的方法跟Main()函數同在一個類中，這個時候，類名可以省略。

11. return

1、在方法中返回要返回的值。

2、立即結束本次方法。

12. 方法（參數、重載、遞歸）

1、我們在Main()函數中，調用Test()函數，我們管Main()函數稱之爲調用者，

管Test()函數稱之爲被調用者。

如果被調用者想要得到調用者的值：

1)、傳遞參數。

2)、使用靜態字段來模擬全局變量。

如果調用者想要得到被調用者的值：

1)、返回值

2、不管是實參還是形參，都是在內存中開闢了空間的。

3、方法的功能一定要單一。

GetMax(int n1,int n2)

方法中最忌諱的就是出現提示用戶輸入的字眼。

4、out、ref、params

1)、out參數。

如果你在一個方法中，返回多個相同類型的值的時候，可以考慮返回一個數組。

但是，如果返回多個不同類型的值的時候，返回數組就不行了，那麼這個時候，

我們可以考慮使用out參數。

out參數就側重於在一個方法中可以返回多個不同類型的值。

比如tryPause()就是使用out參數，除了返回是否轉化成功外，還返回轉化結果

2)、ref參數

能夠將一個變量帶入一個方法中進行改變，改變完成後，再講改變後的值帶出方法。

ref參數要求在方法外必須爲其賦值，而方法內可以不賦值。//out要求方法內必須賦值，方法外不一定。

3)、params可變參數

將實參列表中跟可變參數數組類型一致的元素都當做數組的元素去處理。

params可變參數必須是形參列表中的最後一個元素。

5、方法的重載

概念：方法的重載指的就是方法的名稱相同，但是參數不同。

參數不同，分爲兩種情況

1)、如果參數的個數相同，那麼參數的類型就不能相同。

2)、如果參數的類型相同，那麼參數的個數就不能相同。

***方法的重載跟返回值沒有關係。

6、方法的遞歸

方法自己調用自己。

找出一個文件夾中所有的文件。

三、面向對象

1. 面向過程----->面向對象

面向過程：面向的是完成這件事兒的過程，強調的是完成這件事兒的動作。

把大象塞進冰箱裏

1、打開冰箱門

2、把大象塞進去，親下大象的屁股

3、關閉冰箱門

孫全瘦小矮小屌絲

孫全踩着小板凳打開冰箱門

孫全找翟盼盼幫忙把大象塞進冰箱裏，孫全踩着板凳去親。

孫全踩着板凳關閉冰箱門

翟盼盼 190cm 非常大力氣

1、翟自己就能打開冰箱門

2、翟自己將大象塞進冰箱裏，翟可以自己親一下。

3、翟自己關閉冰箱門

如果我們用面向過程的思想來解決這件事兒，當執行這件事的人的不同的時候，

我們需要爲每個不同的人量身定做解決事情的方法。

面向對象：找個對象幫你做事兒。

把大象塞進冰箱裏

我們把冰箱作爲對象：

1、冰箱門可以被打開

2、大象可以被塞進冰箱裏

3、冰箱門可以被關閉

孫全

孫全 1

孫全 2

孫全 3

翟盼盼

翟 1

翟 2

翟 3

面向對象：意在寫出一個通用的代碼，屏蔽差異。

關門

面向過程：關門

張三一腳把門踹緊了

李四輕輕的把門帶上了

王五門沒關嚴，留了個尾巴

面向對象：關門

門可以被關閉

我在黑板上畫了一個菱形

將圓圈作爲對象

圓圈可以被畫在黑板上

將黑板作爲對象

黑板可以被畫圓

我在黑板上畫了一個圓

張三上來的哪尺子比這畫了一個特別圓的圓

李四上來的隨便一劃拉

王五上來了圓規畫了一個圓

圓可以被畫在黑板上

圓圈可以被畫在黑板上

將圓圈作爲對象：這個圓圈可以被畫在黑板上。

黑板可以被畫圓

黑板作爲一個對象：可以被畫圓圈被畫方塊被畫正方向

根據需求，找被動的作爲對象

試着描述孫全和顏XX的特徵和行爲

姓名：孫全

性別：男

身高：180cm

體重：70kg

年齡：22歲

吃喝拉撒睡一切正常健康

吃喝嫖賭抽

姓名：顏XX

性別：男

身高：180cm

體重：70KG

年齡：23歲

腦殘身體一切健康

我們在代碼中描述一個對象，通過描述這個對象的屬性和方法

對象必須是看得見摸得着的

燈：屬性和方法

屬性：

外形：長的

亮度：500W

顏色：白色

牌子：XX

方法：發光

電風扇：屬性、方法

外形：三個扇葉

顏色：白色

品牌：XX

方法：轉動，扇風

我們把這些具有相同屬性和相同方法的對象進行進一步的封裝，抽象出來類這個概念。

類就是個模子，確定了對象應該具有的屬性和方法。

對象是根據類創建出來的。

類就是一個蓋大樓的圖紙對象就是蓋出來的大樓。

2. 類

語法：

[public] class 類名

{

字段;

屬性;

方法;

}

寫好了一個類之後，我們需要創建這個類的對象，

那麼，我們管創建這個類的對象過程稱之爲類的實例化。

使用關鍵字 new.

this:表示當前這個類的對象。

類是不佔內存的，而對象是佔內存的。

3. 屬性

屬性的作用就是保護字段、對字段的賦值和取值進行限定。

屬性的本質就是兩個方法，一個叫get()一個叫set()。

既有get()也有set()我們誠之爲可讀可寫屬性。

只有get()沒有set()我們稱之爲只讀屬性

沒有get()只有set()我們稱之爲只寫屬性

Field字段

Method方法

Property屬性

****字段就是女人屬性纔是男人。

在調用靜態成員的時候，需要使用類名.靜態成員名;

總結：靜態成員必須使用類名去調用，而實例成員使用對象名調用。

靜態函數中，只能訪問靜態成員，不允許訪問實例成員。

實例函數中，既可以使用靜態成員，也可以使用實例成員。

靜態類中只允許有靜態成員，不允許出現實例成員。

使用：

1)、如果你想要你的類當做一個"工具類"去使用，這個時候可以考慮將類寫成靜態的。

2)、靜態類在整個項目中資源共享。

只有在程序全部結束之後，靜態類纔會釋放資源。

堆棧靜態存儲區域

釋放資源。GC Garbage Collection垃圾回收器

7. 構造函數

作用：幫助我們初始化對象(給對象的每個屬性依次的賦值)

構造函數是一個特殊的方法：

1)、構造函數沒有返回值，連void也不能寫。

2)、構造函數的名稱必須跟類名一樣。

創建對象的時候會執行構造函數

構造函數是可以有重載的。

***

類當中會有一個默認的無參數的構造函數，當你寫一個新的構造函數之後，不管是有參數的還是

無參數的，那個默認的無參數的構造函數都被幹掉了。

8. new關鍵字

Person zsPerson=new Person();

new幫助我們做了3件事兒：

1)、在內存中開闢一塊空間

2)、在開闢的空間中創建對象

3)、調用對象的構造函數進行初始化對象

9. this關鍵字

1)、代表當前類的對象

2)、在類當中顯示的調用本類的構造函數 :this

以避免代碼冗餘！不需要的參數設置爲默認值；

10. 析構函數

~student()

{

手動釋放資源；在程序結束之後觸發

}

四、面向對象2

1. 命名空間

可以認爲類是屬於命名空間的。

如果在當前項目中沒有這個類的命名空間，需要我們手動的導入這個類所在的

命名空間。

1)、用鼠標去點

2)、alt+shift+F10

3)、記住命名空間，手動的去引用

2. 在一個項目中引用另一個項目的類

1)、添加引用

2)、引用命名空間

3. 值類型和引用類型

區別：

1、值類型和引用類型在內存上存儲的地方不一樣。

2、在傳遞值類型和傳遞引用類型的時候，傳遞的方式不一樣。

值類型我們稱之爲值傳遞，引用類型我們稱之爲引用傳遞。

我們學的值類型和引用類型：

值類型：int、double、bool、char、decimal、struct、enum

引用類型：string、自定義類、數組

存儲：

值類型的值是存儲在內存的棧當中。

引用類型的值是存儲在內存的堆中。

4. 字符串

1)、字符串的不可變性

當你給一個字符串重新賦值之後，老值並沒有銷燬，而是重新開闢一塊空間存儲新值。

當程序結束後，GC掃描整個內存，如果發現有的空間沒有被指向，則立即把它銷燬。

2)、我們可以講字符串看做是char類型的一個只讀數組。(反轉字符串時，即改變時，需要先轉化爲字符數組)

ToCharArray();將字符串轉換爲char數組

new string(char[] chs):能夠將char數組轉換爲字符串

4、字符串提供的各種方法

1)、Length：獲得當前字符串中字符的個數

2)、ToUpper():將字符轉換成大寫形式

3)、ToLower():將字符串轉換成小寫形式

4)、Equals(lessonTwo,StringComparison.OrdinalIgnoreCase):比較兩個字符串，可以忽略大小寫

5)、Split()：分割字符串，返回字符串類型的數組。

6)、Substring()：截取字符串。在截取的時候包含要截取的那個位置。

7)、IndexOf():判斷某個字符串在字符串中第一次出現的位置，如果沒有返回-1、值類型和引用類型在內存上存儲的地方不一樣。

//利用找不到返回-1,作爲循環條件做題:indexof(“e”,i),返回從i開始第一次出現e的位置

8)、LastIndexOf()：判斷某個字符串在字符串中最後一次出現的位置，如果沒有同樣返回-1

9)、StartsWith():判斷以....開始

10)、EndsWith():判斷以...結束

11)、Replace():將字符串中某個字符串替換成一個新的字符串

12)、Contains():判斷某個字符串是否包含指定的字符串

13)、Trim():去掉字符串中前後的空格

14)、TrimEnd()：去掉字符串中結尾的空格

15)、TrimStart()：去掉字符串中前面的空格

16)、string.IsNullOrEmpty():判斷一個字符串是否爲空或者爲null

17)、string.Join()：將數組按照指定的字符串連接，返回一個字符串。

//比如：string[] str={“諸葛亮”,”鳥叔”,”卡卡西”};

String s=string.Jion(“|”，str);str爲要連接的數組

18)、s1.CompareTo(s2)，如果s1>s2,則返回1，相等返回0，小於返回-1；

數組的排序Array.Sort(array); //數組的排序：Array.Sort(num);

數組的翻轉Array.Reverse(array);

5. 繼承：解決代碼冗餘問題！！

我們可能會在一些類中，寫一些重複的成員，我們可以將這些重複的成員，

單獨的封裝到一個類中，作爲這些類的父類。

Student、Teacher、Driver 子類派生類

Person 父類基類

子類繼承了父類，那麼子類從父類那裏繼承過來了什麼？

首先，子類繼承了父類的屬性和方法，但是子類並沒有繼承父類的私有字段。

問題：子類有沒有繼承父類的構造函數？

答：子類並沒有繼承父類的構造函數，但是。子類會默認的調用父類無參數的構造函數，

創建父類對象，讓子類可以使用父類中的成員。

所以，如果在父類中重新寫了一個有參數的構造函數之後，那個無參數的就被幹掉了，

子類就調用不到了，所以子類會報錯。

解決辦法：

1)、在父類中重新寫一個無參數的構造函數。

2)、在子類中顯示的調用父類的構造函數，使用關鍵字:base()

6. 繼承的特性

1、繼承的單根性：一個子類只能有一個父類。

2、繼承的傳遞性

7. 查看類圖

8. object是所有類的基類。

9. new關鍵字

1)、創建對象

2)、隱藏從父類那裏繼承過來的同名成員。比如同名的方法

隱藏的後果就是子類調用不到父類的成員。

五、面向對象3

1. 里氏轉換

1)、子類可以賦值給父類

2)、如果父類中裝的是子類對象，那麼可以將這個父類強轉爲子類對象。

2.

子類對象可以調用父類中的成員，但是父類對象永遠都只能調用自己的成員。

3. 判斷子父類之間是否可以轉換

is：表示類型轉換，如果能夠轉換成功，則返回一個true，否則返回一個false

as：表示類型轉換，如果能夠轉換則返回對應的對象，否則返回一個null

4. protected

受保護的：可以在當前類的內部以及該類的子類中訪問。

5. ArrayList集合的長度問題

每次集合中實際包含的元素個數(count)超過了可以包含的元素的個數(capcity)的時候，

集合就會向內存中申請多開闢一倍的空間，來保證集合的長度一直夠用。

方法：

6. Hastable 鍵值對集合字典孫 sun---孫

在鍵值對集合當中，我們是根據鍵去找值的。

鍵值對對象[鍵]=值;

*****:鍵值對集合當中，鍵必須是唯一的，而值是可以重複的

foreach循環

7. 編碼格式

產生亂碼的原因就是因爲你保存這個文件的編碼格式跟你打開這個文件的編碼格式不一樣。

8. 文本文件

拖到txt文件中，還能看得懂的文件就是文本文件。

File類和int的最大值和最小值

9. path類：system.IO，專門用來操作路徑的；

10. File類：System.IO

六、面向對象四

1. 絕對路徑和相對路徑

絕對路徑：通過給定的這個路徑直接能在我的電腦中找到這個文件。

相對路徑：文件相對於應用程序的路徑。

結論：

我們在開發中應該去儘量的使用相對路徑。

2. 裝箱、拆箱

裝箱：就是將值類型轉換爲引用類型。

拆箱：將引用類型轉換爲值類型。

看兩種類型是否發生了裝箱或者拆箱，要看，這兩種類型是否存在繼承關係。

3. 將創建文件流對象的過程寫在using當中，會自動的幫助我們釋放流所佔用的資源。

l 文件流filestream，（）（1）可操作所有的文件、（2）可操作大文件，更重要！！！

例題：多媒體文件的賦值

l SteamReader/SteamWrite

4. 實現多態的手段

1)、虛方法：需要從所有類中選一個作爲父類

步驟：

1、將父類的方法標記爲虛方法，使用關鍵字 virtual，這個函數可以被子類重新寫一個遍。

2)、抽象類：所有類中沒有一個類可作爲父類，只能抽象出一個類

當父類中的方法不知道如何去實現的時候，可以考慮將父類寫成抽象類，將方法寫成抽象方法。

特點：

1.抽象成員必須標記爲abstract,並且不能有任何實現。

2.抽象成員必須在抽象類中。

3.抽象類不能被實例化

4.子類繼承抽象類後，必須把父類中的所有抽象成員都重寫。

（除非子類也是一個抽象類，則可以不重寫）

5.抽象成員的訪問修飾符不能是private

6.在抽象類中可以包含實例成員。

並且抽象類的實例成員可以不被子類實現

7.抽象類是有構造函數的。雖然不能被實例化。、

8、如果父類的抽象方法中有參數，那麼。繼承這個抽象父類的子類在重寫父類的方法的時候必須傳入對應的參數。

如果抽象父類的抽象方法中有返回值，那麼子類在重寫這個抽象方法的時候也必須要傳入返回值。

======

如果父類中的方法有默認的實現，並且父類需要被實例化，這時可以考慮將父類定義成一個普通類，用虛方法來實現多態。

如果父類中的方法沒有默認實現，父類也不需要被實例化，則可以將該類定義爲抽象類。

七、面向對象五

1. c#中的訪問修飾符

public :公開的公共的

private：私有的，只能在當前類的內部訪問

protected：受保護的，只能在當前類的內部以及該類的子類中訪問。

internal：只能在當前項目中訪問。在同一個項目中，internal和public的權限是一樣。

protected internal：protected+internal

1)、能夠修飾類的訪問修飾符只有兩個：public、internal。

2)、可訪問性不一致。

子類的訪問權限不能高於父類的訪問權限，會暴漏父類的成員。

序列化：

1)、將這個類標記爲可以被序列化的。

6. partial部分類

7. sealed密封類

不能夠被其他類繼承，但是可以繼承於其他類。

8. 重寫ToString方法：

9. 接口

//接口就是一個規範、能力

[public] interface I..able

{

成員;

}

特點：

接口是一種規範。

只要一個類繼承了一個接口，這個類就必須實現這個接口中所有的成員

爲了多態。

接口不能被實例化。

也就是說，接口不能new(不能創建對象)

接口中的成員不能加“訪問修飾符”，接口中的成員訪問修飾符爲public,不能修改。

（默認爲public）

接口中的成員不能有任何實現（“光說不做”，只是定義了一組未實現的成員）。

接口中只能有方法、屬性、索引器、事件，不能有“字段”和構造函數。

接口與接口之間可以繼承，並且可以多繼承。

接口並不能去繼承一個類，而類可以繼承接口（接口只能繼承於接口，而類既可以繼承接口，也可以繼承類）

實現接口的子類必須實現該接口的全部成員。

一個類可以同時繼承一個類並實現多個接口，如果一個子類同時繼承了父類A，並實現了接口IA,那麼語法上A必須寫在IA的前面。

class MyClass:A,IA{}，因爲類是單繼承的。

顯示實現接口的目的：解決方法的重名問題

什麼時候顯示的去實現接口：

當繼承的藉口中的方法和參數一摸一樣的時候，要是用顯示的實現接口

當一個抽象類實現接口的時候，需要子類去實現接口。

八、面向對象複習

1. new關鍵字

1)、創建對象

2)、隱藏從父類那裏繼承過來的成員

2. 訪問修飾符

public:公開的，公共的

private:私有的，只能在當前類的內部訪問，類中成員們，如果不加訪問修飾符，默認就是private，比如main函數省略訪問修飾符時，默認爲private。

procteced：受保護的，可以在當前類的內部訪問，也可以在該類的子類中訪問

internal：在當前項目中都可以訪問。

Protected internal：

能夠修飾類的訪問修飾符只有兩個，internal和public

3. 常用的關鍵字

this

1、作爲當前類的對象，可以調用類中的成員。This.成員；

2、調用本類的其他的構造函數在構造函數後加：this（參數）

base

調用父類的成員（在子類重寫了父類成員時）

new

1、創建對象

2、隱藏父類的成員

virtual

標記一個方法是虛方法

abstract

抽象的

override

重寫

interface

接口

partial

部分類

sealed

密封類：不允許被繼承

return

1、在方法中返回要返回的值

2、立即結束本次方法

break

跳出當前循環

continue

結束本次循環，回到循環條件進行判斷

static

靜態的

struct

結構

enum

枚舉

const

常量

4. 字符串

1、字符串的不可變性

2、字符串可以看做是char類型的只讀數組

5. 集合

ArrayList

Hashtable

List<T>

Dictionary<TKey,TValue>

6. 裝箱或者拆箱

裝箱：就是將值類型轉換爲引用類型

拆箱:就是將引用類型轉換爲值類型。

值類型:bool int double char struct enum decimal

引用類型：string 數組集合 interface object 自定義類

拆箱或者裝箱的兩種類型必須具有繼承關係

7. 結構和類的區別

1、類當中寫了一個新的構造函數之後，默認的無參數的就被幹掉了。

但是在結構中，寫了一個新的構造函數之後，默認的那個無參數的還在。

在結構的構造函數當中，必須給所有的字段賦值，這樣也就限制了結構中最多

只能有兩個構造函數，一個是默認的無參數的構造函數，一個是全參數的構造函數。

2、結構的new關鍵字只幹了一件事兒，就是調用結構的構造函數。

3、結構不能繼承於類，而類也不能繼承於結構。

結構不具備面向對象的特徵。

而類纔是面向對象的產物。

3、如果不給結構創建對象的話，不允許調用結構中的非靜態方法。

十、委託、XML

1. 配置.net環境

2. 單例模式

1）將構造函數私有化；

2）提供一個靜態函數，返回一個對象

3）創建一個單例；

3. XML 可擴展標記語言 HTML

XML 存儲數據；

注意：

1） XML嚴格區分大小寫；

2） XML標籤是成對出現的；

XML文檔有且只能有一個根節點；

節點：

元素：

4. 委託：delegate

1）爲什麼要用委託？

將方法做爲參數傳遞給另一個方法；

2）委託的概念

聲明一個委託類型

委託所指向的函數必須和委託具有相同的簽名；

3）匿名函數

沒有名字的函數

4）使用委託求數組的最大值

使用委託求數組的最小值

5）泛型委託

標準委託類型Func<>、Action<>（無返回，傳入string）

6） Lanmda表達式

7）窗體傳值//發佈訂閱模式（觀察者模式）

8）多播委託

socket編程，做一個聊天程序

IIS服務器

2、一般處理程序

網頁的增添改查crud 、圖片處理

4、 aspx頁面的crud

asp.net的生命週期====》面試

4、異步的crud Ajax

5、服務器段控件的crud

6、高級部分：

C#學習筆試

4. c#中的語法結構

6. 枚舉：

1. 面向過程----->面向對象

8. new關鍵字

9. this關鍵字

8. object是所有類的基類。

9. new關鍵字

2.

5. ArrayList集合的長度問題

6. Hastable 鍵值對集合 字典 孫 sun---孫

9. path類：system.IO，專門用來操作路徑的；

10. File類：System.IO

3. 將創建文件流對象的過程寫在using當中，會自動的幫助我們釋放流所佔用的資源。

1)、虛方法：需要從所有類中選一個作爲父類

2)、抽象類：所有類中沒有一個類可作爲父類，只能抽象出一個類

1. c#中的訪問修飾符

6. partial部分類

7. sealed密封類

8. 重寫ToString方法：

1. new關鍵字

1. 配置.net環境

3. XML 可擴展標記語言 HTML

6. Hastable 鍵值對集合字典孫 sun---孫