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
double （15~17位有效數字） 8
decimal （27~28位有效數字） 16

特殊

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 重新賦值
//會產生 內存垃圾
//優化替代方案 以後講解

 通過斷點調試  在監視窗口查看 內存信息
 使用調試程序時，可以中斷程序的執行以檢查代碼、檢查和編輯變量、查看寄存器、查看從源代碼創建的指令，以及查看應用程序佔用的內存空間