一.基本的数据类型

1.什么是数据类型

在编程语言中，数据类型（Data Type） 是对变量存储的 “数据的种类” 的定义，它决定了：

变量可以存储哪些值（例如整数、文本、布尔值）。
这些值在内存中如何存储（占用多少字节）。
可以对这些值执行哪些操作（例如加法、比较、调用方法）。

为什么需要数据类型？

内存管理：不同类型的数据占用不同大小的内存（例如 int 通常占 4 字节，long 占 8 字节）。
操作安全：防止不合法的操作（例如对字符串执行除法）。
代码可读性：明确变量用途（例如 age 应为整数，而非字符串）。

常见数据类型分类

1. 值类型（Value Types）

直接存储数据值，内存分配在栈（Stack）上。
常见类型：
- 整数：无符号的八位整数byte（8 位）、有符号的八位整数：sbyte（八位）、有符号的16位整数short（16 位）、int（32 位）、long（64 位）。
- 浮点数：float（单精度）、double（双精度）。
- 布尔值：逻辑值bool（true 或 false）。字节大小：1
- 字符：char（单个 Unicode 字符，如 'A'）。
- 枚举（enum）：自定义命名常量集合。
- 结构体（struct）：自定义值类型。

示例（C#）：

int age = 25;          // 整数
double height = 1.75;  // 浮点数
bool isStudent = true; // 布尔值
char grade = 'A';      // 字符

2. 引用类型（Reference Types）

存储数据的引用（内存地址），数据本身存储在堆（Heap）上。
常见类型：
- 字符串：string（不可变的字符序列，如 "Hello"）。
- 数组：int[] numbers = new int[5];（存储固定大小的同类型元素）。
- 类（class）：自定义引用类型，如 Person、List<T>。
- 接口（interface）：定义行为契约。
- 委托（delegate）：函数指针。

示例（C#）：

string name = "Alice";  // 字符串
int[] numbers = {1, 2, 3}; // 数组

3. 指针类型（Pointer Types）

直接存储内存地址，主要用于高性能或系统级编程（C# 中需在 unsafe 上下文中使用）。

unsafe {int num = 10;int* p = &num; // 指向整数的指针
}

4. 特殊类型

dynamic：在运行时确定类型（C# 4.0+）。

dynamic value = "Hello"; // 编译时不检查类型
value = 123;             // 运行时动态绑定

object：所有类型的基类型（可存储任意类型的值）。
void：表示 “无返回值”（用于方法返回类型）。

类型转换

隐式转换：小范围类型自动转为大范围类型（如 int → long）。
```
int a = 10;
long b = a; // 隐式转换
```
显式转换（强制转换）：大范围类型转为小范围类型（可能丢失数据）。
```
double x = 3.14;
int y = (int)x; // 显式转换，结果为 3
```
方法转换：使用 Convert 类或类型自身的方法（如 int.Parse）。
```
string s = "123";
int num = int.Parse(s); // 字符串转整数
```

C# 中的泛型（Generic Types）

参数化类型：定义时不指定具体类型，使用时再传入。

List<int> numbers = new List<int>(); // 泛型集合，存储整数
Dictionary<string, int> ages = new Dictionary<string, int>(); // 键值对

不同语言的数据类型差异

特性	C#	JavaScript	Python
静态类型	是（编译时检查类型）	否（动态类型）	否（动态类型）
内置整数类型	`byte`, `short`, `int`	统一为 `Number`	统一为 `int`
字符串类型	不可变 `string`	不可变 `string`	不可变 `str`
数组	固定类型 `int[]`	动态类型 `[]`	动态类型 `list`

二.常量、变量、运算符、表达式、语句

1.常量

常量是在程序运行过程中值始终保持不变的量。它的值在定义时被确定，之后无法修改。

常量定义的格式：const int a=10;

常见类型：
- 数值常量：如整数（100）、浮点数（3.14）。
- 字符串常量：用引号括起来的文本，如"Hello"、'编程'。
- 布尔常量：True（真）或False（假）（部分语言中用1和0表示）。
- 特殊常量：如 Python 中的None（表示空值）、数学中的π（圆周率，约 3.14159）。

