技術標籤：c＃

c ＃ 基礎入門

（純小白的學習記錄）
變數
常量
轉義字元
型別轉換
異常捕獲
算術運算子
條件分支語句
顯示轉換
資料變數型別
陣列
值型別和引用型別

變數

一、變數

1.變數的型別

有符號 所佔位元組數（位元組數越大，範圍越大）

sbyte（-128~127） 1
int（-21億多~21億多） 4
short（-3萬多~3萬多） 2
long （-9百萬兆多~9百萬兆多） 8

無符號 ----不能裝負數

byte （0~255) 1
uint （0~42億多） 4
ushort （0~6萬多） 2
ulong （0~18百萬兆多） 8

浮點數

float （7~8位有效數字） 4

特殊

bool （true 和false） 1
char （一個字元） 2
string （一串字元) 【該字串較為特殊，範圍可變】

2.變數的儲存空間
1byte = 8bit
1MB = 1024 byte
1GB = 1024MB
1TB = 1024 GB

通過sizeof 方法 可以獲取變數型別所佔的記憶體空間（單位：位元組）
（sizeof 是不能得到string 型別所佔的記憶體大小的，因為string字串的長度是可變的）

int sbyteSize= sizeof （sbyte）；
  Console.WriteLine("sbyte 所佔的位元組數為：” +sbyteSize）；
 

3.變數的本質是2進位制

計算機中所有資料的本質都是二進位制，實際上是一堆0和1
資料傳遞只能通過電訊號，只有開和關兩種，所以就用0和1 表示這兩種狀態

1bit就是一個數，要不是0要不是1，為了表示資料方便，出現一個叫bite（位元組）的單位，它是由8個bit組成的儲存單位，所以我們一般說一個位元組為8位

4.變數的命名規範

規則
1.不能重名
2.不能以數字開頭
3.不能使用程式關鍵字命名
4.不能有特殊符號,下劃線除外

*建議的命名規則 變數名要有含義，用英文表示變數的作用 ，儘量不用漢字

*命名法

駝峰命名法 （變數）
首字母小寫，之後單詞首字母大寫，相當於間隔的作用

帕斯卡命名法 （函式，類）

常量

二、常量

1.常量的申明
關鍵字 const
const 變數型別 變數名 = 初始值

常量的申明 const int i2 = 20；
變數的申明 int i = 10；

2.常量的特點
//變數的申明可以不初始化
string name；
//之後可以修改
name = “123”;
name = “345”;

3.常量的申明必須初始化，且不能被修改
const string myName = “肖戰”;
//常量的作用，申明一些常用的不變的量

轉義字元

三、 轉義字元

定義 它是字串的一部分，用來表示一些特殊含義的 字元，如在字串中表現單引號雙引號 空行等等

1.固定寫法 \字元
不同的 \和字元的組合，表示不同的含義

2.轉義字元，舉例單引號

  string str = "\'哈哈哈\'";
        Console.WriteLine(str);

單引號 ’
雙引號 "
換 行 \n
斜槓 \ (計算機檔案路徑 是要用到 \ 符號的）

不常用的轉義字元
製表符 tab鍵，快速空四格      \t
游標退格   \b
空字元      \0
警報音       \a

4.取消轉義字元

 string str2 = @"哈哈\哈哈”；
Console.WriteLine(str2);
 

本來\是不能在該字串中體現，但是現在加了@，打印出後就是 哈哈\哈哈

型別轉換

四、型別轉換（不用變數型別間的轉換）

       //隱式轉換----不同型別間的自動轉換
           大範圍裝小範圍

        //1.相同大型別之間的轉換
        //有符號  long  int  short   sbyte（範圍一次減小）
        long l = 1;
        int  i = 1;
        short s = 1;
        sbyte sb = 1;

        l = i ;
        //隱式轉換int 轉換成了long，可用大範圍裝小範圍， i= l  就不能實現

• decimal 這個型別 沒有辦法用隱式轉換去儲存float 和double，但是可以隱式儲存整形（有符號和無符號）；特殊型別（bool char string）之間不存在隱式轉換

       //2.不同大型別之間的轉換
        *無符號和有符號之間
       (1）無符號裝有符號(不能實現）
       //有符號的變數是不能隱式轉換成 無符號的
     （2）有符號裝無符號（可以）
       // 只要有符號的變數 都在無符號變數的範圍內
       *浮點數  可以裝任何型別 整數的
       *整數  不能裝浮點數
       *特殊型別 和其他型別之間 
       //bool沒有辦法和其他型別相互轉化 ；char 沒辦法隱式儲存其他型別的變數，但是可以隱式轉換成 整形和浮點型
      //char隱式轉換成數值型別，對應的數字其實是一個ASCII碼(百度搜），計算機裡儲存二進位制，字元中文英文標點符號在計算機中其實都是一個數字，一個字元對應一個數字，ASCII碼就是一種對應關係
  

  總結 double–>float—>整數（有符號，無符號）---->char
  decimal ---->整數（有符號，無符號）---->char
  string 和bool 不參與隱式轉換規則

異常捕獲

五、異常捕獲

//異常捕獲作用
//將玩家輸入的內容儲存 string 型別的變數（容器）中
string str = Console.ReadLine() ;
//Parse轉字串 為 數值型別時 必須要合法合規
int i = int.Parse(str);
//通過對異常捕獲的學習，可以避免當代碼報錯時，造成程式卡死的情況

         //必備部分
         try
         {
           //希望進行異常捕獲的程式碼塊
           //如果try中的程式碼 報錯了不會讓程式卡死
         }   
         catch
         {
              //如果出錯了  會執行  catch中的程式碼 來捕獲異常
              //catch(Exception e )具體報錯跟蹤 通過e得到 具體的錯誤資訊
         }
         //可選部分
         finally
         {
             //最後執行的程式碼  不管有沒有出錯 都會執行其中的程式碼
            // 目前可以不用
         }

            // try
            //{
            //    string str = Console.ReadLine();
            //    int i = int. Parse(str);
            //    Console.WriteLine(i);
            //}
            //catch
            //{
            //    Console.WriteLine("請輸入合法數字");
            //}

//注意 異常捕獲程式碼基本結構中 不需要加 ； 在裡面寫程式碼邏輯的時候 每句程式碼才要加 分號

算術運算子

六、算術運算子

1.賦值符號
//=
//先看右側 再看左側 把右側的值賦給左側的變數

2.算術運算子

// +

(1) 用自己計算 先算右側結果 再賦值給左側變數
int i = 1;
i = i +2;
(2)連續運算
(3)初始化就運算 先算右側結果 再賦值給左側變數
int i2 = 1+2+3;
Console.WriteLine(i2);

// 除法

  int chu = 1;
        chu = 10 / chu;
        Console.WriteLine(chu);

       預設的整數  是int型別  如果用來做除法運算  會丟失小數點後的小數
       如果想用浮點數來儲存 一定是 在運算的時有浮點數的特徵

  chu = 1;
        chu = 1 / 2;
        Console.WriteLine(chu);
        float f = 1 / 2f;
        Console.WriteLine(f);

//取餘 %

int y= 4;
y = y % 3;
Console.WriteLine(y);

3.算術運算子的優先順序

先乘除後加減

4.複合運算子

//固定寫法  運算子=
        // +=   -=  *=   %=
       // 複合運算子  用於  自己= 自己進行運算

  int i3 = 1;
        i3 += 2;// i3 = i3 + 2 ;
        Console.WriteLine(i3);

//複合運算子 只能進行一種運算 不能混合

5.算數運算子的自增減

 //自增運算子   讓自己+1
    a2 = 1;
    Console.WriteLine(a2++);//先用再加   //1
    //2
    Console.WriteLine(++a2);//先加再用    //3

//只有加減才有自增減

6.字串的拼接1

//之前的算術運算子只是用來數值型別變數進行數學運算的 //而string 不存在算術運算子 但是可以通過 + 號來進行字串 的拼接

string str = "123";
            str = str + "456";
            Console.WriteLine(str);
            str = str + 1;
            Console.WriteLine(str);

複合運算子

str = "123";
        str += "1" + 4 + true;
        Console.WriteLine(str);

        str += 1 + 2 + 3 + 4;
        Console.WriteLine(str);

        str +=  ""  + 1 + 2 + 3 + 4;
        Console.WriteLine(str);

        str = "";
        str += 1 + 2 + "" + (3 + 4);
        Console.WriteLine(str);

字串的拼接2

//固定語法
//string.Format(“待拼接的內容”,內容1,內容2,…);
//想要被拼接的內容用佔位符代替 {數字} 數字：0-n,依次往後

  string str2 = string.Format("我是{0}，我今年{1}歲，我想要{2}", "王垚", "18", "去重慶");
        Console.WriteLine(str2);

        //控制檯列印拼接
        //後面的內容比佔位符 多  不會報錯，比佔位符少 會報錯
        Console.WriteLine("A{0},B{1},C{2}", 1, 2, 3);
        Console .Write("A{0},B{1},C{2}", 1, 2, 3);

7.條件運算子

特殊噠 是否等於 == 是否不等於 ！=

//不能直接純比較不使用，那麼這對我們來說沒有意義
//比較的結果 返回的是 一個bool 型別的值
//true 和false 如果條件滿足 那就返回true 不滿足 就返回false

int a = 5;
int b = 10;
bool result = a > b;
Console.WriteLine(result);//false

8.邏輯運算子

//邏輯與
//符號 && 並且
//規則 對兩個bool值進行邏輯運算 有假則假 同真為真

   bool result = true && false;
            Console.WriteLine(result);
            result = true && true;
            Console.WriteLine(result);

        //bool 相關型別  bool變數
        //邏輯運算子優先順序  低於 條件運算子 算數運算子
        int i = 3;
        result = i > 1 && i < 5;
        Console.WriteLine(result);

//多個邏輯與 組合運用 在沒有括號的情況下 從左到右 依次看即可

//邏輯或
//符號 ||
// 規則 對兩個bool 值進行邏輯運算 有真則真 同假為假

  result = true || false;
        Console.WriteLine(result);

//邏輯非
//符號 ！
//規則 對一個bool 值進行取反 真變假 假變真

  result = !true;
        Console.WriteLine(result);

邏輯非的優先順序 較高

//混合使用優先順序問題
    // 規則  邏輯非 優先順序最高    邏輯與 優先順序 高於 邏輯非
    //邏輯運算子 優先順序 低於 算數運算子  條件運算子（邏輯非除外）

   //eg  
        bool gameOver = false;
        int hp = 100;
        bool isDead = false;
        bool isMustOver = true;
        result = gameOver || hp < 0 && !isDead || isMustOver;
        //       false || false && truje || true 
        //       false || false ||true 
        //        false ||true
        //        true

        //邏輯運算子短路規則
        // 只要 邏輯與 或者 邏輯或 左邊滿足了條件，右邊的內容 就不重要了

        //邏輯或  有真則真  左邊只要為真 右邊就不用管了，若左邊為假  仍需管右邊
        int i4 = 1;
        result = i4 > 0 || ++i4 >= 1;//只看 i4>0 為 真
        Console.WriteLine(result);
        //邏輯與  有假則假

9.位運算子

主要用 數值型別進行計算的
//將數值轉為 2進位制（除2取餘數） 再進行位運算

//位與 &
//規則 連線兩個數值 進行位計算 將數值轉為2進位制
//對位運算 有0則0

int c = 1;//001
int d = 5;//101
//   001
//&  101
//   001   (可以從右往左看   發現 最左邊的數有0，1  則 有0即0

int e = c & d;
Console.WriteLine(e);

//位或 |
//規則同上
//對位運算 有1則1

//異或 ^
//規則同上
//對位運算 相同為0 不同為1

位取反 ~
規則 寫再數值前面 將數值轉為2進位制
對位運算 0變1 1變0

 a = 5;
        //0000 0000 0000 0000 0000 0000 0000 0101 從（int 型別 完整的二進位制數）
        //1111 1111 1111 1111 1111 1111 1111 1010  （ 此數代表負數）
        //反碼補碼知識
        c = a;
        Console.WriteLine(c);

//左移 << 和 右移 >>
//規則 讓一個數的 2進位制數進行 左移和右移
//左移幾位 右側加幾個0
//右移幾位 右側去掉幾個數

 a = 5;//101
            c = a << 5;
            Console.WriteLine(c);

            // 1位 1010
            // 2位 10100
            // 3位 101000

10.三目運算子

套路 3個空位 2個符號
// bool型別 ? bool 型別為真返回內容 : bool型別為假返回內容:
//三目運算子 會有返回值 這個返回值型別必須一致 並且必須使用

 int m = 5;
        str = m < 1 ? "m大於1" : "m不滿條件";
        Console.WriteLine(str);

        //第一個空位 始終是結果為bool型別的表示式 bool變數 條件表示式 邏輯運算子表示式
        //第二個空位 什麼表示式均可 只要保證他們的結果型別是一致的

條件分支語句

七、條件分支語句

讓順序執行的程式碼 產生分支

1.if語句

//if
//作用 滿足條件時 多執行一些程式碼
//語法
//if (bool型別值) //bool型別相關： bool變數 條件運算子表示式 邏輯運算子表示式
// {
// 滿足條件要執行的程式碼
// }
//注意
//if 語句的語法部分 不需要寫分號
// if 語句可以巢狀使用

   if (true)
        {
            Console.WriteLine("肖戰真好看");
        }
        Console.WriteLine("肖戰非常好看");

 //巢狀使用(可無限）
    string name = "if you";
    string passWord = "666";
    if (name == "if you" && passWord == "666") ;
    {
        Console.WriteLine("使用者名稱驗證成功");
        if (passWord == "666") ;
        {
            Console.WriteLine("密碼驗證成功");
        }

    }

//if else
//作用 產生兩條分支 滿足條件做什麼 不滿足條件做什麼

語法
        //if （bool型別值）
        // {
        //  滿足條件執行的程式碼；
        //}
        //else
        //{
        //  不滿足條件執行的程式碼；
        //}

if (true)
{
Console.WriteLine(“想去重慶”); //上面為 true 就執行這個
}
else
{
Console.WriteLine(“好想去重慶”); //上面為 false 就執行這個
}

        //if...  else if   ...else
        //if  (bool型別值)
        //{
        //滿足條件執行的程式碼
        //}
        //else if  （bool型別值）
        //{
        //滿足條件執行的程式碼
        // }
        //else
        //{
        //不滿足條件執行的程式碼
        //}

else 是可以省略的
//注意 條件判斷 從上到下執行 滿足了第一個以後 後面的都不會執行了

2.switch語句
//作用 讓順序執行的程式碼 產生分支

//switch (變數)
//{
// 變數 == 常量 執行 case 和 break 之間的程式碼
// case 常量:（這是冒號）
// 滿足條件執行的程式碼邏輯;
// break;
// default:(這是冒號）
// 如果上面case 的條件都不滿足 就會執行 default 中的程式碼
// break;
//}

//常量 只能寫一個值 不能寫一個範圍，如條件運算子 邏輯運算子一類
//switch 只判斷 變數是否等於某一個固定值

  int k = 3;
             switch (k)
             {
                 case 1:            //case 後一定是常量
                     Console.WriteLine("k等於1");
                     break;
                 case 2:
                     Console.WriteLine("k等於2");
                     break;
                 case 3:
                     Console.WriteLine("k等於3");
                     break;
                 default:
                     Console.WriteLine("什麼條件都不滿足 執行default 中的內容");
                     break;
 
             }
             //上述中k不等於3時 就直接執行default 
             //default 可以省略  ，是在你default中什麼都不想強調的時候
 
 

  可以自定義常量
        //規則1.必須初始化 2.不能修改
        char p = 'A';
        const char c2 = 'A';
        //下面寫switch語句

//貫穿
//作用 滿足某些條件時 做的事情是一樣的 就可以貫穿

不寫case 後面配對的break 就叫做貫穿

 int aa = 1;
        switch (aa)
        {
            case 1:
            case 2:
            case 3:
                Console.WriteLine("啊哈");
                break;
            default:
                break;
        }

3.while 語句
// 作用 可以不停的 迴圈執行某一程式碼塊的內容，區別於條件分支語句（讓程式碼產生分支）

//while (bool 型別的值）
// {
//滿足條件的時候 會執行 while 語句塊中的內容
//…
//當代碼邏輯執行完 會回到while 迴圈開頭 再次進行條件判斷
// }
//Console.WriteLine (“主程式碼邏輯”)

//死迴圈
//*只在目前學習控制檯程式時 頻繁使用，之後用unity時 基本不用死迴圈
//1.可能因為記憶體問題 造成程式崩潰 閃退 2.造成程式卡死

        //死迴圈舉例
        //  while  (true)
        //{
        //    Console.WriteLine("*******");
        //    Console.WriteLine("請玩家輸入使用者名稱密碼");
        //    Console.ReadLine();
        //}


        //非死迴圈
        // 計算一個為 0的 整形變數 讓他只能累加1，不停的加到10為止

        int j = 0;
        while (j < 10)
        {
            ++j;
        }
        Console.WriteLine(j);

while 可巢狀

int a4 = 0;
while (a4 < 10) ;
{
    ++a4;
    int b2 = 0;
    while (b2 < 10)// 這裡迴圈的b2和上一行中的b2 沒有關係
    {
        ++b2;
    }
}

        //流程控制關鍵詞
        //作用  控制迴圈邏輯的關鍵詞

break 跳出迴圈

 while (true)
        {
            Console.WriteLine("啦啦啦啦我最可愛");
            break;//之後程式碼不再進行
        }

        int o = 0;
        while (true)
        {
            ++i;
            Console.WriteLine(o);
            if (o == 10)
            {
                break;//break只與 while ，switch 配套 ，與if 沒有關係，這裡if 中的break 會直接跳出整個程式碼塊
            }
        }
        Console.WriteLine(o);

continue 回到迴圈開始 繼續執行

 while (true)
        {
            Console.WriteLine("嘿嘿 喜歡帥哥");
            continue; // 不會跳出程式碼塊 而是返回迴圈
        }

迴圈語句 do… while

        //while迴圈 先判斷條件再執行
        //do while迴圈 先斬後奏 先至少執行一次迴圈語句塊中的邏輯 再判斷是否繼續

        // do
        // {
        //    //do while 迴圈語句塊
        //  } while (bool型別的值);

int f1 = 1;
do
{
    Console.WriteLine(" f1");
} while (f1 < 2);

        do
        {
            Console.WriteLine(" f1");
            continue;//   這裡的continue 不回到do  而是先往下執行到while
        } while (false);

4.for 迴圈

//for (/初始表示式/;/條件表示式/;/增量表達式/ )
//{
//迴圈程式碼邏輯;
// }

// 初始表示式 一般宣告一個臨時變數 用來計數用
// 條件表示式 表明進入迴圈的條件 一個bool 型別的結果（bool 變數 條件運算子 條件運算子）
// 增量表達式 用第一個空中的變數 進行 自增減運算

//只有第一次進入迴圈的時候 才會呼叫 第一個空中的程式碼
//每次進入迴圈之前 都會判斷第二個空中的條件 滿足才會進入迴圈邏輯

        for (int i8 = 0; i8 < 10; i8++)
        {
            Console.WriteLine(i8);
        }
        //最後打印出來 是0-9的數



        //實際上 規則很簡單
        //第一個空位 申明變數 也可連續申明
        //第二個空位 進入條件 只要是bool 結果的表示式都可以
        //第三個空位 執行一次迴圈邏輯後要做的事情 

支援巢狀

        for (int m1=0; m1<0; m1++)
        {
            for (int g = 0; g < 10; g++) 
            {
                Console .WriteLine ( m1 +"_" + g );
            }
        }

        //特殊寫法     平常儘量不要這樣寫  這 三個空可以都空著
        // for 迴圈可以寫死迴圈
        for (; ; )
        {
            Console.WriteLine("for 迴圈的死迴圈");

        }

        int k1 = 0;
        for (; k1<10; )
        {
            ++k1;
        }


        for ( k = 0; ; ++k)
        {
            if (k >= 10)
            {
                break;
            }
        }

對比 whlie 迴圈
//for 迴圈 一般用來準確得到 一個範圍中的所有數 經常使用的是for 迴圈

顯示轉換

八、顯示轉換 （手動處理 強制轉換）

1.括號強轉

//作用 一般情況下 將高精度的型別轉換為低精度
//注意；精度問題以及 範圍問題

相同大類的整形

有符號整形 sbyte sb = 1; short s = 1; int i = 1; long l = 1;

s = (short) i ;
Console.WriteLine(s);//括號強轉 的時候  可能會出現範圍問題造成的異常

無符號整形 byte b = 1; uint ui = 1; b = (byte)ui;

浮點之間
float f = 1.1f;
double d =1.12121333f;
-----f = (float)d;
-----Console.WriteLine(f);

無符號和有符號
unit ui2 = 1;
int i2 = 1;
—ui2 = (unit)i2;
—Console.WriteLine(ui2);

浮點和整形（浮點資料強轉成整形時，會直接拋棄小數點後邊的小數）
i2 = (int)1.64f;
Console.WriteLine(i2);

char 和數值型別
i2 = ‘A’;
char c =(char）i2；
Console.WriteLine©;

bool和string
（不能通過括號強轉）

2.Parse法

//作用 把字串型別轉換為對應型別，必須，否則報錯

// 變數型別 . Parse（”字串“）；

//有符號
int i4 = int.Parse(“123”);
Console.WriteLine(i4);

3.Convert法

作用 更準確的將各個型別之間進行相互轉化，精度比括號強轉好一點，會四捨五入

語法 Convert.To目標型別（變數或常量）

轉字串 如果是把字串轉成對應型別 那字串一定要合法合規 把bool型別可以轉化 數值型別 true對應1， false對應0

sbyte sb5 = Convert.ToSByte(“1”);
short s5 = Convert.ToInt16(“1”);
int i5 = Convert.ToInt32(“1”);
long l5 = Convert.ToInt64(“1”);

byte b6 = Convert.ToByte(“1”);
ushort us5 = Convert.ToUInt16(“1”);
uint ui5 = Convert.ToUInt32(“1”)；
ulong ul5 = Convert.ToUInt64(“1”);

float f5 = Convert.ToSingle(“13.2”);
double f5 =Convert.ToDouble(“13.2”);
decimal de5 = Convert.ToDecimal(“13.2”);

bool boS = Convert.ToBoolean(“true”);
char c5 = Convert.ToChar(“A”);

string strS = Convert.Tostring(123123);

4.其他型別轉string

作用 ： 拼接列印

語法： 變數 . toString（）；

當我們進行字串拼接時，就會自動呼叫 tostring 轉換成string
Console.WriteLine(“123123” + 1 + true);

資料變數型別

九、 資料變數型別

無符號變數 byte ushort uint ulong
有符號變數 sbyte short int long
浮點數 float double decimal
特殊型別 bool char string

變數本質
1byte = 8bit

複雜資料型別

特點
1.資料集合
一般是多個數據集合在一起構成的資料
2.自定義
一般可以自己取名字，可以自定義的資料（變數）

列舉：整形常量的集合，可以自定義
陣列：任意變數型別順序儲存的資料
結構體：任意變數的資料集合，可以自定義

1.列舉

***申明列舉***

enum E_PlayerType
{
    Main,//0   列舉項預設值為0
    Other,//1
}
enum E_MonsterType
{
    Norma,
    Boss,
}

列舉和switch是天生一對

   E_PlayerType playerType = E_PlayerType.Main;
        if (playerType == E_PlayerType.Main)
        {
            Console.WriteLine("主玩家邏輯");
        }
        else if (playerType == E_PlayerType.Other)
        {
            Console.WriteLine("其他玩家邏輯");
        }

//但是一般不用if ，列舉與switch是天生一對，可自動填充，比較簡便

//列舉轉int
        int i = (int)playerType; //()強轉
        Console.WriteLine(i);

        //int也可轉列舉，不常用
        playerType = 0;

        //列舉轉string
        string str = playerType.ToString();//生成時是把列舉項的名字轉換成string，很少使用
        Console.WriteLine(str);

        //string轉列舉
        
        //Parse後第一個引數； 你要轉為的是哪個列舉型別  第二個引數；用於轉換的對應列舉項的字串
        //轉換完成後 是一個通用的型別 我們需要用括號強轉成我們想要的目標列舉型別
        playerType = (E_PlayerType)Enum.Parse(typeof(E_PlayerType), "Other");
        Console.WriteLine(playerType);

        列舉的作用
        在遊戲開發中，物件很多時候有許多狀態
        比如玩家 有一個動作狀態 我們需要用一個變數或者標識，來表示當前玩家處於的是哪種狀態
        綜合考慮 可能會用int來表示它的狀態
        行走，待機，跑步這些
        列舉可以幫助我們  清晰的分清楚狀態的含義

陣列

十、陣列

陣列是儲存一組相關型別資料的集合，分為，一維，多維，交錯陣列
一般情況下，陣列都是一維陣列

1.陣列的申明

變數型別[] 陣列名

只是申明瞭一個數組，但是沒有開房； 變數型別 可以是我們學過的，也可以是我們沒學過的變數型別

        int[] arr1;

變數型別[] 陣列名 = new 變數型別 [陣列的長度]；
int[] arr2 = new int[5];//這種方式 相當於開了5個房間 但是房間裡面的int值 預設為0

變數型別[] 陣列名 = new 變數型別 [陣列的長度] {內容1，內容2，…}；
int[] arr3 = new int[5] { 1, 2, 3, 4, 5 };
int[] arr4 = new int[] { };

變數型別[] 陣列名 = {內容1，內容2，…}；
int[] arr5 = { 1, 2, 3, 4, 5 };

2.陣列的使用
int[] array = { 1, 2, 3, 4, 5 };

1.陣列的長度   Length

 Console.WriteLine(array.Length);

2.獲取陣列中的元素
陣列中的下標和索引 他們是從0開始的
通過 索引下標去 獲得陣列中某一個元素的值時，要注意 不能越界(陣列的房間號範圍時 0~Length -1）

     Console.WriteLine(array[0]);//1
     Console.WriteLine(array[2]);//3
     Console.WriteLine(array[4]);//5

3.修改陣列中的元素

     array[0] = 99;

>             Console.WriteLine(array[0]);

4.遍歷陣列 通過迴圈 快速獲取陣列中的每一個元素

  Console.WriteLine("**************");
        for (int i = 0; i < array.Length; i++)
        {
            Console.WriteLine(array[i]);
        }

5.增加陣列的元素
//陣列初始化後 是不能夠 直接新增新的元素的

Console.WriteLine("**************");
        int[] array2 = new int[6];
        //搬家
        for (int i = 0; i < array.Length; i++) 
        {
            array2[i] = array[i];
        }
        array = array2;
        for (int i = 0; i < array.Length; i++) 
        {
            Console.WriteLine(array[i]);
        }
        array[5] = 999;

6.刪除陣列的元素
陣列初始化以後 是不能 直接刪除元素的
依舊是搬家的原理

Console.WriteLine("**************");
        int[] array3 = new int[5];
        for (int i = 0; i < array3.Length ; i++)
        {
            array3[i] = array[i];
        }
        array = array3;
        for (int i = 0; i < array3.Length; i++)
        {
            Console.WriteLine(array[i]);
        }

7.查詢陣列中的元素
//99 2 3 4 5
//要查詢 3這個元素在哪個位置
//只有通過遍歷才能確定 陣列中 是否儲存了一個目標元素

    int a = 3;
            for (int i = 0; i < array.Length ; i++)
            {
                if (a == array[i])
                {
                    Console.WriteLine("和a相等的元素在{0}索引位置", i);
                    break;
                }
            }

        //總結
        //1.概念  同一變數型別的資料集合
        //2.申明  遍歷 增刪查改
        //3.所有的變數型別都可以申明為  陣列
        //4.他是用來批量儲存遊戲中的用以型別物件的  容器

3.二維陣列

基本概念
使用兩個下標（索引）來確定元素的陣列
兩個下標可以理解成 行標 和 列標
//eg 矩陣
//1 2 3
//4 5 6
//可以用二維陣列 int[2,3]表示
//好比 兩行 三列 的資料集合

1.二維陣列的申明

 int[,] arr02 = new int[3, 3];
 // 變數型別[,] 二維陣列變數名 = new 變數型別 [ 行，列 ] {  {0行內容1，0行內容2.....}{0行內容1，0行內容2....} ...}

 int[,] arr03 = new int[3, 3] { { 1 , 2 ,3},
                                { 4 , 5, 6 },
                                { 7 , 8 ,9 } };

  //或
 int[,] arr04 = new int[,] { { 1 , 2 ,3},
                             { 4 , 5, 6 },
                             { 7 , 8 ,9 } };
  //或
 int[,] arr05 =  { { 1 , 2 ,3},
                   { 4 , 5, 6 },
                   { 7 , 8 ,9 } };

2.二維陣列的長度

        int[,] array06 = new int[,] { { 1,2,3 },
                                      { 4,5,6 } };

 我們要獲取  行和列分別是多少

   得到多少行
            Console.WriteLine(array.GetLength(0));
            //得到多少列
            Console.WriteLine(array.GetLength(1));

3.獲取二維陣列中的元素

//注意； 第一個元素的索引是0，  最後一個元素的索引肯定是 長度-1
    Console.WriteLine(array06[0,1]);
    Console.WriteLine(array06[1,2]);

4 .修改二維陣列中的元素

 array06[0, 0] = 99;
        Console.WriteLine(array06[0, 0]);
        Console.WriteLine("****************");

5.遍歷二維陣列

   for (int i = 0; i < array.GetLength (0); i++)
    {
        for (int j = 0; j < array.GetLength(1); j++)
        {
            //i  行 0 1 
            //j  列 0 1 2
            Console.WriteLine(array06[i, j]);
            // 0,0  0,1  0,2
            // 1,0  1,1  1,2

        }
    }

6.增加啊陣列的元素

不能在原有的基礎上直接新增或刪除
            int[,] array07 = new int[3, 3];
            for (int i = 0; i < array.GetLength(0) ; i++)
            {
                for (int j = 0; j < array.GetLength(1) ; j++)
                {
                    array07[i, j] = array06[i, j];
                }
            }
            array06 = array07;
            array06[2, 0] = 7;
            array06[2, 1] = 8;
            array06[2, 2] = 9;
            Console.WriteLine("**************");

//總結
//1.概念 同一變數型別的 行列 資料集合
//2.所有的變數型別都可以宣告為 二維陣列
//3.遊戲中一般用來 儲存 矩陣 控制檯小遊戲中表示地圖格子

4. 交錯陣列（很少用到）
//交錯陣列 是陣列的陣列 每個維度的數量可以不同
//可以儲同一型別的m行不確定列的資料

        //交錯陣列的申明
        //int[][] arr7;

        //變數型別[][] 交錯陣列名  =  new 變數型別 [行數][]{一堆陣列1，一堆陣列2.....}
        int[][] arr8 = new int[3][];


        int[][] arr9 = new int[3][] {new int[] {1,2,3} 
 ,                                   new int[]{1,2 },
                                     new int[]{1   } };

        //陣列的使用
        int[][] arrray = { new int [] {1,2,3},
                           new int []{4,5}};

        //1.陣列的長度
        //行
        Console.WriteLine(array.GetLength(0));
        //得到某一行的列數
        // Console.WriteLine(array[0].Length);

        //2.獲取交錯陣列中的元素
        // Console.WriteLine(array[0][1]);

        //3.修改交錯陣列中的元素
        //array[0][1] = 99;
        //Console.WriteLine(array[0][1]);

        //4.遍歷交錯陣列
        //for (int i = 0; i < array.GetLength(0); i++)
        //{
        //    for (int j = 0; j <array[i].Length; j++)
        //    {
        //        Console.WriteLine(array[i][j] + " ");
        //    }
        //    Console.WriteLine();
        //}

值型別和引用型別

十一、值型別和引用型別

        //變數型別複習
        無符號整形
        //byte b = 1;
        //ushort us = 1;
        //uint ui = 1;
        //ulong u1 = 1;

        有符號整形
        //sbyte sb = 1;
        //short s = 1;
        //int i = 1;
        //long l = 1;

        浮點數
        //float f = 1f;
        //double d = 1.1;
        //decimal de = 1.1m;

        特殊型別
        //bool bo = true;
        //char c = 'A';
        //string str = "strs";

        //複雜資料型別
        //enum 列舉
        //陣列（一維  二維  交錯）

把以上 學過的 變數型別 分成 值型別和引用型別
引用型別 string 陣列 類
值型別 無符號整形 有符號整形 浮點數 char bool 結構體

     //值型別和引用型別的區別

1.使用上的區別

值型別
int a = 10;
引用型別
int[] arr = new int[] { 1, 2, 3, 4 };

 //申明瞭一個b讓其等於之前的a
int b = a;
   //申明瞭一個 arr2 讓其等於之前的  arr
int[] arr2 = arr;
 Console.WriteLine("a = {0}, b = {1}", a, b);
 Console.WriteLine("arr[0] = {0} , arr2[0] = {1}", arr[0], arr2[0]);

  b = 20;
  arr2[0] = 5;
  Console.WriteLine("修改了b和arr2{0}之後");
  Console.WriteLine("a = {0}, b = {1}", a, b);
  Console.WriteLine("arr[0] = {0} , arr2[0] = {1}", arr[0], arr2[0]);

值型別 在相互賦值時 把內容拷貝給了對方 它變我不變
引用型別的相互賦值 時讓兩者指向同一個值 它變我也變

2.為什麼有以上區別
值型別 和 引用型別 儲存在的 記憶體區域 是不同的 儲存方式是不同的
值型別 儲存在 棧空間 – 系統分配，自動回收，小而快
引用型別 儲存在 堆空間 – 手動申請和釋放，大而慢

arr2 = new int[] { 99, 3, 2, 1 };
        Console.WriteLine("arr[0] = {0} , arr2[0] = {1}", arr[0], arr2[0]);
        //new 了就是新開了房間 和之前沒有什麼關係了 所以arr 不會有任何變化

  //特殊的引用型別string

        // string str1 = "123";
        // string str2 = str1;
        //因為string 是 引用型別 按理說 應該是它變我也變
        //但string 很特殊 它具備 值型別的特徵  它變我不變
        //str2 = "321";

        //Console.WriteLine(str1);
        //Console.WriteLine(str2);

//string 雖然方便 但是有一個小缺點 就是頻繁的 改變 string 重新賦值
//會產生 記憶體垃圾
//優化替代方案 以後講解

 通過斷點除錯  在監視視窗檢視 記憶體資訊
 使用除錯程式時，可以中斷程式的執行以檢查程式碼、檢查和編輯變數、檢視暫存器、檢視從原始碼建立的指令，以及檢視應用程式佔用的記憶體空間