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 重新赋值
//会产生 内存垃圾
//优化替代方案 以后讲解
通过断点调试 在监视窗口查看 内存信息
使用调试程序时，可以中断程序的执行以检查代码、检查和编辑变量、查看寄存器、查看从源代码创建的指令，以及查看应用程序占用的内存空间