算法与程序设计——C#
C#数据类型值类型
结构类型
一、基本概念
1. 结构类型是 C# 中的值类型，用于把多个相关变量组合成一个整体。
2. 结构存放在栈（Stack）中，访问速度快。
二、声明结构类型
结构类型的声明可以写在命名空间里、类的外面，整个项目都可以使用。也可以写在类里，只能在这个类使用，不能写在方法等代码块。
声明语法：
[结构访问修饰符] struct 结构名
{
[字段访问修饰符] 数据类型 字段名1；
[字段访问修饰符] 数据类型 字段名2；
… …
[字段访问修饰符] 数据类型 字段名n；
}
说明：
- 结构访问修饰符：可选，指定了结构的访问级别，public（大家都能用）、internal（同一个项目里能用）、protected（自己+子类能用）、protected internal（两者都可）、pirvate（自己用）。如果省略，默认为internal。
②struct：定义结构类型的关键字。
- 结构名：建议采用大驼峰命名法，需要符合标识符命名规则，要见明知意。
- 字段访问修饰符：主要取值public和private（默认值），public表示可以通过该类型的变量访问该字段，private表示不能通过该类型的变量访问该字段。
示例：
struct Student
{
public int id;
public string name;
public int age;
}
三、定义结构变量
在声明一个结构类型后，可以定义该结构类型的变量（简称结构变量）。
定义结构变量的语法格式：
结构类型 结构变量；
示例：Student stu1；
四、结构变量的使用
结构变量的使用主要包括字段的访问和赋值等，这些都是通过结构变量的字段来实现的。C# 结构是值类型，必须完全初始化才能访问字段。
访问字段变量一般格式：
结构变量名.字段名；
给字段赋值的一般格式：
结构变量名.字段名=值；
五、完整示例
1.声明Student 结构类型，包括stu_name,stu_age,stu_gender,stu_score等字段。
struct Student{
public string stu_name;
public int stu_age;
public char stu_gender;
public float stu_score;
}
2.定义Student结构变量。
Student stu1;
3.给Sutdent 结构变量的各个字段赋值
stu1.stu_name=”张立”;
stu1.stu_age=16;
stu1.stu_gender=’男’;
stu1.stu_score=98.5;
4.输出
Console.WriteLine(“姓名：”+stu1.stu_name+”性别：”+stu1.stu_gender+”年龄：” +stu1.stu_age+”分数：” +stu1.stu_score);
C# 枚举（Enum）类型
一、什么是枚举
• 枚举（Enum）：是一种值类型，用来定义一组命名的整型常量
• 作用：让代码更易读、避免乱用数字、统一取值范围
• 关键字：enum
二、枚举的声明语法
enum 枚举名
{
枚举成员1,
枚举成员2,
枚举成员3,
...
}
示例：
enum Season
{
spring,
summer,
autumn,
winter
}
三、枚举成员的赋值
C#中，枚举成员的赋值可以是隐式的，也可以是显式的。当没有为枚举成员显式赋值时，他们的值会从0开始，并且每个后续成员的值会自动递增1.但是，也可以显式地为枚举成员赋值，这样可以更灵活地控制每个成员地值。
示例：
enum Season
{
spring=1, //显式赋值为1
summer=2, //显式赋值为2
autumn=4, //显式赋值为4
winter=8 //显式赋值为8
}
四、枚举变量的定义
语法：枚举名 变量名；
示例：Season sea；
五、枚举变量的赋值
语法： 变量名=枚举成员；
示例： sea=Season.spring;
sea=(Season)1;
六、枚举变量的访问
枚举变量可以像普通变量一样直接访问。
示例：
enum Season {
spring,
summer,
autumn,
winter
}
class Program
{
static void Main(string[] args)
{
Season sea1;
Season sea2;
Season sea3;
Season sea4;
sea1 = Season.spring;
sea2 = Season.summer;
sea3 = (Season)2;
sea4 = (Season)3;
Console.WriteLine("春：{0} 夏:{1} 秋：{2} 冬：{3}",sea1,sea2,sea3,sea4);
}
}
七、枚举与整数与字符串互相转换
◦ 枚举 → int（强制转换）
int num = (int)Season.spring;
◦ int → 枚举（强制转换）
Season sea= (Season)2;
◦枚举 → 字符串（获取名字）
string name = Season.spring.ToString();
常量
常量是固定值，程序运行期间不会改变。常量可以是任何基本数据类型，比如整数常量、浮点数常量、字符串常量、枚举常量。常量可以被当作常规的变量，只是它们的值在定义后不能被修改。
常量可以分为直接常量和符号常量。
- 直接常量
直接常量也称为字面常量，在代码中直接书写的具体数值或字符，不需要通过关键字声明，直接字面形式出现在程序中。
特点：
- 无需声明、直接使用、书写简洁。
- 可读性较差，当多次使用同一数值时，若需要修改则逐一修改，不利于维护。
- 常见于简单的赋值、运算或判断语句中。
Eg：int age=18；double pi=3.14159； char grade=‘A’；
其中“18”，“3.14159”，“‘A’”都是直接常量。
- 整数常量
程序中直接写出来的整数值。整数值可以是十进制，十六进制，二进制（C#7.0）或八进制（不支持）。
- 十进制常量（最常用）
◦ 正常数字：0、123、-456、10000
◦ 无前缀
- 十六进制常量
◦ 前缀：0x 或 0X
◦ 例：0xFF、0x1A、0x00FF、0X10
- 二进制常量（C#7.0+ VS2010对应C#4.0）
◦ 前缀：0b 或 0B
◦ 例：0b1010、0b11110000
- 八进制常量（考试必坑）
◦ C、C++ 用 0 开头，C# 废除八进制
◦ 考试必坑：C# 没有 0123 这种八进制
数字分隔符（C# 7.0+）：
• 符号：_（下划线），只分隔、不影响值
• 例：1_000_000、0xFF_FF、0b1010_1111
• 作用：提高可读性
整数常量的默认类型：
1. 十进制常量：
◦ 能存进 int → 默认 int
◦ 超出 int 范围 → 依次是 uint、long、ulong
2. 十六进制 / 二进制（C# 7.0+）：
◦ 同样按范围匹配：int、uint、long、ulong
后缀（直接给常量强制指定类型）：
• U / u → uint 例：100U
• L / l → long 例：100L（建议大写L，避免和1混淆）
• UL/ul → ulong
- 浮点常量
程序中直接写出来的实数值（带小数的数），两种表示形式，十进制小数形式和指数形式（科学计数法）程序运行时值不可，改变。如：3.14、0.5、-2.718、1e3。
- 十进制小数形式
必须包含小数点 或 小数部分。
合法：
• 123.45
• .45 等价于 0.45
不合法：123（整型，不是浮点）
- 指数形式（科学计数法）
格式：尾数 E/e 整数指数
含义：aEb = a × 10^b
规则：
• E/e 前后必须有数字
• 指数必须是整数（正、负、0）
合法示例：
• 1.23e3 = 1230
• 0.45e-2 = 0.0045
• 123e0 = 123.0
非法示例：
• e3、12e、1.2E3.5（指数不能是小数）
浮点常量的默认类型
- 浮点常量默认是 double 类型（双精度）
- 若要表示 float 类型，必须加后缀：
◦ f / F → float
◦ d / D → double（可省略）
◦ m / M → decimal（高精度货币）
示例：
• 3.14 → double
• 3.14f → float
• 3.14m → decimal（C#）
重要特点
1. 浮点常量有小数精度，可表示小数、大数、极小值。
2. 不能表示分数（如 1/3 只能写成近似值）。
3. 计算机内部是二进制存储，会有微小精度误差（如 0.1+0.2≠0.3）。
常见易错点
1. 没有小数点 → 整型常量，不是浮点。
2. 指数写法中：E 不能单独出现，指数必须整数。
3. 直接写 3.14 是 double，赋值给 float 可能报错，要加 f。
- 字符常量
程序中直接写出来的字符，用单引号括起来，存储的是 ASCII 码（整数），不是字符本身
- 书写格式
'a' '5' '!' ' ' 'A'
• 必须单引号
• 里面只能有 1 个字符
• 区分大小写：'a' != 'A'
- 字符常量的本质
• 每个字符对应一个 ASCII 码（0~127）
• 字符常量在计算机里就是整数
• 可以直接参与运算：'a' + 1 = 98 即 'b'
常用 ASCII（必须记）： '0' → 48，'9' → 57， 'A' → 65， 'Z' → 90， 'a' → 97， 'z' → 122
- 转义字符常量（重点！）
以 \ 开头，表示特殊功能字符，也算 1 个字符。
常用转义字符：
|
'\n' |
换行 |
'\t' |
水平制表符（Tab） |
|
'\0' |
字符串结束符（ASCII 0） |
'\\' |
反斜杠本身 |
|
'\'' |
单引号 |
'\"' |
双引号 |
|
\ddd |
八进制转义：'\101' = 'A' |
\xhh |
十六进制转义：'\x41' = 'A' |
- 易错点总结
- ' ' 空格字符：ASCII 32，不是0
- '\0'：ASCII 0，空字符，不是空格
- 单引号里不能放多个字符：'ab' 错误
- 不能用双引号表示字符："a" 是字符串，不是字符
- 字符串常量
程序中直接写出来的字符串，用双引号括起来的一串字符，可以包含0个，1个，多个字符（字母、数字、符号、汉字、空格等）。
- 类型：string
- 本质：多个字符组成的序列
- 合法示例："hello"、"12345"、"A"、"我是学生"、" "（空格字符串）。
- 字符串常量的特点
- 必须用双引号 " "
- 长度任意（可以0个字符）
- "" 空字符串是合法常量
- 属于引用类型
- 字符串不可变（一旦创建不能修改，只能重新赋值）
- 存储：Unicode 编码，每个字符占 2 字节
字符串中的转义字符（和char一样）
字符串里也可以用 \ 开头的转义字符：
• \n 换行
• \t 制表符 Tab
• \\ 一个反斜杠
• \" 双引号
• \0 空字符
示例：
string s = "姓名\t年龄\n张三\t18";
string path = "C:\\test\\a.txt";
- 逐字字符串 @" "（C# 特有！）
• 以 @ 开头，双引号内部不识别转义字符
• 可以直接换行、直接写 \、直接写空格
• 字符串内要表示 " 用 ""
用途：写路径、多行文本最方便！
string path = @"C:\test\a.txt"; // 不用写 \\
string text = @"第一行
第二行
第三行";
- 字符串常量 vs 字符常量
|
对比项 |
字符常量 char |
字符串常量 string |
|
引号 |
单引号 ' ' |
双引号 " " |
|
长度 |
只能 1 个字符 |
0~任意个 |
|
空值 |
非法 |
合法（空串） |
|
内存 |
2字节 |
字符数×2字节 |
|
类型 |
值类型 |
引用类型 |
|
结尾 |
无 |
自动加’\0’ |
|
例子 |
'A' '中' |
"A" "中国" |
- 布尔常量
布尔型用来表示真、假两种状态的数据类型。
true（必须小写）——表示真、是、成立、对
false（必须小写）——表示假、否、不成立、错
- 符号常量
1、符号常量的概念
• 符号常量：用const关键字定义的、有固定名称、值在程序运行中不可修改的常量，也叫命名常量。
• 它是相对于字面常量（直接写的数值、字符串，比如3.14、"abc"）的概念，用有意义的名称来代替固定值，提升代码可读性和可维护性。
2、定义语法
const 数据类型 常量名 = 常量值;
• 示例：
const double PI = 3.1415926;
const int MAX_AGE = 120;
const string SCHOOL_NAME = "XX职业技术学校";
const bool IS_VALID = true;
3、核心特点
（1）必须在定义时赋值，不能先声明后赋值
◦ 错误写法：const int a;
a = 10;
◦ 正确写法：const int a = 10;
（2）值不可修改：程序运行过程中，一旦定义就不能再修改，否则编译报错
（3）编译期常量：值在编译时就确定，不是运行时计算
（4） 作用域：和变量一致，可以定义在类、方法、结构体等内部
（5）命名规范：通常采用全大写+下划线（如MAX_COUNT），便于和变量区分
（6） 支持的数据类型：
◦ 基本数值类型：sbyte/byte/short/ushort/int/uint/long/ulong/float/double/decimal
◦ 字符类型：char
◦ 字符串类型：string
◦ 布尔类型：bool
◦ 空值：null
◦ 不能用自定义类、数组等引用类型（除string和null外），也不能用变量赋值
4、符号常量 vs 字面常量（对比）
|
对比项 |
符号常量（const） |
字面常量（直接量） |
|
写法 |
const int MAX=100; |
直接写100、"abc" |
|
可读性 |
高（名称见名知意） |
低（含义不直观） |
|
可维护性 |
高（一处修改，全局生效） |
低（多处修改容易遗漏） |
|
可修改性 |
不可修改 |
无名称，不存在修改 |
5、常见易错点
（1）不能用变量给const常量赋值：
int num = 10;
const int a = num; // 错误！编译不通过
（2）不能在定义后修改值：
const int a = 10;
a = 20; // 错误！常量不可修改
（3）不能省略数据类型（C# 强类型语言）：
const a = 10; // 错误！必须指定类型
（4）const和readonly的区别（拓展考点）：
◦ const：编译期常量，必须定义时赋值，不可修改
◦ readonly：运行期常量，可以在定义时或构造函数中赋值，实例成员可在构造函数修改
六、使用场景
• 定义程序中固定不变的数值：圆周率PI、最大容量MAX_SIZE
• 定义固定字符串：项目名称、版本号、文件路径
• 定义固定布尔值：功能开关IS_ENABLED
• 避免"魔法数字"（直接写在代码中无意义的数字），提升代码可维护性
最终知识点总结
C#符号常量是用const定义、必须初始化、运行时不可修改的命名常量，用于替代字面常量，提升代码可读性与可维护性，仅支持特定数据类型，命名通常全大写。
运算符及各运算符的优先级
算术运算符
基本概念
运算符
用来执行特定操作的符号或关键字。例如，+、-、*、/是用来执行加减乘除操作的符号他们叫做算数运算符。
操作数
在计算式里被运算符加工、参与运算的数据，就叫做操作数，可以是常量，也可以是变量。
示例：a+5
+：运算符（干活的工具）
a、5：操作数（被工具计算的原材料）
表达式
用运算符把操作数连接起来，能算出一个结果的式子，就叫做表达式。
示例：
-
3+5
+：运算符
3、5：操作数
3+5：表达式
-
a*10-b
*、-：运算符
a、10、b：操作数
a*10-b：表达式
注意：表达式结尾不写“；”，能算出值，加了分号就是语句，用来执行操作。
算术运算符
|
符号 |
意义 |
示例 |
结果 |
|
+ |
加法运算 |
3+5 |
8 |
|
- |
减法/取负运算 |
5-3 |
2 |
|
* |
乘法运算 |
2*3 |
6 |
|
/ |
除法运算 |
6/2 |
3 |
|
% |
取余数 |
12%10 |
2 |
+（加）：
1、同类型相加
规则：直接相同数据类型数字求和，结果保持原类型
int a = 3, b = 5;
int res = a + b; // 结果 8，纯数字加法
2、不同数值类型混合相加（隐式自动类型转换）
C# 小精度类型会自动向大精度类型转换，避免数据丢失，
• 案例1：short + int → 自动变int
short s = 10;
int n = 20;
var t = s + n; // t 本质是 int 类型
• 案例2：int + double → 自动变double
int x = 5;
double y = 2.5;
Console.WriteLine(x + y); // 7.5 浮点结果
• 易错点：byte/short 自身相加，结果强制提升为int
byte、short太小，运算时编译器默认转int，不能直接赋值给原类型
byte b1 = 10, b2 = 20;
// byte res = b1 + b2; 报错！编译不通过
byte res = (byte)(b1 + b2); // 必须强制类型转换
3、溢出问题
int/long 等整型相加，数值超出取值范围会溢出
4、任意类型 + string → 字符串拼接
只要加号两边任意一边是字符串，+ 就放弃算术加法，变成拼接连接符，全局自动调用 ToString()
（1）数字 + 字符串
Console.WriteLine(123 + "abc"); // 输出：123abc
Console.WriteLine("和为：" + 5 + 8); // 输出：和为：58 易错！先拼接不是加法
优先级陷阱（考试高频考点）
从左往右依次运算，遇到字符串立刻切换拼接模式：
• "a" + 1 + 2 → a12 全拼接
• 1 + 2 + "a" → 3a 先算术加，再拼接
（2）布尔/字符/对象 + 字符串
所有自定义类型、基础非数值类型，都会自动转字符串：
bool flag = true;
Console.WriteLine("结果：" + flag); // 结果：True
object obj = 666;
Console.WriteLine("数据" + obj); // 数据666
（3）空字符串拼接
"" + 基础类型 快速把数字转字符串，简易类型转换：
int num = 99;
string str = "" + num; // str = "99"
5、char 字符类型的 + 特殊规则
（1）char + char / char + int：执行算术加法
char底层本质是ASCII编码数字，不是文本
char c1 = 'A'; // ASCII 65
char c2 = 'B'; // ASCII 66
Console.WriteLine(c1 + c2); // 131，计算编码值之和
（2）char + string：变回字符串拼接
Console.WriteLine('A' + "bc"); // Abc
-（减）：
1. 数值减法
int a = 10 - 5; // 5
double b = 3.14 - 1.14; // 2.0
decimal c = 10.5m - 2.3m; // 8.2m
// 不同类型混合（隐式转换）
double d = 10 - 3.14; // 6.86 (int 转为 double)
2. 一元负号（取负）
int x = 5;
int y = -x; // -5
int z = -(-5); // 5
double d = 3.14;
double neg = -d; // -3.14
// 与 0 的关系
int zero = -0; // 0 (负零仍为零)
3. char 类型运算
int c = 'B' - 1; // 65
int n = 'B' - 'A'; // 1 (char - char → int)
4. 一元负号的类型转换4
uint u = 10;
// long x = -u; // 编译错误：不能直接对 uint 取负
long x = -(long)u; // -10 (需要显式转换)
int i = -2147483648; // 可以，但常量需要特殊处理
// int i = -(-2147483648); // 溢出（在 checked 上下文中）
5.浮点数精度问题：
double a = 0.3 - 0.2; //
decimal b = 0.3m - 0.2m; // 0.1 (decimal 精度更好)
*（乘）：
1、相同数据类型数字相乘结果保持原类型
int a = 2;
int b = 3;
int c = a * b; // 6
double x = 2.2;
double y = 2;
Console.WriteLine(x * y);
2、不同数据类型混合相乘（自动隐式转换）
int n = 5;
double d = 2.0;
var t = n * d; // 最终类型是 double
3、byte、short 互相相乘，结果自动变成 int
byte b1 = 2;
byte b2 = 3;
// byte r = b1 * b2; 编译报错
byte r = (byte)(b1 * b2); // 必须强制转换
short s1 = 10;
short s2 = 2;
short s = (short)(s1 * s2);
4、char 类型使用 * 运算符（高频考点）
char本质是ASCII数字，char 和 数字可以用 * 做算术乘法
char ch = 'A';//ASCII 65
int num = 2;
Console.WriteLine(ch * num); // 130 纯数值计算
/（除）：
1、整型相除（int、long、byte、short）——【整除】
规则：砍掉小数点后面所有数字，只保留整数部分，不四舍五入
Console.WriteLine(7 / 2); // 3 不是3.5，小数直接舍去
Console.WriteLine(-7 / 2); // -3
Console.WriteLine(7 / -2); // -3
正负规则：符号正常数学计算，小数一律截断。
2、浮点数参与除法（float、double、decimal）——【真实小数除法】
只要 / 任意一边是浮点类型，自动启用精准小数计算，不再整除.
运算前，小范围类型先转大范围类型，再计算。
1. int / long → 结果 long
2. int / float → 结果 float
3. int / decimal → 结果 decimal
// int / double → 自动类型提升为double
Console.WriteLine(7 / 2.0); // 3.5
Console.WriteLine(7.0 / 2); // 3.5
3、低精度整型：byte / short 除法
和加减乘规则一致：
byte、short、sbyte、ushort 任意算术运算(-、+、*、/)，表达式结果自动提升为 int
示例：
byte b1 = 10;
byte b2 = 2;
// byte res = b1 / b2; // 编译报错，结果是int
byte res = (byte)(b1 / b2); // 必须强制类型转换
4、char 类型使用 / 运算符
char底层存储ASCII数值，可以和数字做除法算术运算：
char c = 'B'; // 66
Console.WriteLine(c / 2); // 33
5、除数为 0
（1）整数除以0：编译不通过
（2）浮点数除以0：不崩溃，返回特殊值
正数/0 → 无穷大 Infinity
负数/0 → 负无穷大 -Infinity
0.0 / 0.0 → 非数字 NaN
6、浮点除的精度问题
double 类型四舍五入保留15位有效数字。
float类型四舍五入保留7位有效数字。
Console.WriteLine(10d / 3d); // 3.33333333333333
Console.WriteLine(10f/ 3f); // 3.333333
Console.WriteLine(20d / 3d); // 6.66666666666667
Console.WriteLine(20f/ 3f); // 6.6666667
%（取余/取模）：
1、C# 取余符号规则：余数的正负 跟随被除数
正数示例
Console.WriteLine(7 % 2); // 余1
Console.WriteLine(10 % 3); // 余1
Console.WriteLine(8 % 5); // 余3
余数符号和前面的被除数一致：
-7 % 2 // -1 被除数负→余数负
7 % -2 // 1 被除数正→余数正
-7 % -2 // -1 被除数负→余数负
口诀：看前面，不看后面，前正余正，前负余负
2、byte / short 类型 % 运算
只要是 byte、sbyte、short、ushort 任意算术运算，编译器先提升为int再计算，表达式结果是int。
byte a = 9;
byte b = 4;
// byte res = a % b; // 编译错误，结果是int
byte res = (byte)(a % b); // 正确，强制类型转换
short s1 = 20;
short s2 = 6;
short r = (short)(s1 % s2);
跨类型：byte % short、short % byte，结果依然是int。
3、不同数值类型混合取余（隐式类型转换）
两边类型不一样，小范围转大范围，结果匹配大范围类型：
（1）int % long → long
（2）int % double → double（小数也能取余）
（3）decimal % decimal → decimal 金融精准计算
示例：
Console.WriteLine(5.5 % 2); // 1.5
Console.WriteLine(7.2m % 3m); // 1.2
注意：浮点运算天生有微小精度误差。
4、char 类型结合 % 运算
（1）char 底层是ASCII编码数字，可以和整数做取余算术运算；
char ch = 'A'; // 65
Console.WriteLine(ch % 10);
（2）% 不能和字符串混用，编译直接报错；只有 + 能拼接字符串。
5、除数为 0 的致命区别（和除法一致）
（1）整型 % 0：编译不通过。
（2）浮点 double/float % 0：不崩溃，结果为 NaN 非数字。
算术运算符的优先级
一、核心总规则
1. 优先级越高，越先计算；同级运算符遵循从左往右依次运算。
2. 小括号()优先级最高，可强行改变默认运算顺序，开发中优先用括号避免歧义。
3. C#算术运算符分为：一元算术运算符、二元算术运算符两类。
二、优先级从高到低完整排序（必考）
第1级：最高优先级
( ) 括号
作用：包裹表达式，优先计算括号内部所有内容，多层括号从内层向外计算。
第2级：一元算术运算符（单操作数，只需要一个数字）
+ 正号、- 负号
第3级：乘除取模类（同级，左结合）
* 乘法、/ 除法、% 取余（取模）
三者优先级一致，碰到一起从左算到右。
第4级：加减类（同级，左结合，最低算术优先级）
+ 加法、- 减法
两者优先级一致，同级从左向右计算，最后执行加减运算。
三、拓展：和赋值运算符的区别
算术运算符整体优先级 远高于 简单赋值=
示例：int a = 3 + 5 * 2; 先算右侧所有算术，最后再把结果赋值给变量。
四、一句话速记口诀
括号最优先，正负排第二；乘除取模随后走，最后才算加和减；同级运算左边起。
位运算符
在C#中，位运算符用于对整数类型的二进制直接操作，核心包含左移(≪)、右移(≫)等运算符，该类运算符直接操作数据的二进制表示，运算效率高，常用于底层开发、性能优化和掩码相关场景。
-
按位与 &（全1才1）
作用：提取某些位、判断某位是否为 1、保留指定位
5 & 3
5 → 101
3 → 011
-----------
001 → 结果 1
-
按位或 |（有1 就1）
作用：把某些位设为 1
5 | 3
5 → 101
3 → 011
-----------
111 → 结果 7
-
按位异或 ^（相同为0，不同为1）
作用：翻转某些位、不进位加法、交换变量
5 ^ 3
5 → 101
3 → 011
-----------
110 → 结果 6
-
按位取反 ~（全部反转）
作用：所有位 0→1、1→0
~5 = -6
C# 中整数是有符号数，取反后会变负数（补码规则）。
-
左移 <<（乘2）
规则：二进制整体向左移动，右侧补 0
等价数学运算：数值 × 2ⁿ
5 << 1 → 10
5 << 2 → 20
6. 右移 >>（除2）
规则：二进制整体向右移动，左侧补符号位
等价数学运算：数值 ÷ 2ⁿ（向下取整）
8 >> 1 → 4
8 >> 2 → 2
7 >> 1 → 3
位运算符优先级
从高到低：
~ → << 、>> → & → ^ → |
不确定就加括号，最安全。
自增（++）自减（--）运算符
一、基础概念
1. 自增 ++：变量自身 +1
2. 自减 --：变量自身 -1
3. 分类：
◦ 前置：++i、--i（先变值，后用值）
◦ 后置：i++、i--（先用旧值，后变值）
二、单独写一行（最简单、必考基础）
前置、后置 没有任何区别，都只让变量自身±1
int a = 10;
a++;
++a;
a--;
--a;
三、嵌入表达式/输出
1、后置自增 i++
规则：先使用变量当前的值参与运算，语句结束后变量再+1
示例：
int x = 5;
Console.WriteLine(x++); // 输出5 先用旧值
Console.WriteLine(x); // 输出6 事后自身加1
2、前置自增 ++i
规则：变量先立刻+1，再用新值参与运算
int x = 5;
Console.WriteLine(++x); // 输出6 先加1
Console.WriteLine(x); // 输出6
3、后置自减 i--
规则：先使用变量当前的值参与运算，语句结束后变量再-1。
示例：
int x = 5;
Console.WriteLine(x--); // 输出5 先用旧值
Console.WriteLine(x); // 输出4 事后自身加-1
4、前置自减--i
规则：变量先立刻-1，再用新值参与运算
int x = 5;
Console.WriteLine(--x); // 输出4 先减1
Console.WriteLine(x); // 输出4
四、赋值组合经典例题
例1 后置++赋值
int a = 3;
int b = a++;
//步骤：
//1.b先接收a旧值3
//2.a自己变成4
//结果：b=3，a=4
例2 前置++赋值
int a = 3;
int b = ++a;
//步骤：
//1.a先变成4
//2.b接收新值4
//结果：b=4，a=4
五、byte / short 短小类型 ++、-- 特殊点
之前加减乘除：byte+byte 会变int；
自增自减是特例：不会提升为int！不用强制转换
byte b = 5;
b++; //合法，直接还是byte
++b; //合法
short s = 10;
s--; //正常使用，不需强转
六、浮点类型 float double decimal 可以用++ --
不只是整数，小数也能自增自减，每次 ±1.0
double d = 2.5;
d++;
Console.WriteLine(d);//3.5
七、char 字符支持 ++ --
char底层是ASCII编码，可以自增自减，切换相邻字符
char c = 'A';
c++;//变成'B'
字符类型的自增自减运算结果还是字符。与+加、-减运算不同。
字符串运算符
1. 字符串拼接运算符：+ 和 +=
（1）+ 加号拼接
作用：连接多个字符串，返回新字符串，原字符串不变（字符串是不可变常量）。
• 纯字符串拼接
string a = "hello";
string b = "world";
string c = a + " " + b; // 结果：hello world
• 字符串 + 任意基础类型（自动隐式调用 ToString()）
string s = "数字：" + 100; // 数字：100
string s2 = "判断：" + true; // 判断：True
string s3 = "字符：" + 'A'; // 字符：A
• 运算优先级陷阱：先算数字加法，再拼接
Console.WriteLine(10 + 20 + "总和"); // 30总和，先算术相加
Console.WriteLine("总和" + 10 + 20); // 总和1020，全部转为拼接
（2）+= 拼接赋值
复合赋值运算符，原地拼接赋值，简化代码：
string str = "你好";
str += "C#";
// 等价于 str = str + "C#"，最终：你好C#
赋值运算符
关运算符
关系运算符就是用来比较两个值，关系成立结果为true，否则结果为false的运算符，结果一定是 bool 类型。
一、6 个关系运算符
|
运算符 |
含义 |
说明 |
|
== |
等于 |
判断两个值是否相等 |
|
!= |
不等于 |
判断两个值是否不相等 |
|
> |
大于 |
左边 > 右边 |
|
< |
小于 |
左边 < 右边 |
|
>= |
大于等于 |
左边 ≥ 右边 |
|
<= |
小于等于 |
左边 ≤ 右边 |
等于==
功能：判断两个值是否相等，相等返回true不相等返回false
int a = 10;
int b = 3;
a == b // false
！=不等于
int a = 10;
int b = 3;
a != b // true
>大于
int a = 10;
int b = 3;
a > b // true
<小于
int a = 10;
int b = 3;
a < b // false
>=大于或等于
int a = 10;
int b = 3;
a >= 10 // true
<=小于或等于
int a = 10;
int b = 3;
b <= 3 // true
注意：
-
关系运算返回 true/false
-
主要用在条件判断
-
= 赋值，== 判断相等（最容易错）
逻辑运算符
一、3 个核心逻辑运算符
|
运算符 |
名称 |
作用 |
口诀 |
||
|
&& |
逻辑与 |
两边都为 true，结果才 true |
全真才真 |
||
|
|| |
逻辑或 |
一边为 true，结果就 true |
一真即真 |
||
|
! |
逻辑非 |
取反，true 变 false，false 变 true |
真变假，假变真 |
1. 逻辑与 &&（并且）
-
规则：条件 1 && 条件 2
-
只有两边都 true → 结果 true
-
只要有一个 false → 结果 false
bool a = true;
bool b = false;
a && b → false
true && true → true
常用：同时满足多个条件
if (age > 18 && score >= 60)
2. 逻辑或 ||（或者）
-
规则：条件 1 || 条件 2
-
只要一个 true → 结果 true
-
全 false 才 false
true || false → true
false || false → false
常用：满足任意一个条件
if (age < 12 || age > 60)
3. 逻辑非！（取反）
-
规则：! 条件
-
true ↔ false 互相翻转
!true → false
!false → true
常用：否定条件
if (!string.IsNullOrEmpty(name))
二、短路特性（非常重要）
-
&& 短路：左边为 false，右边不执行
-
|| 短路：左边为 true，右边不执行
示例：
false && Method() → Method 不执行
true || Method() → Method 不执行
三、优先级（从高到低）
-
! 非
-
&& 与
-
|| 或
不确定就加括号，最安全。
条件运算符
C# 条件运算符（三元运算符）
一、基本信息
-
名称：条件运算符 / 三元运算符
-
符号：? :
-
格式：条件？表达式 1 : 表达式 2
-
结果：条件为 true → 表达式 1；false → 表达式 2
二、核心语法（必背）
条件 ? 真时执行 : 假时执行
int a = 10;
int b = 5;
int max = a > b ? a : b;
// 条件a>b成立 → 取a → max=10
三、执行规则
-
先判断条件是 true 还是 false
-
true → 执行冒号左边
-
false → 执行冒号右边
-
最终只执行一个，不会都执行
四、经典使用场景
-
求最大值 / 最小值
int max = x > y ? x : y;
-
简单判断赋值
string result = score >= 60 ? "及格" : "不及格";
-
代替简单 if-else
// if 写法
if (age >= 18) msg = "成年";
else msg = "未成年";
// 三元写法
string msg = age >= 18 ? "成年" : "未成年";
五、注意事项（易错点）
-
表达式 1 和 表达式 2 类型必须兼容
不能一个 int 一个 string 混用。
-
不能只写一半
条件? 表达式1; ❌ 错误
必须有 : 和后半部分。
-
可以嵌套，但尽量少用（可读性差）
string level = score >= 90 ? "优秀" : (score >=60 ? "及格" : "不及格");
运算符优先级
运算符按照操作数的数目分为单目运算符，双目运算符，三目运算符。也叫一元运算符，二元运算符，三元运算符。
在C#中，运算符的优先级决定了表达式的运算顺序。当表达式中包含多个运算符时，优先级高的运算符会先于优先级低的执行。如果运算符的优先级相同，则按照他们在表达式中出现的顺序从左到右执行。
|
优先级 |
运算符类型 |
运算符 |
数目 |
结合性 |
|
高 | | | | | | | ⬇ 低 |
单目运算符 |
++、--、！ |
单目 |
右结合 |
|
算术运算符 |
*、/、% |
双目 |
左结合 |
|
|
+、- |
双目 |
左结合 |
||
|
移位运算符 |
≪、≫ |
双目 |
左结合 |
|
|
关系运算符 |
>、>=、<、<= |
双目 |
左结合 |
|
|
==、!= |
双目 |
左结合 |
||
|
逻辑运算符 |
&& |
双目 |
左结合 |
|
|
|| |
双目 |
左结合 |
||
|
条件运算符 |
?: |
三目 |
右结合 |
|
|
赋值运算符 |
=、+=、-=、*/、/=、%=、&=、|=、^=、≪=、≫= |
双目 |
右结合 |
其他常用运算符
C# is 运算符（类型判断）
一、is 运算符是什么
is 是 C# 中的类型判断运算符，用来判断：操作数是否为指定类型、或者能不能安全转换成这个类型。
返回结果：bool（true / false）
常用来做类型检查、避免类型转换报错
二、基本语法
语法：操作数 is 类型
是 → true
不是 → false
示例：
string obj = "Hello";
bool b1 = obj is string; // true
bool b2 = obj is int; // false
三、is 能判断什么
值类型：int、double、bool、char…
引用类型：string、class、interface…
继承关系（子类 is 父类 → true）
null 判断
四、经典示例
示例 1：判断字符串
object a = "abc";
Console.WriteLine(a is string); // true
示例 2：判断数字
object b = 99;
Console.WriteLine(b is int); // true
示例 3：继承判断
class Animal { }
class Dog : Animal { }
Animal animal = new Dog();
Console.WriteLine(animal is Dog); // true
Console.WriteLine(animal is Animal); // true
示例 4：判断 null（C#7.0+）
string str = null;
Console.WriteLine(str is null); // true
五、is 运算符 3 个重点规则
null is 任何类型 → 都返回 false
object x = null;
x is string → false
子类 is 父类 → true
狗 is 动物 → 对
动物 is 狗 → 不一定对
值类型判断必须完全匹配
int is double → false
int is int → true
C#as运算符（安全转换）
as 是 C# 中安全的类型转换运算符，专门用于引用类型和可空值类型的转换，将操作数转换为指定的引用类型/可空值类型，转换成功返回对应类型对象，转换失败返回null，核心特点：转换失败不会抛异常，只会返回 null。
一、核心定义
语法：操作数 as 目标类型;
- 作用：尝试将一个对象安全转换为指定类型
- 关键特性：
- 转换失败 → 返回 null（不抛 InvalidCastException）
- 只能用于引用类型、可空值类型（Nullable<T>）
- 是运行时类型检查，不是强制转换
示例：
object obj = "Hello";
string str1 = obj as string; // 成功：str1="Hello"
int? num1 = obj as int?; // 失败：num1=null（int？表示可控int类型）
object obj = 100;
int? num = obj as int?; // 成功：num=100
obj = "abc";
num = obj as int?; // 失败：num=null
C#空值条件运算符？.
功能：安全访问对象的成员（属性/方法/字段），先判断对象是否为null若对象为null则返回null，则直接返回null，不会抛出空引用异常，如果对象不是null，则正常访问成员。适用于可能为null的对象成员访问。
语法： 对象?.成员
作用： 先判断对象是否为 null
为 null → 整个表达式结果 = null
不为 null → 访问成员
示例：1 string str=null;
//若str为null，直接返回null，避免调用Length属性时报错
int? length=str?.Length;
Console.WriteLine(length); //输出null
C#空值合并运算符??
功能：为可能为null的变量设置默认值，若左操作数不为null，返回左侧值，若为null，返回右侧之。
语法：操作数1 ?? 操作数2
示例： string input=null;
//input为null，返回默认值”为输入”;
string result=input ?? “未输入”;
Console.WriteLine(result);
C#空值合并赋值运算符??=
功能：简化空值判断与赋值，若左侧变量为null，将右侧值赋给左侧变量；若不为null，保持原数值不变。
语法：变量??=表达式
示例： string str=null;
str??=”默认值”;
Console.WriteLine(str);//输出 默认值
string str2=”原有值”;
str2??=”新值”;
Console.WriteLine(str2);
顺序结构
流程控制语句
流程控制语句主要分为三大类：顺序结构，分支结构和循环结构。
顺序结构
概念：按照时间、空间或逻辑发展的顺序，将各个要点有机地连接起来，形成一篇完整地程序。在编程中，它特指程序中地语句按照从上到下地顺序依次执行，每一条语句都在前一条语句执行完毕后才执行。
C# 赋值语句
- 赋值语句概念
C#中，赋值语句是一种基本地编程语句，用于将一个值赋给一个变量。这种语句使用赋值运算符（=），左边是变量名，右边是要赋给该变量地值或表达式。
赋值语句作用：把右边表达式的值，存入左边的变量中。
核心规则：变量 在左，值 / 表达式 在右
二、基础赋值运算符
语法：
变量 = 表达式;
示例：
int a = 10;
int b;
b = 20;
b = a + 5;
特点：
= 是赋值，不是数学等于；
先算右边表达式，再把结果赋给左边变量；
左边只能是变量，不能是常量、表达式。
- 复合赋值运算符（简写赋值）
|
运算符 |
含义 |
等价写法 |
|
+= |
加法赋值 |
a = a + n |
|
-= |
减法赋值 |
a = a - n |
|
*= |
乘法赋值 |
a = a * n |
|
/= |
除法赋值 |
a = a / n |
|
%= |
取余赋值 |
a = a % n |
示例：
int a = 10;
a += 5; // 等价 a = a + 5
a -= 3; // 等价 a = a - 3
a *= 2; // 等价 a = a * 2
a /= 4; // 等价 a = a / 4
a %= 3; // 等价 a = a % 3
四、连续赋值
语法：同类型变量可以一行连续赋值
int x, y, z;
x = y = z = 100;
执行顺序：从右往左
等价：
z = 100;
y = z;
x = y;
五、赋值类型匹配规则
右边值类型 和左边变量一致，可直接赋值；
隐式转换：小范围类型 → 大范围类型 可以直接赋值
int a = 5;
double d = a; // int 自动转 double
强制转换：大范围 → 小范围，必须强制转换
double d = 3.14;
int a = (int)d;
不能把字符串直接赋值给数值类型
六、赋值语句常见语法错误
左右写反
10 = a; // 错误：左边不能是常量
类型不匹配，不转换直接赋值
int a = "123"; // 错误
复合赋值中间不能加空格、不能拆开写
赋值语句末尾必须加分号；
七、赋值运算符优先级
赋值类运算符 优先级最低
先算算术、关系、逻辑，最后再赋值
示例：
int a = 3 + 5 * 2;
先算乘法、再加法，最后赋值给 a。
八、和之前空值赋值关联
??= 空合并赋值（C#8.0）
str ??= "默认值";
左边为 null 才赋值，不为 null 保持原值。
输入语句
C# Console.ReadLine ()
一、作用
从控制台读取用户输入的一整行字符，按下回车键结束输入，并将输入内容作为字符串返回。属于Console类。
二、语法
量名 = Console.ReadLine();
三、核心特点
- 返回值类型固定是 string
- 读取到回车才结束
- 读取的内容包含空格，不包含回车符
- 如果直接按回车，返回 空字符串 ""（不是 null）
- 必须用 string 类型变量接收
四、最常用写法
Console.WriteLine("请输入姓名：");
string name = Console.ReadLine();
五、输入数字必须转换（重点）
Console.ReadLine() 只能读字符串，要存为数字必须转换：
// 转 int
int age = int.Parse(Console.ReadLine());
// 转 double
double score = double.Parse(Console.ReadLine());
六、常见错误
用 int 直接接收，不转换
int a = Console.ReadLine(); // 错误！类型不匹配
单词写错：ReadLint、Readline 等
少写括号
Console.ReadLine; // 错误
Console.ReadLine(); // 正确
C# Console.Read ()
一、Console.Read () 是什么
作用：从控制台读取一个字符，返回它的 ASCII 码（int 类型）。
特点：只读第一个字符，按回车确认。
二、语法
int 变量 = Console.Read();
三、核心知识点
- 返回值是 int 类型（字符对应的 ASCII 码）
- 只读取第一个字符，后面内容忽略
- 按 Enter 才开始读取
- 读取的是字符编码，不是字符本身
- 若要得到真实字符，需要强制转换：
(char)Console.Read()
四、示例
示例 1：读取 ASCII 码
int ascii = Console.Read();
Console.WriteLine(ascii);
输入：a
输出：97
示例 2：转成真实字符
int ascii = Console.Read();
char ch = (char)ascii;
Console.WriteLine(ch);
输入：A
输出：A
五、Console.Read () 与 Console.ReadLine () 区别
|
方法 |
读取内容 |
返回类型 |
结束方式 |
|
Console.Read() |
一个字符 |
int（ASCII 码） |
读第一个字符 |
|
Console.ReadLine() |
一整行 |
string |
读到回车 |
六、常见错误
1、用 string 接收 Console.Read ()
string s = Console.Read(); // 错误！int 不能给 string
2、以为会读取多个字符
// 输入 123，只会读 '1' 的 ASCII 码
int n = Console.Read();
C# Console.ReadKey ()
一、作用
从控制台读取用户按下的一个按键，不需要按回车，按下即响应；常用于暂停程序、等待按键、获取按键信息。
二、语法
Console.ReadKey()
三、核心特点（必背）
- 读取一个按键，任意键都能触发
- 不需要按回车，按下立即返回
- 返回类型是 ConsoleKeyInfo 结构体
- 默认会在屏幕显示按下的字符
- 可以带参数 true 实现不显示输入（隐藏输入）
四、常用写法
1. 最简单写法（暂停程序）
Console.ReadKey();
2. 读取按键并接收
ConsoleKeyInfo key = Console.ReadKey();
3. 隐藏输入（不显示按键）
Console.ReadKey(true);
五、常用属性（ConsoleKeyInfo 的 3 个常用属性）
- .Key → 获取按键名称（如 Enter、A、D1）
- .KeyChar → 获取按键对应的字符（char 类型）
- .Modifiers → 获取控制键（Ctrl/Shift/Alt）
示例：
ConsoleKeyInfo k = Console.ReadKey();Console.WriteLine(k.Key); //输出按键名Console.WriteLine(k.KeyChar); //输出字符
六、Console.Read ()、ReadLine ()、ReadKey () 对比
|
方法 |
读取内容 |
返回类型 |
是否需要回车 |
|
Console.Read() |
一个字符的 ASCII 码 |
int |
需要 |
|
Console.ReadLine() |
一整行字符串 |
string |
需要 |
|
Console.ReadKey() |
一个按键 |
ConsoleKeyInfo |
不需要 |
七、最常用场景
- 让控制台程序运行完不闪退
- 按任意键继续
- 监听用户快捷键操作
- 隐藏输入密码
C# 输出语句
一、输出语句作用
将程序中的数据、变量、计算结果显示在控制台屏幕上。
二、两种核心输出语句
1. Console.WriteLine();
作用：输出内容后自动换行
语法：
Console.WriteLine(内容);
2. Console.Write();
作用：输出内容后不换行，继续在本行输出
语法：
Console.Write(内容);
三、输出的 4 种常用写法
1. 输出字符串常量
Console.WriteLine("Hello World");
2. 输出变量
int a = 10;
Console.WriteLine(a);
3. 字符串拼接输出
string name = "张三";
Console.WriteLine("姓名：" + name);
4. 字符串插值（C# 6.0+）
Console.WriteLine($"姓名：{name}，年龄：{age}");
四、核心区别（必背）
|
语句 |
换行 |
用法 |
|
Console.WriteLine() |
自动换行 |
输出一行 |
|
Console.Write() |
不换行 |
连续输出 |
五、输出占位符 {0} {1}
{索引}：表示占位符，索引从0开始，依次对应后面的参数，{0} 对应第一个参数，{1} 对应第二个参数。占位符索引必须与参数顺序一致、数量匹配，否则会报格式异常
示例： string name=”张三”;
int age=16;
Console.WriteLine("姓名：{0}，年龄：{1}", name, age);
可以在占位符中添加格式符，语法为{N[,M][:Yn]}，用于控制参数的显示格式（对齐、小数精度等）。
N表示占位符的序号，0对应第一个变量，1对应第二个变量，以此类推。
[,M]是可选项，M表示输出的变量在控制台中所占的字符个数。正数右对齐，负数左对齐。
示例： Console.WriteLine(121212);
Console.WriteLine("{0,6}",12);
Console.WriteLine("{0,-6}",12);
运行结果：
[:Yn]是可选项，Y是格式化说明符，n为正整数，代表定义数据的精度范围。
常用格式化说明符：
|
格式说明符 |
名称 |
说明 |
示例(值：1234.567) |
输出结果 |
|
F或f |
定点数 |
指定小数位数。F2表示保留两位小数 |
{1234.567:F2} |
1234.57 |
|
N或n |
数字 |
带千位分隔符，可指定小数位数 |
{1234.567:N2} |
1，234.57 |
|
C或c |
货币 |
使用区域性货币格式 |
{1234.567:C2} |
￥1234.57 |
|
P或p |
百分比 |
将数字乘以100并添加% |
{0.567:P1} |
56.7% |
|
E或e |
科学技术法 |
指数表示法。E2表示保留两位小数 |
{1234.567:E2} |
1.23E+003 |
|
D或d |
十进制 |
仅用于整数类型，可指定最小位数 |
{123:D6} |
000123 |
|
X或x |
十六进制 |
仅用于整数类型，X为大写输出大写十六进制，x为小写输出小写十六进制 |
{255:X} {255:x} |
FF ff |
六、输出转义字符
\n：换行
\t：制表符（Tab）
\"：输出双引号
示例：
Console.WriteLine("第一行\n第二行");
分支结构
单分支语句
一、单分支语句是什么
单分支语句：只有一个分支的条件判断结构。
当条件成立（为 true）时，执行大括号里的代码；
条件不成立（为 false）时，跳过不执行。
二、核心作用
根据条件决定是否执行某段代码。
三、语法格式
1. 标准写法
if (条件表达式)
{
// 条件成立时要执行的语句;
}
2. 只有一条语句时（可省略大括号，不推荐）
if (条件表达式)
执行语句;
四、执行流程
- 先计算 ( ) 里的条件表达式，结果一定是 bool 类型（true /false）
- 如果结果为 true → 执行 { } 里的代码
- 如果结果为 false → 直接跳过 { }，不执行
五、条件表达式
条件表达式是一个能够计算为布尔值的表达式。
六、经典示例
示例 1：判断年龄是否满 18 岁
int age = 20;
if (age >= 18)
{
Console.WriteLine("已成年");
}
示例 2：判断分数是否及格
int score = 85;
if (score >= 60)
{
Console.WriteLine("及格");
}
七、注意事项（易错点）
- if 后面没有分号
if (a > b); // 错误！多了分号
- 条件必须放在 小括号 ( ) 里
- 大括号 { } 里的代码建议缩进，可读性更强
- 判断相等必须用 ==，不能用 =（= 是赋值）
C# 双分支语句
一、双分支语句是什么
双分支语句：有两个分支的条件判断结构。
- 条件成立（true）：执行第一块代码
- 条件不成立（false）：执行第二块代码
两个分支必定执行其中一个，不会都不执行。
二、核心作用
根据条件二选一执行代码。
三、语法格式（标准写法）
if (条件表达式)
{
// 条件为 true 时执行
}
else
{
// 条件为 false 时执行
}
四、执行流程（必背）
- 先计算小括号 ( ) 里的条件，结果是 bool 类型（true/false）
- 条件为 true → 执行 if 大括号里的语句
- 条件为 false → 执行 else 大括号里的语句
五、条件表达式
条件表达式是一个能够计算为布尔值的表达式。
六、经典示例
示例 1：判断是否成年（双分支版）
int age = 17;
if (age >= 18)
{
Console.WriteLine("已成年");
}
else
{
Console.WriteLine("未成年");
}
示例 2：判断成绩是否及格
int score = 55;
if (score >= 60)
{
Console.WriteLine("成绩及格");
}
else
{
Console.WriteLine("成绩不及格");
}
七、注意事项（易错点）
- if 后面不能写分号，else 后面也不能写分号
- else 不能单独使用，必须和 if 配对
- 判断相等用 ==，不能用 =（= 是赋值）
- 条件必须放在 ( ) 里
- if 和 else 的代码块建议用 { } 括起来
八、单分支 vs 双分支（区别）
- 单分支（if）：满足才执行，不满足跳过
- 双分支（if-else）：满足执行 if，不满足执行 else，二选一
多分支语句 C# switch...case 语句
一、switch...case 是什么
switch...case 是 C# 中的多分支选择语句。
根据一个变量 / 表达式的固定值，匹配对应的 case 执行代码，属于等值判断结构。
二、核心作用
用于固定值匹配的多分支判断（如：星期、月份、等级、菜单选项等）。
三、语法格式（标准写法）
switch (表达式)
{
case 常量1:
执行语句;
break;
case 常量2:
执行语句;
break;
case 常量3:
执行语句;
break;
default:
所有case都不匹配时执行;
break;
}
四、执行流程（必背）
- 计算 switch( ) 里变量的值
- 从上到下匹配 case 后的常量
- 找到匹配的 case → 执行里面代码 → 遇到 break 跳出
- 没有任何匹配 → 执行 default 分支
- 每个分支执行完必须跳出，不能穿透
五、支持的数据类型
switch 支持等值判断类型：
- int、char、string、enum、bool 等
不支持范围判断（如 >=、<=）
六、经典示例（成绩等级）
int score = 85;
int level = score / 10;
switch (level)
{
case 10:
case 9:
Console.WriteLine("优秀");
break;
case 8:
Console.WriteLine("良好");
break;
case 7:
case 6:
Console.WriteLine("及格");
break;
default:
Console.WriteLine("不及格");
break;
}
七、关键字说明
- switch：表示开始多分支选择
- case：标记一个匹配项，后面必须是常量
- break：跳出 switch 结构（必须写）
- default：所有 case 不匹配时执行（可选，建议写）
八、注意事项（易错点・考试必考）
- case 后面必须是常量，不能是变量 / 表达式
- 同一个 switch 中 case 常量不能重复
- 每个 case 结尾必须写 break，不能直通
- switch 只能做等值匹配，不能判断范围
- 多个 case 可以共用一组代码（合并 case）
- default 可选，放在任意位置都可以（建议放最后）
九、switch 与 if 多分支区别
- if 多分支：可以判断范围、条件、逻辑运算
- switch：只能判断固定值等值匹配
- 能用 switch 实现的，一定能用 if 实现；反之不一定
窗体的创建
Windows应用程序开发步骤
- 启动Visual Studio2010
- 创建项目
- 界面设计
- 设置属性
- 编写代码
- 双击窗体或控件，可进入该对象的默认事件。
- 使用“属性”窗口中的事件列表，双击需要编写代码的事件名。
- 运行调试代码
（1）“调试”菜单—“启动调试”命令。
（2）F5
（3）标准工具栏中的
命令。
- 保存程序
（1）“文件”—“全部保存”命令。
（2）标准工具栏中的
按钮。
窗体的结构
任务实施
更多推荐
6
0- 0
已为社区贡献1条内容
所有评论(0)