一、枚举
(一)枚举的声明
enum E_自定义枚举名
{
自定义枚举项名字 = 5, // 第一个枚举项的默认值,变成5了
自定义枚举项名字1, // 6
自定义枚举项名字2 = 100,
自定义枚举项名字3, // 101
自定义枚举项名字4, // 102
}
(二)枚举的类型转换
枚举 -->
int:var i = (int) playerType;
枚举 -->
string:var str = playerType.ToString();
string -->
枚举:
// Parse 第一个参数:你要转为的是哪个枚举类型
// 第二个参数:用于转换的对应枚举项的字符串
// 转换完毕后 是一个通用的类型 我们需要用括号强转成我们想要的目标枚举类型
playerType = (E_PlayerType) Enum.Parse(typeof(E_PlayerType), "Other");
二、一维数组
(一)数组的声明
// 变量类型[] 数组名;
// 只是申明了一个数组 但是并没有开房
// 变量类型 可以是我们学过的 或者 没学过的所有变量类型
int[] arr1;
// 变量类型[] 数组名 = new 变量类型[数组的长度];
var arr2 = new int[5]; //这种方式 相当于开了5个房间 但是房间里面的int值 默认为0
// 变量类型[] 数组名 = new 变量类型[数组的长度]{内容1,内容2,内容3,.......};
var arr3 = new int[5] {
1, 2, 3, 4, 5 };
// 变量类型[] 数组名 = new 变量类型[]{内容1,内容2,内容3,.......};
int[] arr4 = {
1, 2, 3, 4, 5, 6, 7, 8, 9 }; //后面的内容就决定了 数组的长度 “房间数”
// 变量类型[] 数组名 = {内容1,内容2,内容3,.......};
int[] arr5 = {
1, 3, 4, 5, 6 }; //后面的内容就决定了 数组的长度 “房间数”
bool[] arr6 = {
true, false };
(二)数组的使用
int[] array = {
1, 2, 3, 4, 5 };
// 1.数组的长度
// 数组变量名.Length
Console.WriteLine(array.Length);
// 2.获取数组中的元素
// 数组中的下标和索引 他们是从0开始的
// 通过 索引下标去 获得数组中某一个元素的值时
// 一定注意!!!!!!!!
// 不能越界 数组的房间号 范围 是 0 ~ Length-1
Console.WriteLine(array[0]);
Console.WriteLine(array[2]);
Console.WriteLine(array[4]);
// 3.修改数组中的元素
array[0] = 99;
Console.WriteLine(array[0]);
// 4.遍历数组 通过循环 快速获取数组中的每一个元素
for (var i = 0; i < array.Length; i++) Console.WriteLine(array[i]);
// 5.增加数组的元素
// 数组初始化以后 是不能够 直接添加新的元素的
var array2 = new int[6];
// 搬家
for (var i = 0; i < array.Length; i++) array2[i] = array[i];
array = array2;
for (var i = 0; i < array.Length; i++) Console.WriteLine(array[i]);
array[5] = 999;
// 6.删除数组的元素
// 数组初始化以后 是不能够 直接删除元素的
// 搬家的原理
var array3 = new int[5];
//搬家
for (var i = 0; i < array3.Length; i++) array3[i] = array[i];
array = array3;
Console.WriteLine(array.Length);
// 7.查找数组中的元素
// 99 2 3 4 5
// 要查找 3这个元素在哪个位置
// 只有通过遍历才能确定 数组中 是否存储了一个目标元素
var a = 3;
for (var i = 0; i < array.Length; i++)
if (a == array[i])
{
Console.WriteLine("和a相等的元素在{0}索引位置", i);
break;
}
三、二维数组
(一)数组的声明
//变量类型[,] 二维数组变量名;
int[,] arr; //申明过后 会在后面进行初始化
//变量类型[,] 二维数组变量名 = new 变量类型[行,列];
var arr2 = new int[3, 3];
//变量类型[,] 二维数组变量名 = new 变量类型[行,列]{ {0行内容1, 0行内容2, 0行内容3.......}, {1行内容1, 1行内容2, 1行内容3.......}.... };
var arr3 = new int[3, 3] {
{
1, 2, 3 },
{
4, 5, 6 },
{
7, 8, 9 }
};
//变量类型[,] 二维数组变量名 = new 变量类型[,]{ {0行内容1, 0行内容2, 0行内容3.......}, {1行内容1, 1行内容2, 1行内容3.......}.... };
int[,] arr4 = new int[,] {
{
1, 2, 3 },
{
4, 5, 6 },
{
7, 8, 9 }
};
//变量类型[,] 二维数组变量名 = { {0行内容1, 0行内容2, 0行内容3.......}, {1行内容1, 1行内容2, 1行内容3.......}.... };
int[,] arr5 = {
{
1, 2, 3 },
{
4, 5, 6 },
{
7, 8, 9 }
};
(二)数组的使用
int[,] array = {
{
1, 2, 3 },
{
4, 5, 6 }
};
// 1.二维数组的长度
// 我们要获取 行和列分别是多长
// 得到多少行
Console.WriteLine(array.GetLength(0));
// 得到多少列
Console.WriteLine(array.GetLength(1));
// 2.获取二维数组中的元素
// 注意:第一个元素的索引是0 最后一个元素的索引 肯定是长度-1
Console.WriteLine(array[0, 1]);
Console.WriteLine(array[1, 2]);
// 3.修改二维数组中的元素
array[0, 0] = 99;
Console.WriteLine(array[0, 0]);
// 4.遍历二维数组
for (var i = 0; i < array.GetLength(0); i++)
for (var j = 0; j < array.GetLength(1); j++)
// i 行 0 1
// j 列 0 1 2
Console.WriteLine(array[i, j]);
// 0,0 0,1 0,2
// 1,0 1,1 1,2
// 5.增加数组的元素
// 数组 声明初始化过后 就不能再原有的基础上进行 添加 或者删除了
var array2 = new int[3, 3];
for (var i = 0; i < array.GetLength(0); i++)
for (var j = 0; j < array.GetLength(1); j++)
array2[i, j] = array[i, j];
array = array2;
array[2, 0] = 7;
array[2, 1] = 8;
array[2, 2] = 9;
for (var i = 0; i < array.GetLength(0); i++)
for (var j = 0; j < array.GetLength(1); j++)
// i 行 0 1
// j 列 0 1 2
Console.WriteLine(array[i, j]);
// 0,0 0,1 0,2
// 1,0 1,1 1,2
// 6.删除数组的元素
// 同上
// 7.查找数组中的元素
// 如果要在数组中查找一个元素是否等于某个值
// 通过遍历的形式去查找
四、交错数组
(一)数组的声明
// 变量类型[][] 交错数组名;
int[][] arr1;
// 变量类型[][] 交错数组名 = new 变量类型[行数][];
var arr2 = new int[3][];
// 变量类型[][] 交错数组名 = new 变量类型[行数][]{ 一维数组1, 一维数组2,........ };
var arr3 = new int[3][] {
new[] {
1, 2, 3 },
new[] {
1, 2 },
new[] {
1 }
};
// 变量类型[][] 交错数组名 = new 变量类型[][]{ 一维数组1, 一维数组2,........ };
int[][] arr4 = {
new[] {
1, 2, 3 },
new[] {
1, 2 },
new[] {
1 }
};
// 变量类型[][] 交错数组名 = { 一维数组1, 一维数组2,........ };
int[][] arr5 = {
new[] {
1, 2, 3 },
new[] {
1, 2 },
new[] {
1 }
};
(二)数组的使用
int[][] array = {
new[] {
1, 2, 3 },
new[] {
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 (var i = 0; i < array.GetLength(0); i++)
{
for (var j = 0; j < array[i].Length; j++) Console.Write(array[i][j] + " ");
Console.WriteLine();
}
// 5.增加交错数组的元素
// 6.删除交错数组的元素
// 7.查找交错数组中的元素
五、值与引用
-
值类型——它变我不变——存储在栈内存中
无符号整形、有符号整形、浮点数、char、bool、结构体
-
引用类型——它变我也变——存储在堆内存中
数组(一维、二维、交错)、string、类
string 是引用类型,按理说应该是它变我也变。但它具备值类型的特征——它变我不变
六、函数
// 1 2 3 4
// static 返回类型 函数名(参数类型 参数名1, 参数类型 参数名2, .......)
// {
// 函数的代码逻辑;
// 函数的代码逻辑;
// 函数的代码逻辑;
// .............
// 5
// return 返回值;(如果有返回类型才返回)
// }
// 1. 关于static 不是必须的 在没有学习类和结构体之前 都是必须写的
// 2-1. 关于返回类型 引出一个新的关键字 void(表示没有返回值)
// 2-2. 返回类型 可以写任意的变量类型 14种变量类型 + 复杂数据类型(数组、枚举、结构体、类class)
// 3. 关于函数名 使用帕斯卡命名法命名 myName(驼峰命名法) MyName(帕斯卡命名法)
// 4-1. 参数不是必须的,可以有0~n个参数 参数的类型也是可以是任意类型的 14种变量类型 + 复杂数据类型(数组、枚举、结构体、类class)
// 多个参数的时候 需要用 逗号隔开
// 4-2. 参数名 驼峰命名法
// 5. 当返回值类型不为void时 必须通过新的关键词 return 返回对应类型的内容 (注意:即使是void也可以选择性使用return)
七、ref 与 out
ref 和 out 的作用:解决值类型和引用类型在函数内部改值或者重新申明,能够影响外部传入的变量,让其也被修改的问题
使用上:就是在申明参数的时候,前面加上 ref和out的 关键字即可 使用时 同上
区别:
ref 传入的变量必须初始化,但是在内部 可改可不改
out 传入的变量不用初始化,但是在内部 必须修改该值(必须赋值)
八、变长参数和默认值
// 变长参数关键字 params
private static int Sum(params int[] arr) {
var sum = 0;
for (var i = 0; i < arr.Length; i++) sum += arr[i];
return sum;
}
// params int[] 意味着可以传入n个int参数 n可以等于0 传入的参数会存在arr数组中
// 注意:
// 1.params关键字后面必为数组
// 2.数组的类型可以是任意的类型
// 3.函数参数可以有 别的参数和 params关键字修饰的参数
// 4.函数参数中只能最多出现一个params关键字 并且一定是在最后一组参数 前面可以有n个其它参数
private static void Eat(string name, int a, int b, params string[] things) {
}
// 有参数默认值的参数 一般称为可选参数
// 作用是 当调用函数时可以不传入参数,不传就会使用默认值作为参数的值
private static void Speak(string str = "xxx") {
Console.WriteLine(str);
}
// 注意:
// 1.支持多参数默认值 每个参数都可以有默认值
// 2.如果要混用 可选参数 必须写在 普通参数后面
private static void Speak2(string a, string test, string name = "xxx", string str = "xxx") {
}
九、结构体
结构体一般写在 namespace 语句块中
结构体关键字 struct
// struct 自定义结构体名
// {
// // 第一部分
// // 变量
// // 第二部分
// // 构造函数(可选)
// // 第三部分
// // 函数
// }
// 注意 结构体名字 我们的规范 是 帕斯卡命名法
(一)构造函数
// 基本概念
// 1.没有返回值
// 2.函数名必须和结构体名相同
// 3.必须有参数
// 4.如果申明了构造函数 那么必须在其中对所有变量数据初始化
// 构造函数 一般是用于在外部方便初始化的
public Student(int age, bool sex, int number, string name)
{
// 新的关键字 this
// 代表自己
this.age = age;
this.sex = sex;
this.number = number;
this.name = name;
}