this 指向当前类实例（或当前类本身，静态场景），base 指向父类实例，核心用于访问自身/父类的成员、调用构造函数。
- this：1. 访问当前实例成员（区分局部变量与字段，如  this.name = name ）；2. 调用当前类其他构造函数（ this(参数) ，构造器重载复用）；3. 索引器定义（ public 类型 this[参数] { get; set; } ）。

 继承规则：用 : 继承（类仅单继承），子类可访问父类 public / protected / protected internal 成员，隐藏 private 成员；

允许子类用 override 重写实现的父类方法，核心用于实现“运行时多态”（同一调用语句根据对象实际类型执行不同逻辑）。
- 用 virtual 关键字修饰父类方法，必须有默认实现（不能像抽象方法无体）；
- 子类可选择重写（用 override ）或不重写（继承父类实现）；
- 重写后仍可被孙子类继续重写（除非用 sealed override 密封）；
- 调用规则：通过父类引用指向子类对象时，执行子类重写后的逻辑（多态核心）。
 

this 指向当前类实例（或当前类本身，静态场景），base 指向父类实例，核心用于访问自身/父类的成员、调用构造函数。
- this：1. 访问当前实例成员（区分局部变量与字段，如  this.name = name ）；2. 调用当前类其他构造函数（ this(参数) ，构造器重载复用）；3. 索引器定义（ public 类型 this[参数] { get; set; } ）。
- base：1. 访问父类成员（如  base.Speak()  调用父类方法，解决成员隐藏）；2. 调用父类指定构造函数（ base(参数) ，子类构造第一行，显式指定父类构造）。
关键规则： this(...)  和  base(...)  不能同时出现在构造函数第一行，且仅能用于构造函数中。
 

继承核心是“子类继承父类非私有成员”，子类构造函数的关键是必须先调用父类构造（保证父类初始化），再处理自身逻辑。
1. 继承规则：用 : 继承（类仅单继承），子类可访问父类 public / protected / protected internal 成员，隐藏 private 成员；
2. 构造函数调用：
- 隐式：子类构造无显式指定时，默认用 base() 调用父类无参构造（父类需存在无参构造）；
- 显式：用 base(参数) 调用父类指定构造（如子类需传参给父类），或 this(参数) 调用子类其他构造（复用逻辑）；
3. 关键限制： base / this 必须是构造函数第一行，且不能同时使用；父类无无参构造时，子类必须显式调用父类有参构造。
 

继承是实现代码复用、建立类型层级的核心特性，允许子类（派生类）继承父类（基类）的非私有成员（字段、方法等），并可扩展或重写父类行为。
- 用  :  表示继承（如  class Student : Person ），C# 仅支持单继承（子类只能有一个直接父类）；
- 子类自动拥有父类的  public / protected / internal  成员， private  成员不可直接访问（需通过父类公共方法间接访问）；
- 核心目的：复用父类共性代码（如  Person  的  Name  属性），子类专注实现自身特性（如  Student  的  StudentId  属性），配合  virtual / override  实现多态。
 

方法隐藏是C#中子类用  new  关键字重定义父类同名成员（方法/属性等），让父类成员在子类中“不可见”，本质是“子类定义新成员，而非重写父类成员”。
- 语法：子类成员前加  new  关键字（如  public new void Show() ），无  new  会有编译警告；
- 调用规则：通过父类引用指向子类实例时，调用父类原方法；通过子类引用时，调用子类隐藏后的方法；
- 与重写（ override ）区别：重写是替换父类虚方法实现（多态），隐藏是定义独立新成员（无多态）。
 

1.抽象类（ abstract class ）*不可实例化、可继承（单）、包含抽象与非抽象成员
抽象类是包含抽象成员（无实现）的类，核心作用是“定义基类模板，强制子类实现核心行为”，不能直接实例化。
- 用  abstract  关键字定义，可包含抽象成员（ abstract 方法/属性 ）和非抽象成员（有实现）；
- 子类必须用  override  实现所有抽象成员（除非子类也是抽象类）；
- 支持单继承（子类只能继承一个抽象类），是“部分实现+部分抽象”的设计。

2.密封类（ sealed class ） *可实例化、不可继承、仅含抽象成员（或密封重写成员）
密封类是禁止被继承的类，核心作用是“阻止类被扩展，保护核心逻辑不被修改”，可直接实例化。
- 用  sealed  关键字定义，不能作为父类（子类无法继承）；
- 可包含任意非抽象成员（无特殊限制），也可密封方法（ sealed override ，阻止子类重写父类虚方法）；

 

核心是必须先调用父类构造函数（默认隐式调用父类无参构造，也可显式指定），再初始化子类自身成员。 
- 隐式调用：子类构造函数无显式指定时，默认用  base()  调用父类无参构造（父类必须存在无参构造，否则报错）；
- 显式调用：用  base(参数)  调用父类指定构造（如  public Student(string name) : base(name) {} ），或  this(参数)  调用子类其他构造（构造函数重载复用）；
- 关键规则： base / this  必须是构造函数体第一行代码，且不能同时使用。
 
 

