溫馨提示×
您好，登錄后才能下訂單哦！
點擊 登錄注冊 即表示同意《億速云用戶服務條款》
您好，登錄后才能下訂單哦！
這篇文章主要介紹了C#基礎知識的示例分析，具有一定借鑒價值，感興趣的朋友可以參考下，希望大家閱讀完這篇文章之后大有收獲，下面讓小編帶著大家一起了解一下。
關鍵字：C#的關鍵字全部大寫
注釋：跟C++ / Java 風格一致，///是文檔注釋，只能寫在類、方法、屬性的前面。不能用來注釋單個變量。
C#語言也是嚴格區(qū)分大小寫的
C#中的常量：
常量，顧名思義，就是“不會改變的量”。
我們平時書寫的數字（比如12.85）、字符(比如'F')、字符串(比如"謝謝")，它們都屬于“字面常量”。
有一些常量既重要又容易出錯，比如圓周率π的值為3.1415926......，所以，我們常常會使用自定義常量。請看下面的代碼：
static void Main(string[] args)
{
const double PI = 3.1415926; //自定義常量PI
Console.Write("半徑為4的圓的周長為："); //字符串常量
Console.WriteLine(PI * 4 * 2); //使用自定義常量PI
Console.Write("半徑為4的圓的面積為："); //字符串常量
Console.WriteLine(PI * 4 * 4); //使用自定義常量PI
}需要解釋2個關鍵字： const 關鍵字，表明PI是一個常量； double 關鍵字，表明PI的類型為“雙精度浮點型”（一種精度很高的數字類型）。
你會發(fā)現，這段代碼中使用了2次圓周率（周長、面積），但是因為使用自定義常量，所以字面常量3.1415926只書寫了一次。這樣做避免了重復書寫導致的錯誤。
還有一點要特別注意：常量在聲明時賦值，之后是不能修改的。
上一節(jié)我們學習了常量，但編程中使用最多的是變量，這一節(jié)我們學習變量。
變量能夠存儲數據，并且與常量不同，變量存儲的數據可以修改。比如今年18歲，明年可以變成19歲。
使用變量分為3步：聲明、賦值、使用。
聲明變量的語法：數據類型 變量名;
給變量賦值的語法：變量名=值;
請閱讀下面的代碼：
static void Main(string[] args )
{
int age; //聲明一個類型為int的變量age
age = 18; //給變量age賦值為18
Console.WriteLine("我今年" + age+"歲"); //使用變量age
age = 19; //修改age變量的值
Console.WriteLine("我今年" + age+"歲"); //使用變量age
}變量的聲明和賦值可以同時完成（合在一起，也叫初始化）
我們知道聲明變量需要寫出數據類型，我們今天要學習的是最常用的幾種類型。
字符類型 char ，存儲用 '' (單引號)括起來的一個字符，例如：
char sex='男';//存儲性別
字符串類型 string ，存儲用“”（雙引號）括起來的一串字符，例如：
string address="北京市宣武區(qū)牛街北口";//存儲地址
整數類型 int ，存儲整數，例如：
int age=23;//存儲年齡
雙精度浮點型 double ，存儲小數，例如：
double salary=7991.63;//存儲工資
以上四種是最常用的數據類型，其他常用類型，我們會隨著課程深入慢慢介紹。
需要注意的是，某種類型的變量，只能存儲這種類型的數據，否則，可能會出錯。
上一節(jié)我們學習了4種數據類型，也提到每種類型的變量只能存這種類型的數據。可是，有時候真的需要把不同類型的值放在一起運算，比如這種：3.5+8 這時候怎么辦呢？有下面2種情況：
自動類型轉換：2種不同類型的數據運算，低精度類型會自動轉換為較高精度的類型。
以3.5+8為例，顯然數字8的精度較低（int），而3.5的精度較高（double），所以，8會自動轉換為double型，即轉換為3.5+8.0進行運算，結果為11.5。
請看這個例子：double d=2; 2的精度顯然低于變量d的精度，所以2會自動轉換為2.0然后賦值給d。
再看這個例子：int i=3.0;變量i的精度低于3.0，但是由于i已經聲明為int型的變量，變量的值可以變，但變量的類型可不能變來變去的，所以這條命令會出錯的。
強制類型轉換：無法自動轉換為我們需要的類型，可以用強制類型轉換，比如上例可以這樣完成：
int i=(int)3.0;
數字前面的（int）表示轉換的目標類型為int，3.0會被強制轉換為3。
需要注意， double 型強制轉換為int型將失去小數部分，比如(int)2.8，我們得到的將是2。
程序中的變量名、常量名、類名、方法名，都叫做標識符。C#有一套標識符的命名規(guī)則，如果命名時不遵守規(guī)則，就會出錯。這套規(guī)則簡單說有下面三條：
①標識符只能由英文字母、數字和下劃線組成，不能包含空格和其他字符。
錯誤的標識符聲明：string $user; //錯在使用了其他字符
②變量名不能用數字開頭。
錯誤的標識符聲明：double 6h;//錯在用數字開頭
③不能用關鍵字當變量名。
錯誤的標識符聲明：char static ;//錯在用關鍵字static做變量名
計算機程序，當然少不了“計算”，要計算就必須了解運算符。今天，我們先學習算術運算符中的加、減、乘、除。
加：+ 。加號有2個用途：當用加號連接兩個數字時，會計算出這兩個數字的和。比如：
Console.WriteLine(9+2.2);//輸出11.2
另一種情況，當加號兩邊包含字符串的時候，會把兩邊的表達式連接成新的字符串。比如：
Console.WriteLine(9+"2.2");//輸出92.2，因為"2.2"是字符串，所以9也被轉換為"9"，+起的作用是連接字符串
減：- 。減號的作用就是減法。比如：
Console.WriteLine(15-23);//輸出-8
乘：* 。乘號的作用是求2數的乘積。比如：
Console.WriteLine(0.8*3);//輸出2.4
除：/ 。除號的作用是求2數相除的商。比如：
Console.WriteLine(2/0.5);//輸出4.0
但是，2個整數相除，結果僅保留整數部分，小數部分會被舍去。
Console.WriteLine(5/10);//輸出0
這一節(jié)我們學習取余運算符。
C#中的取余運算符就是%。上一節(jié)學習的除號，作用是求2個數字相除的商，而取余運算符%的作用是求兩個數字相除的余數。比如：
Console.WriteLine(19/5);//求19除以5的商，輸出3Console.WriteLine(19%5);//求19除以5的余數，輸出4（商3余4）
編程中，%常常用來檢查一個數字是否能被另一個數字整除。比如下面的代碼片段：
int number = 29; Console.WriteLine(number%2);//求number除以2的余數
如果輸出0,表示沒有余數，即number能夠被2整除（是偶數）；如果輸出1，表示有余數，即number不能被2整除（是奇數）。
這一節(jié)學習兩個特別的運算符++和--。
++，叫做自加運算符。比如你今年18歲，明年長了一歲，用代碼寫出來是這樣：
int age=18;//今年18歲 age=age+1;//明年，在今年的年齡上加1歲
也可以寫成這樣：
int age=18;//今年18歲 age++;//明年，在今年的年齡上加1歲
age++;與age=age+1;作用相同，都是變量的值+1。
--，叫做自減運算符。同理，你今年18歲，用了XX護膚水以后，明年變成17歲了，可以這樣寫：
int age=18;//今年18歲 age--;//等同于 age=age-1;
另外，age++;與age--;也可以寫作++age;或--age;
但請注意：如果與其他運算在同一語句中，++寫在變量前面或后面，算法不一樣，請看下例：
Console.WriteLine(age++);作用等同于下面兩句：
Console.WriteLine(age);//先打印a ge=age+1;//后自加
Console.WriteLine(++age);作用等同于下面兩句：
age=age+1;//先自加 Console.WriteLine(age);//后打印
你看，運算順序不一樣吧，所以輸出的結果也不會相同。
比較數字大小，或者比較數字相等的運算符是比較運算符。C#中的比較運算符有：
注意：表示兩個值相等的“等于”是由2個“=”組成的。
比較運算的結果，都是布爾類型（ bool ），bool類型我們是第一次提到，它表示邏輯上的真(成立)與假(不成立)。真與假用關鍵字 true 和 false 表示。
上面程序中， x>=y 不成立會返回 false ， x<=y 成立，會返回 true 。運行結果：
邏輯運算符用來連接多個 bool 類型表達式，實現多個條件的復合判斷。C#中的邏輯運算符包括：邏輯非( ! )、邏輯與( && )、邏輯或( || )。
邏輯非用來對某一個 bool 類型表達式取反，即“真變假”或“假變真”。請看下面的代碼：
Console.WriteLine(1 > 0);//條件表達式為true，輸出TrueConsole.WriteLine(!(1 > 0));//用邏輯非對條件表達式取反，輸出False
邏輯與用來判斷 2 個 bool 類型表達式是否同時為 true 。請看下面的代碼：
int x = 5, y = 2;//同時聲明2個int型變量并賦值Console.WriteLine(x>3 && y>3);//判斷x>3和y>3是否同時為true，由于y>3為false，所以整個表達式為false
只有當&&兩邊的表達式均為 true 時，整個表達式才為 true ；若任意一個表達式為 false ，整個表達式即為 false 。
邏輯或用來判斷2個 bool 類型表達式中是否有一個為 true 。請看下面的代碼：
int x = 5, y = 2;//同時聲明2個int型變量并賦值Console.WriteLine(x>3 || y>3);//判斷x>3和y>3是否有一個為true，由于x>3為true，所以整個表達式為true
只要||兩邊的表達式有一個為 true ，整個表達式即為 true ；若兩邊的表達式均為 false ，整個表達式為 false 。
對比一下，就是說： && 運算符，兩邊同真才算真，一邊為假就算假； || 運算符，一邊為真即為真，兩邊同假才是假。
作為對上一節(jié)學習的鞏固，這一節(jié)我們通過幾個示例熟悉邏輯運算符的應用。第一個示例是關于邏輯與，比如小張想結婚，未來丈母娘開出的條件是：存款必須過10萬，必須有房子，這兩條少一條都不行。既然2個條件都是“必須”做到，那就需要同時滿足，適合用邏輯與連接：
運行結果為：False
下一個示例是關于邏輯或，比如麗麗選擇男朋友的標準，要么是“工程師”，要么是“運動員”，二者居其一即可：
運行結果為：True
前面，我們已經學過一個賦值運算符“=”，這次我們學習一下其他的賦值運算符：
加賦值“+=”：先加后賦值。請看下面的例子：
int x=5; x += 2;//這句等同于x=x+2;執(zhí)行后，x的值為7
減賦值“-=”：先減后賦值。請看下面的例子：
int x=5; x -= 2;//這句等同于x=x-2;執(zhí)行后，x的值為3
乘賦值“*=”：先乘后賦值。請看下面的例子：
int x=5; x *= 2;//這句等同于x=x*2;執(zhí)行后，x的值為10
除賦值“/=”：先除后賦值。請看下面的例子：
int x=5; x /= 2;//這句等同于x=x/2;執(zhí)行后，x的值為2
取余賦值“%=”：先取余后賦值。請看下面的例子：
int x=5; x %= 2;//這句等同于x=x%2;執(zhí)行后，x的值為1
與其他運算符從左向右計算不同，賦值運算符從右向左計算。
前面我們學習了那么多運算符，如果編程中同時使用了多個運算符，到底哪一個會先運算呢？這就是優(yōu)先級的問題。C#運算符的優(yōu)先級請參考下面的順序：
①括號。學數學的時候我們就知道，要先計算括號里面的內容。C#語言也是一樣，如果有多層括號，要從里向外計算。括號優(yōu)先級最高。
②一元運算符。有些運算符兩邊有2個操作數，比如2+3、6%5等等，這些叫做二元運算符。只有一個操作數的叫做一元運算符，它們的優(yōu)先級高于二元運算符。一元運算符包括：++(自加) 、 --（自減） 、 !（邏輯非）。
③*（乘）、/（除）、%（取余）。
④+（加）、-（減）。
⑤>（大于）、<（小于）、>=（大于等于）、<=（小于等于）。
⑥==（等于）、!=（不等于）。
⑦&&（邏輯與）。
⑧||（邏輯或）。
⑨賦值運算符。包括：=、+=、-=、*=、/=、%=。
另外，還需要注意一點：優(yōu)先級相同的運算符從左向右計算（賦值運算符相反）。
請看下面這段代碼：
bool b = 20 - (15 - 8) * 2 > 10 && (2 % 2 * 2 + 2) > 2; Console.WriteLine(b);
分析：首先計算優(yōu)先級最高的括號，(15-8)得到7，(2%2*2+2)則需要先計算%和*，后算+，結果是2，表達式就變成了：
bool b=20-7*2>10&&2>2;
接下來優(yōu)先級最高的是7*2，然后是減法，變成：
bool b=6>10&&2>2;
繼續(xù)計算兩個大于號，得到：
bool b=false&&false;
最后的結果當然是false：
流程圖是程序步驟的圖形化表示方法。流程圖中包括如下符號：
以上圖形中，流程線用來連接相鄰的兩個步驟；每一個程序都有且僅有一個開始和結束。
以下流程圖描述的是，求2個浮點數的和，后邊是用C#實現：
走到岔路口，需要選擇方向。編寫程序也會遇到判斷和分支。請看下面的流程圖，判斷手機賬戶余額是否不足10元，如果不足給出提示：
這個程序在“balance<10”這個步驟出現了分支，“balance<10”被稱為判斷（ bool 類型），當判斷為 true 時，執(zhí)行左邊的分支，輸出提示；當判斷為 false 時，執(zhí)行右邊的分支，不輸出任何內容。
在C#中，這個結構成為條件結構，通常用 if 關鍵字來實現：
當 if 右邊的判斷為 true 的時候，會執(zhí)行分支一；如果判斷為 false ，則不會執(zhí)行分支一。
前一節(jié)我們學習了 if 條件結構。條件結構可以有2個分支，比如下面的流程圖，判斷一個整數是奇數還是偶數：
這個流程圖從C#實現如下，其中，條件為 true 時執(zhí)行的分支寫在 if() 后面的{}中；條件為 false 時執(zhí)行的分支寫在 else 后面的{}中。
這個由 if 和 else 組成的結構是條件結構的一種，它的基本邏輯是：當條件為 true 時，執(zhí)行分支1，否則，執(zhí)行分支2。這段程序中，變量num能夠被2整除時會執(zhí)行分支1，不能被2整除時執(zhí)行分支2。程序的運行結果是：
每一個 if...else 結構都包含 1 個條件和 2 個分支，而程序會根據條件的真與假，選擇執(zhí)行其中的某一個分支。條件必須為 bool 類型的表達式。
程序開發(fā)中，往往需要先判斷一個條件是否成立，再判斷另一個條件。比如下面的例子：驗證賬號是否為“admin”，如果不是則提示錯誤；如果是，則驗證密碼是否為“bj2022”：
用C#實現如下：
外層的if (userName == "admin") 會被首先判斷，如果為 false ，就會輸出“用戶名錯誤！”；如果為 true ，再判斷內層的if (password == "bj2022")
如果，有多個條件，其中只有一個成立，應該怎樣判斷呢？比如小明考試，90分以上獎勵一臺手機，80-89分獎勵一個滑板，60-79分獎勵一個燒餅，60以下沒有獎勵，0-100的分數被劃分為4檔，需要做3次條件判斷。如果用上一節(jié)學習的嵌套if結構完成，3層if的嵌套會使程序變得很復雜。本節(jié)我們使用多重 if 結構實現，它的基本語法為：
程序運行時，將從上到下依次判斷條件，若某個條件為 true ，則執(zhí)行對應的分支，并且停止后面條件的判斷。比如下面的代碼，將輸出“獎勵一個燒餅”：
if...else 條件結構中，如果某個分支只包含一條命令，那么是可以省略大括號{}的。比如上一節(jié)的練習，可以簡化為：
請注意，如果分支中包含2條以上的命令，是不能省略{}的。
如果 if 和 else 比較多，又省略了{}，怎么判斷那一個 if 和哪一個 else 是一對呢？請看下面的代碼：
當出現多個 if 和 else ，又沒有{}來界定范圍時，請參考下面2條原則：
①每一個 else 與前面離它最近的 if 配對。按照這個原則，上面示例代碼的兩個 else 都與第二個 if 配對，這顯然是不可能的，于是又有了第二個原則。
②多個 else 都與同一個 if 相近時，最內層的 else 優(yōu)先配對。這樣，第一個 else 處于內層，就與第二個 if 優(yōu)先配對，第二個 else 只能與第一個 if 配對。上面的示例代碼會輸出“C”。
根據這兩個原則，上面的代碼等同于如下的規(guī)范代碼：
編寫條件結構時，盡可能加上 {} 可以省掉不必要的錯誤和麻煩。
C#提供了一種條件運算符，能夠代替簡單的 if...else 結構。這種條件運算符的語法如下：
條件表達式 ? 分支1 : 分支2
?: 就是條件運算符，可以看到它有3個操作數，所以又被稱為三元運算符。它的運算邏輯是：當條件表達式為 true 時，執(zhí)行分支1；當條件表達式為 false 時，執(zhí)行分支2。
下面的例子中，根據年齡的大小，輸出“成年人”或“未成年人”：
因為age=17，所以條件表達式age>=18的值為 false ，返回“未成年人”。
if...else 之外，C#中還有一種 switch 條件結構，可以用來對變量進行多個分支的等值判斷。語法如下：
（變量）與每一個 case 后面的常量進行等值比較，如果相等，就執(zhí)行對應的分支。執(zhí)行分支以后， break 關鍵字會使 switch 結構中止，不會再判斷后面的常量。如果變量與所有的常量都不相同，則執(zhí)行 default 后面的分支。
下面的代碼，根據運算符完成了四則運算中的一項：
上面的代碼，因為變量oper的值與 case '*' 匹配，所以會輸出乘積“18”。
switch 中的（變量）只能是3種類型：整型(如 int )、字符型( char )、字符串類型( string )。
程序連續(xù)的重復一個步驟稱為“循環(huán)”。循環(huán)可以簡化我們的代碼，減少冗余。例如，打印 1-10 的整數，我們可以寫 10 條打印語句，也可以這樣：
這個循環(huán)結構，會首先判斷 x<=10 ，條件為真時執(zhí)行循環(huán)體（“輸出x”和“x++”），之后，再次判斷條件 x<=10 ，若條件為真則繼續(xù)執(zhí)行循環(huán)體......若條件為假，則結束循環(huán)。
簡單的說，循環(huán)是由循環(huán)體（需要重復執(zhí)行的命令）和循環(huán)條件組成的。運行時，先判斷循環(huán)條件，若條件為 true ，就執(zhí)行循環(huán)體一次，然后再判斷條件...當條件為 false 時，結束循環(huán)。上面的流程圖，當變量 x 累加到 11 時，循環(huán)條件為 false ，循環(huán)就會結束。
C#中，可以用 while 循環(huán)結構來實現：
對比代碼和流程圖可知， while 循環(huán)結構中，循環(huán)條件寫在 () 中，循環(huán)體寫在 {} 中。運行結果：
這一節(jié)，我們學習用循環(huán)累加的方式求和。
上一節(jié)，我們曾經循環(huán)打印過 1-10 的整數，如果聲明一個變量，在打印的過程中，把每一個數字都累加到變量里面，就可以得到 1-10 的和。求和算法的基本步驟：
①聲明變量 sum 用來存儲“和”。 sum 的初始值賦為 0 。
②循環(huán)，用變量 x 訪問每一個數字，用 sum+=x 的方式累加。（即 sum=sum+x; ）
③循環(huán)結束后， sum 中存儲的即是和。
運行結果如下：
前面已經學習了 while 循環(huán)，C#中還有一種非常有用的 for 循環(huán)，特別適合于“已知循環(huán)次數”的循環(huán)。
比如，循環(huán)打印3次“我能行！”，用 while 循環(huán)可以這樣寫：
而用 for 循環(huán)這樣寫：
可以看出來， while 循環(huán)有的變量聲明、循環(huán)條件、變量自加， for 循環(huán)一個也不缺，但是 for 循環(huán)把這些跟循環(huán)次數有關的元素都放在 ( ; ; ) 中，使得{}中的循環(huán)體更加純粹，程序結構更加清晰。
* for 循環(huán) ( ; ; ) 中的兩個分號是不能缺少的。
for 循環(huán)運行時，首先進行變量聲明和賦值；接下來判斷循環(huán)條件，若條件為 true ，則執(zhí)行循環(huán)體一次，若條件為 false ，則結束循環(huán)；執(zhí)行循環(huán)體后，進行變量自加。然后會進入下一次循環(huán)。
C#中， do...while 循環(huán)也是一種常用的循環(huán)結構。循環(huán)結構各部分運行順序如下：
從上面的示意可以看出， do...while 循環(huán)第一次執(zhí)行循環(huán)體是沒有經過條件判斷的，也就是說會無條件的執(zhí)行一次循環(huán)體，此后的邏輯
順序就與while循環(huán)相同了——先判斷條件，條件為true再執(zhí)行循環(huán)體一次。請看下面的例子：
盡管循環(huán)條件始終為 false ，但由于 do...while 循環(huán)第一次執(zhí)行循環(huán)體不判斷條件，所以循環(huán)體還是執(zhí)行了一次。運行結果為：
我們已經學習了C#中最常用的三種循環(huán)結構，下面我們小小總結一下：
循環(huán)中可以應用 continue 關鍵字中止一次循環(huán)，直接進入下一次。請看下面的例子：
當程序執(zhí)行到到 continue; 的時候，會立即停止本次循環(huán)體，直接進入下一次循環(huán)。所以，第三行輸出比其他行少一些：
所以，可以使用 continue 關鍵字，在循環(huán)中剔除一些特殊的數據。
前面學習 switch 結構時，我們曾經遇到過 break 關鍵字， break 在 switch 結構的作用是“跳出 switch 結構”。
break 關鍵字還可以用在循環(huán)中，作用是“結束循環(huán)”。下面的循環(huán)代碼中，當 x==3 的時候會執(zhí)行 break ：
運行結果：
對比代碼和運行結果可知，當執(zhí)行到 break ，循環(huán)結束（盡管此時循環(huán)條件仍然為 true ）。
利用 break 關鍵字和 true 關鍵字，我們可以用另一種方式編寫循環(huán)，下面的代碼是輸出1-5的整數：
運行結果：
在一個循環(huán)體中包含另一個循環(huán)，稱為“嵌套循環(huán)”。當2個循環(huán)嵌套的時候，外層循環(huán)體執(zhí)行一次，內層循環(huán)體執(zhí)行 n 次（ n 是內層循環(huán)的次數）。請看下面的例子：
運行結果：
比較代碼和運行結果，我們發(fā)現，內層循環(huán)體執(zhí)行 3 次，外層循環(huán)體執(zhí)行 1 次。這就有點像鐘表上的時針和分針——時針走一格，分針走一圈。
下面一段代碼打印了一個矩形：
運行效果：
請思考一下，哪一個變量決定了每一行的循環(huán)次數， x 還是 y ？
編程中有這樣一種情形：我們需要存儲多個同類型數據。比如，保存 1600 個學生的年齡。是否需要聲明 1600 個 int 類型的變量？過了一年，學生們長了 1 歲，是否需要給每個變量重新賦值？這件事情，想想就怕怕。好在C#中有一種數組，專門存儲一組相同類型的數據。數組的聲明和初始化語法如下：
數據類型[ ] 數組名 = new 數據類型[長度];
注意：數組名像變量名一樣要遵循標識符的命名規(guī)則；長度必須是整數
下面我們來比較變量和數組的聲明與初始化，右邊是在內存中為變量和數組分配空間的示意：
對比變量 x 和數組 y 就會發(fā)現，數組 y 中其實包含了 3 個 double 類型的變量，為什么是 3 個？因為初始化數組時在 [ ] 中聲明的長度為 3 。既然都在數組 y 中，所以 3 個變量（應該叫數組元素）的名字都叫 y ，為了區(qū)分它們，按照順序給它們加上索引 [0]、[1]、[2] 。請注意：數組的索引從 0 開始遞增。那么，數組 y 中 3 個元素的名字就變成了 y[0]、y[1]、y[2] 。最后再注意一點：數組經過初始化以后，數組元素有默認的初始值， double 類型為 0.0 ， int 類型為 0 ， char 類型為 'a' ， bool 類型為 false ， string 類型為 null 。
數組元素的賦值與普通變量相同。下面的示例中，我們聲明了一個長度為 3 的 string 類型數組，逐個賦值，然后打?。?/p>
上例中，需要注意的是元素的索引，數組元素索引從 0 開始遞增，所以長度為 3 的數組，其元素索引為 [0]、[1]、[2] 。
如何知道一個數組的長度呢？ 數組.Length 屬性會返回數組的長度（即數組元素的個數）。請看下面的例子：
代碼中的 friends.Length 會返回 friends 數組的長度，請看運行結果：
上一節(jié)我們學習了數組的聲明和初始化，以及數組元素的訪問方法。其實，C#中數組元素有多種初始化方式，請看下例：
上例中，數組 a 的初始化方式我們已經學習過了；數組 b、c、d 是在初始化時為數組元素指定初始值，請注意數組 d 用 [3] 聲明了數組長度，后面 { } 中的初始值個數要與 [ ] 中聲明的長度相同。數組 b、c 初始化沒有聲明長度，長度由 { } 中的初始值個數確定。
上一節(jié)我們還學習了數組的一個屬性 Length ， Length 能夠返回數組的長度，利用它和數組元素的索引，我們可以循環(huán)訪問每一元素。上一節(jié)中打印名字的代碼，可以這樣改進：
Length 屬性返回數組的長度，如上例中，數組長度為 3 ， Length 就返回 3 ，即循環(huán)變量 i 從 0 循環(huán)到 2 。為什么不循環(huán)到 3 呢？因為數組元素的索引是從 0 開始的呀！長度為 3 的數組，索引為 0 - 2 。
通過上例，我們看到，使用數組就能循環(huán)訪問一組相同類型的變量了，是不是比使用單個變量要輕松呢？
for 循環(huán)使我們可以通過索引訪問數組元素；而 foreach 循環(huán)則可以不依賴索引而讀取每一個數組元素。下面的示例代碼聲明了一個整型數組，然后通過兩種方法打印數組元素：
運行結果是相同的：
使用 foreach 的語法：
需要解釋一下 ④ ，如上面的示例代碼，迭代變量 x 只能用于讀取數組 num 中的值，但是不能給數組元素賦值，如果嘗試給 x 賦值，則會有下面的錯誤提示：
了解了 foreach 循環(huán)的語法，你可能會有疑問：好像 foreach 循環(huán)能做的 for 都能做， foreach 存在的意義是什么呢？其實，C#中還存在一些類似于數組的數據組織方式，它們中有一些是沒有元素索引的，對于這些元素，只能通過 foreach 遍歷。關于那些更高級的對象，我們留待后面的課程介紹。
二維數組，就是以數組作為元素的數組。挺拗口的，看看它跟一維數組的對比：
左邊的 a 是一維數組，數組中包含 4 個 int 型變量：a[0]、a[1]、a[2]、a[3] 。
右邊的 b 是二維數組，數組中包含 2 個 int 型一維數組：b[0]、b[1] 。而 b[0] 和 b[1] 中又分別包含 3 個 int 型變量：b[0,0]、b[0,1]、b[0,2]、b[1,0]、b[1,1]、b[1,2] 。
總結一下，二維數組這樣聲明：
int[,] arr = new int[2,3]; //包含2個一維數組，每個一維數組包含3個變量，總共2*3=6個數組元素
二維數組元素這樣賦值和打印：
arr[1,0] = 28; //二維數組元素有2個索引，都是從0開始，以arr數組為例，元素索引從[0,0]到[1,2]Console.Write( arr[1,0] );
我們可以用二維數組管理相關的數據，比如有 4 名同學參加語文和數學兩門考試，我們用二維數組存儲他們的成績，每位同學的 2 門課分數，存儲在一個一維數組中：
運行結果如下：
通常C++中會對類中的屬性設置成private，然后對可以修改的對象單獨寫一個修改值的方法，但C#則大大簡化了這個步驟
這是C++、Java里面沒有的東西。
注意命名規(guī)則 _name ----> Name
C#z中：字段是類中原始的成員對象，通常是私有的，屬性是對字段的封裝，通常是公有的
class Child
{
private string _sex; //隱藏字段
public string Sex //公開屬性
{
get { return _sex; } //讀訪問器
set { _sex = value; } //寫訪問器
}
}使用：
Child LaoWang = new Child(); LaoWang.Sex = "male"; Console.WriteLine(LaoWang.Sex);
補充：字段封裝的快捷鍵： 光標放在字段內，CTRL + R + E
對Set訪問器進行檢查：
public string Sex //公開屬性
{
get
{
return _sex;
} //讀訪問器
set
{
if(value == "man" && value != "woman")
{
_sex = value;
}
} //寫訪問器
}使用：
Child child = new Child {Name = "小明", Age = 5};值類型： int char double bool ...
值類型變量存儲對象的值，賦值會創(chuàng)建值的副本，修改任何一個副本，都不會影響到其他的副本
引用類型： 類、數組、接口
struct class的區(qū)別：
struct不允許定義無參構造函數
默認訪問限定符不同
struct中可以不實例化而直接訪問成員方法
在下面這種情況：
class Child
{
public Child(String sex)
{
_sex = sex;
}
private String _sex;
public string Sex
{
get
{
return _sex;
}
set
{
if (value == "男" || value == "女")
{
_sex = value;
}
}
}
}這樣寫是沒有問題的，將性別限制成了“男”、“女”兩種情況
但如果是星座呢？ 星座有12種，難道要全部用if判斷嗎？
這個地方，就可以用枚舉
代碼如下：
enum Constell
{
白羊,水瓶,金牛,摩羯
}
class Child
{
Child(Constell con)
{
_con = con;
}
private Constell _con;
internal Constell Con
{
get
{
return _con;
}
set
{
_con = value;
}
}
}
和C++不同，默認傳遞方式取決于傳遞的參數是值類型還是引用類型
另外傳遞方式略有差異，需要在調用處和函數定義處均聲明，如：
MySwap(ref val1, ref val2);
（個人覺得這樣比C++好用許多）
out用來聲明參數為輸出型參數。
同樣，在函數的定義處和調用處，都要用out關鍵字聲明要修飾的變量
感謝你能夠認真閱讀完這篇文章，希望小編分享的“C#基礎知識的示例分析”這篇文章對大家有幫助，同時也希望大家多多支持億速云，關注億速云行業(yè)資訊頻道，更多相關知識等著你來學習!
免責聲明：本站發(fā)布的內容（圖片、視頻和文字）以原創(chuàng)、轉載和分享為主，文章觀點不代表本網站立場，如果涉及侵權請聯(lián)系站長郵箱：is@yisu.com進行舉報，并提供相關證據，一經查實，將立刻刪除涉嫌侵權內容。