2.变量

变量是在程序运行过程中值可以被修改的量，它用于存储数据，相当于一个 “容器”，有自己的名称（变量名）和数据类型。

变量定义的格式：类型修饰符变量名 = 初始值

例如：int age = 2；

类型修饰符：规定了变量的空间大小，以及变量的数据类型

变量名：变量的名字，起标识作用

初始值：变量定义的默认值

使用float的时候要在数字后加一个f，double后必须加入一个d

3.常量和变量的命名规则

只能包含特定字符
- 允许使用字母（a-z, A-Z）、数字（0-9）和下划线（_）。
- 不能以数字开头，例如123name是非法的，而name123合法。
区分大小写
- 变量age和Age是不同的变量（如 Python、Java、C++ 等语言）。
不能使用关键字
- 不能使用编程语言的保留字（如if、else、for、class等）作为名称。
- 例如，在 Python 中if = 5会报错，因为if是关键字。
建议使用有意义的名称
- 变量名应反映其用途，例如用age存储年龄，而不是用无意义的a。
- 常量名通常使用全大写字母，例如MAX_VALUE。

4.运算符

（1）赋值运算符

用于给变量赋值，将右边的值赋值给左边

赋值运算优先级较低

（2）算数运算符

用于参与计算

（3）++运算符和--运算符

a++等价于a=a+1

++age是让age加一在进行赋值

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;namespace _01
{internal class Program{static void Main(string[] args){int num = 10;num = num++ + --num - ++num;Console.WriteLine(num);}}
}

（4）复合运算符

a+=b等价于a=+b

5.表达式

表达式是由常量、变量、运算符组合而成的式子，它会被计算并返回一个结果。

特点：
- 表达式必须有明确的计算结果，结果的类型由参与运算的元素决定（如数值表达式返回数值，布尔表达式返回布尔值）。
- 表达式不能单独作为程序的执行单位，通常用于赋值、判断条件等场景。
示例：
- 数值表达式：3 + 5 * 2（结果 13）、x / 10（x是变量）。
- 布尔表达式：age > 18 and score >= 60（判断年龄是否大于 18 且分数是否不低于 60）。
- 字符串表达式："Hello" + " " + "World"（结果"Hello World"）。

6.语句

程序执行的最小单位，在c#中每一句都有分号结尾

7.数据类型的转换

（1）隐式转换

特点：从小范围类型到大范围类型的安全转换，无需显式语法。
适用场景：例如int转double、char转int等。

int num = 10;
double d = num;  // 隐式转换：int → double（10 → 10.0）char c = 'A';
int code = c;    // 隐式转换：char → int（'A' → 65，ASCII码）

（2）显式转换（强制转换）

特点：从大范围类型到小范围类型的转换，可能丢失数据，需用(目标类型)语法。
适用场景：例如double转int、object转具体类型。

double d = 3.14;
int num = (int)d;  // 显式转换：double → int（3.14 → 3，截断小数部分）object obj = "Hello";
string str = (string)obj;  // 显式转换：object → string

注意：强制转换可能引发InvalidCastException（如将int类型的object转为string）。

（3）类型转换方法

1. ToString()

将任意类型转换为字符串。

int num = 123;
string str = num.ToString();  // "123"bool isTrue = true;
string result = isTrue.ToString();  // "True"

2. GetTypeCode()

获取值类型的类型代码，结合TypeCode枚举判断类型。

int num = 10;
TypeCode typeCode = num.GetTypeCode();  // TypeCode.Int32

（4）Convert 类

特点：提供静态方法进行类型转换，自动处理格式和范围问题，更安全。
常用方法：ToInt32()、ToDouble()、ToString()、ToBoolean()等。

string str = "123";
int num = Convert.ToInt32(str);  // 字符串 → 整数（123）object obj = 3.14;
double d = Convert.ToDouble(obj);  // object → double（3.14）string boolStr = "true";
bool isTrue = Convert.ToBoolean(boolStr);  // 字符串 → 布尔值（true）

