2022-04-17 C# 第2篇——基础

蔗理苦

已于 2022-04-17 02:24:40 修改

阅读量859

点赞数

分类专栏： C# 学习笔记文章标签： c#

于 2022-04-17 01:30:58 首次发布

本文链接：https://blog.csdn.net/zheliku/article/details/124224016

版权

C# 学习笔记专栏收录该内容

12 篇文章 8 订阅

订阅专栏

文章目录

一、枚举

（一）枚举的声明

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;
}

蔗理苦

关注

0
点赞
踩
3

收藏

觉得还不错? 一键收藏
打赏
0
评论
2022-04-17 C# 第2篇——基础

文章目录一、枚举二、一维数组三、二维数组四、交错数组五、值与引用六、函数七、ref 与 out八、变长参数和默认值九、结构体一、枚举（一）枚举的声明enum E_自定义枚举名{ 自定义枚举项名字 = 5, // 第一个枚举项的默认值，变成5了自定义枚举项名字1, // 6 自定义枚举项名字2 = 100, 自定义枚举项名字3, // 101 自定义枚举项名字4, // 102} （二）枚举的类型转换枚举 --> int：
复制链接

扫一扫