public （全公开）、 private （仅当前类）、 protected （当前类+子类）、 internal （同一程序集）、 protected internal （子类或同一程序集）；
- 行为修饰符（常用）： static （属于类型）、 abstract （抽象，无实现）、 sealed （密封，不可继承/重写）、 virtual （可重写）、 override （重写父类成员）、 readonly （只读字段）、 const （编译时常量）。
1. public（全公开）
- 场景：需要被其他项目、当前程序集所有类访问的类型/成员。
2. private（仅当前类）
- 场景：类内部的辅助逻辑、私有数据，不想被外部（包括子类）访问。
3. protected（当前类+子类）
- 场景：父类的核心能力/数据，允许子类继承复用，但不对外开放。
4. internal（同一程序集）
- 场景：仅需在当前项目内共享的类型/成员，对外隐藏实现细节。
5. protected internal（子类或同一程序集） 
- 场景：需在当前项目内共享，且允许子类跨项目继承访问的成员。
 

- 访问修饰符： public （公开，全范围访问）、 private （私有，仅当前类访问）、 protected （保护，当前类+子类访问）、 internal （内部，同一程序集访问）、 protected internal （保护+内部，子类或同一程序集访问）；
- 行为修饰符： abstract （抽象，修饰类/方法，类不能实例化、方法无实现）、 sealed （密封，修饰类/方法，类不能被继承、方法不能被重写）、 virtual （虚拟，修饰方法/属性，允许子类重写）、 override （重写，子类覆盖父类虚拟成员）、 const （常量，编译时确定值，必须声明时赋值，属于类型）。
 readonly  用于修饰字段，表字段只能在声明时或构造函数中赋值，之后不可修改（运行时确定值）。
1. 可修饰实例字段/静态字段（ static readonly ），静态只读字段仅能在静态构造函数中赋值；
2. 与  const  区别： const  是编译时常量（值固定）， readonly  是运行时常量（可通过构造函数动态赋值）；
3.const不能与static一起使用且必须声明时直接赋值
 

static（静态） 是C#中修饰类、成员（字段、方法、属性等）的关键字，核心是“属于类型本身，而非类型的实例”，无需创建对象即可访问。
- 静态成员：用 static 修饰，存储在全局内存区，所有实例共享，通过“类型名.成员名”访问（如 Math.PI 、 Console.WriteLine() ）；
- 静态类：用 static class 定义，只能包含静态成员，不能实例化（如 Math 类），常用于工具类；
- 关键限制：静态成员不能访问非静态成员（无实例上下文），非静态成员可访问静态成员；静态构造函数无参数、仅执行一次（初始化静态字段）。
 
 

接口是定义“行为契约”的抽象类型，仅声明方法、属性、事件等成员签名（无实现），强制实现类遵循统一规范。
- 用 interface 关键字定义，成员默认 public abstract （无需显式写）；
- 类/结构体用 : 实现接口，需实现所有成员（C# 8.0+支持接口默认实现，可选实现）；
- 支持多实现（一个类可实现多个接口），是实现“多态”和“解耦”的核心手段。
 
 

接口继承是指接口可继承一个或多个其他接口，实现“接口间的功能组合与扩展”，类实现派生接口时需实现所有继承的接口成员
- 用 : 表示继承，支持多继承（类只能单继承类，但接口可多继承接口）；
- 派生接口会包含所有基接口的成员，无需重复定义；
- 类实现派生接口时，必须实现该接口及所有基接口的全部抽象成员（无默认实现的成员）。

索引数组里有用到，用shis关键字定义，语法类似public类型this[参数类型  索引名]{get;set;}；

索引值类型不限（可int  string等），支持重载（不同参数类型/个数）

必须用operator关键字定义，且多为静态方法

不能创新只能重载，就是把函数重写

继承是指子类通过（派生类）通过父类（基类）的非私有成员（如属性、方法），同时可以扩展自身专属成员，实现代码复用和逻辑分层。

继承包括：1.单继承限制：一个子类仅能拥有一个直接父类，无法同时继承多个类。

2.成员访问限制：子类默认继承父类的public/protected/internal成员，private长远无法访问权限限制无法直接使用。

3.“is-a”关系：子类与父类需满足逻辑上的从属关系（如“Student是Person”“Dog是Animal"），而非单纯的代码复用。

父类里面有两个数据，数据成员有两个函数成员，由父类派生出两个子类。

子类是由父类继承过来的，所以父类里面所有的代码都会被子类（派生类）继承。

子类（派生类）可以有自己的数据和函数。

队列Queue

使用方式和栈类似

入队、出队

Peek队头的数据

Dequeue 出队（从队头开始）

Contains()

Count

myTS.clear(); //清空

myTS.Contains() //是否包含某个数值（返回布尔）

myTS.Counts //栈内的数值

CopyTo 将栈里面的数值复制到Array中

ToArray 把栈转换成一个数组