注意：若转换失败（如"abc"转int），会抛出FormatException。

（5）Parse 与 TryParse（字符串转数值）

1. Parse()

直接解析字符串为目标类型，失败时抛出异常

string str = "456";
int num = int.Parse(str);  // 解析为整数（456）// 若字符串格式错误，会抛出FormatException
// string invalidStr = "abc";
// int error = int.Parse(invalidStr);  // 错误！

2. TryParse()

安全解析字符串，返回布尔值表示成功或失败，结果通过out参数输出。

string str = "789";
if (int.TryParse(str, out int result))
{Console.WriteLine($"解析成功：{result}");  // 输出：解析成功：789
}
else
{Console.WriteLine("解析失败");
}

推荐：优先使用TryParse()避免异常，提高程序健壮性。

（6）自定义类型转换

1. 实现接口

通过实现IConvertible接口自定义类型转换逻辑。

public class Person : IConvertible
{public string Name { get; set; }public int Age { get; set; }// 实现IConvertible接口的方法（略）public TypeCode GetTypeCode() => TypeCode.Object;// 其他方法...
}

2. 转换运算符

使用implicit（隐式）或explicit（显式）关键字定义自定义类型转换。

public class Meter
{public double Value { get; set; }// 隐式转换：Meter → Kilometerpublic static implicit operator Kilometer(Meter meter){return new Kilometer { Value = meter.Value / 1000 };}// 显式转换：Kilometer → Meterpublic static explicit operator Meter(Kilometer km){return new Meter { Value = km.Value * 1000 };}
}public class Kilometer
{public double Value { get; set; }
}// 使用示例
Meter m = new Meter { Value = 5000 };
Kilometer km = m;  // 隐式转换
Meter newM = (Meter)km;  // 显式转换

（7）装箱与拆箱

1. 装箱（Boxing）

将值类型转换为引用类型（如int转object）。

int num = 100;
object obj = num;  // 装箱：值类型 → object

2. 拆箱（Unboxing）

将引用类型转换回值类型，需显式转换。

object obj = 100;
int num = (int)obj;  // 拆箱：object → int

注意：频繁装箱拆箱会影响性能，建议优先使用泛型集合（如List<int>）替代ArrayList。

（8）总结与选择建议

转换方式	适用场景	示例
隐式转换	小范围类型到大范围类型的安全转换	`int → double`
显式转换（强制）	大范围类型到小范围类型的转换（可能丢失数据）	`double → int`
Convert 类	不同类型间的安全转换（如字符串转数值、对象转基本类型）	`Convert.ToInt32("123")`
Parse/TryParse	字符串解析为数值类型，TryParse 更安全（避免异常）	`int.TryParse("123", out num)`
自定义转换	自定义类型之间的转换（通过运算符或接口）	`implicit operator`
装箱 / 拆箱	值类型与引用类型（如`object`）之间的转换，性能开销大	`int → object → int`

三.基本输入、输出函数

场景	常用方法 / 类	示例代码
控制台输出	`Console.WriteLine()`	`Console.WriteLine("Hello");`
控制台输入	`Console.ReadLine()`	`string name = Console.ReadLine();`
文件写入	`File.WriteAllText()`	`File.WriteAllText("test.txt", "内容");`
文件读取	`File.ReadAllText()`	`string content = File.ReadAllText("test.txt");`
二进制写入	`BinaryWriter`	`using (var writer = new BinaryWriter(File.Create("data.bin"))) { writer.Write(123); }`
二进制读取	`BinaryReader`	`using (var reader = new BinaryReader(File.Open("data.bin", FileMode.Open))) { int num = reader.ReadInt32(); }`

输出函数：

Console.WriteLine输出换行

Console.Write输出不换行

输入函数：

Console.Read读取一个字符

Console.ReadLine：读取一个字符串

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;namespace _02
{internal class Program{static void Main(string[] args){string myname = "syn";string inputname = Console.ReadLine();Console.WriteLine("您输入的内容是");Console.WriteLine(inputname);}}
}