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 

值类型和引用类型

十一、值类型和引用类型

        //变量类型复习
        无符号整形
        //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 重新赋值
//会产生 内存垃圾
//优化替代方案 以后讲解

 通过断点调试  在监视窗口查看 内存信息
 使用调试程序时，可以中断程序的执行以检查代码、检查和编辑变量、查看寄存器、查看从源代码创建的指令，以及查看应用程序占用的内存空间