C#面相对像的编程

本章节学习目标：

学习C#语言基础
打好C#面相对象的基础

环境配置：

UnityTA学习计划
学习教程（C#编程-第二季-面向对象-宇宙最简单2021最新版）
参考网址（C# 教程 | 菜鸟教程）
VScode
JetBrains Rider 2024
Unity2022·····

一、调试和错误处理

1、什么是调试和错误处理？

调试是识别、定位和修复程序中的错误（bug）的过程。调试通常涉及逐步执行代码、检查变量状态、输出中间结果等，以找出问题的根源。
错误处理是指在程序中预见可能的错误，并编写代码来处理这些错误，防止程序崩溃或产生不可预期的结果。常见的错误处理方式包括使用异常处理机制（如 try-catch 块）来捕获和处理异常。

2、使用输出语句和Debug模式调试程序

使用输出语句调试：通过在代码中插入输出语句（如 Console.WriteLine），输出变量的值或程序执行到某一步的状态。

csharp int x = 10; Console.WriteLine("x 的值是: " + x); // 输出 x 的值

使用Debug模式调试：在 Visual Studio 等 IDE 中，可以使用 Debug 模式设置断点，逐步执行代码，查看变量的值、调用栈等信息。

3、中断模式下的窗口介绍

在 Debug 模式下，程序执行到断点时会进入中断模式。此时，程序暂停执行，开发者可以查看和修改变量的值，检查调用栈等。常见的窗口包括：

局部变量窗口：显示当前作用域内的变量及其值。
调用堆栈窗口：显示当前函数的调用链，帮助理解程序的执行流程。
监视窗口：允许开发者添加特定的变量或表达式进行监视。
输出窗口：显示程序的输出信息，如调试信息、错误信息等。

4、逐语句逐过程（中断模式）

在中断模式下，开发者可以逐步执行代码：

逐语句（Step Into）：执行当前行的代码，如果遇到函数调用，会进入该函数内部，继续逐行执行。
逐过程（Step Over）：执行当前行的代码，如果遇到函数调用，不会进入函数内部，而是将整个函数作为一步执行。
跳出（Step Out）：如果当前在某个函数内部，执行该函数的剩余部分，并返回到调用该函数的地方。

5、关于程序中的异常

异常是程序运行时发生的错误或意外情况。常见的异常包括除以零、空指针引用、数组越界等。异常会中断程序的正常执行流程，如果没有处理，程序可能会崩溃。

csharp try { int result = 10 / 0; // 除以零会抛出 DivideByZeroException } catch (DivideByZeroException ex) { Console.WriteLine("错误: " + ex.Message); // 捕获并处理异常 }

C# 提供了异常处理机制，允许开发者捕获并处理异常，从而避免程序崩溃。例如，使用 try-catch 块来捕获异常。

6、使用trycatch检查用户输入的数据是否合法

try-catch 结构可以用来捕获和处理用户输入时可能出现的异常。例如，检查用户输入的是否是一个合法的整数：

//try 中放置可能出现异常的代码
try
{
    Console.Write("请输入一个整数: ");
    string userInput = Console.ReadLine();
    int number = int.Parse(userInput); // 尝试将输入转换为整数
    Console.WriteLine("你输入的整数是: " + number);
}
//catch代表我们要捕捉哪些异常
catch (FormatException)
{
    Console.WriteLine("输入的不是一个合法的整数！");
}
catch (Exception ex)
{
    Console.WriteLine("发生错误: " + ex.Message);
}
//finally代表不管任何情况都能执行的代码
finally
{

}

二、什么是面相对象的编程？

1、什么是面向对象的编程？

面向对象编程（Object-Oriented Programming，OOP） 是一种编程范式，它以“对象”为核心来组织代码和数据。对象是现实世界中事物的抽象，包含属性（数据）和方法（行为）。OOP 的核心思想是将程序分解为多个相互独立的对象，每个对象负责特定的功能。
OOP 的四大基本特性：
封装（Encapsulation）：
- 将数据（属性）和行为（方法）封装在一个对象中。
- 隐藏内部实现细节，只暴露必要的接口。
- 例如：类的私有字段和公共方法。
继承（Inheritance）：
允许一个类（子类）继承另一个类（父类）的属性和方法。
支持代码复用和层次化设计。
例如：Dog 类继承自 Animal 类。
多态（Polymorphism）：
同一个方法在不同对象中有不同的实现。
通过接口或父类引用调用子类的方法。
例如：Animal 类的 Speak 方法在 Dog 和 Cat 类中有不同的实现。
抽象（Abstraction）：
提取对象的共同特征，忽略不必要的细节。
通过抽象类或接口定义通用的行为。
例如：定义一个 Shape 抽象类，包含 Draw 方法。

2、为什么使用面向对象的编程？

使用面向对象编程的主要原因是它能够更好地组织和管理复杂的代码，提高代码的可维护性、可扩展性和复用性。
代码复用
通过继承和组合，可以复用已有的代码，减少重复编写代码的工作量。
例如：多个类可以共享父类的属性和方法。
模块化设计
将程序分解为多个独立的对象，每个对象负责特定的功能。
模块化设计使得代码更易于理解和维护。
易于维护和扩展
封装隐藏了对象的内部实现细节，修改对象的内部逻辑不会影响其他部分的代码。
通过继承和多态，可以轻松扩展程序的功能。
提高代码的可读性
面向对象的代码更接近现实世界的模型，易于理解和描述。
例如：将“学生”和“课程”建模为对象，代码逻辑更直观。
支持团队协作
不同的开发者可以负责不同的对象或模块，降低代码冲突的风险。
通过定义清晰的接口，团队成员可以并行开发。
更好的错误处理
通过封装和抽象，可以将错误限制在局部范围内，避免错误扩散到整个程序。
例如：在对象内部处理异常，外部调用者无需关心细节。
模拟现实世界
面向对象编程能够更好地模拟现实世界中的事物和关系。
例如：将“汽车”建模为一个对象，包含属性（颜色、品牌）和方法（启动、停止）。
面相对象实例：

```csharp using System;

// 父类：动物 class Animal { public string Name { get; set; }

   public Animal(string name)
   {
       Name = name;
   }

   // 虚方法，子类可以重写
   public virtual void Speak()
   {
       Console.WriteLine("动物发出声音");
   }

}

// 子类：狗 class Dog : Animal { public Dog(string name) : base(name) { }

   // 重写父类的方法
   public override void Speak()
   {
       Console.WriteLine($"{Name} 汪汪叫");
   }

}

// 子类：猫 class Cat : Animal { public Cat(string name) : base(name) { }

   // 重写父类的方法
   public override void Speak()
   {
       Console.WriteLine($"{Name} 喵喵叫");
   }

}

class Program { static void Main(string[] args) { Animal myDog = new Dog("小黑"); Animal myCat = new Cat("小白");

       myDog.Speak(); // 输出：小黑 汪汪叫
       myCat.Speak(); // 输出：小白 喵喵叫
   }

} ```

三、类

1、定义类

//类的定义是以关键字 class 开始，后跟类的名称。类的主体，包含在一对花括号内。下面是类定义的一般形式：
<access specifier> class  class_name 
{
    // member variables
    <access specifier> <data type> variable1;
    <access specifier> <data type> variable2;
    ...
    <access specifier> <data type> variableN;
    // member methods
    <access specifier> <return type> method1(parameter_list) 
    {
        // method body 
    }
    <access specifier> <return type> method2(parameter_list) 
    {
        // method body 
    }
    ...
    <access specifier> <return type> methodN(parameter_list) 
    {
        // method body 
    }
}
//请注意：

//访问标识符 <access specifier> 指定了对类及其成员的访问规则。如果没有指定，则使用默认的访问标识符。类的默认访问标识符是 internal，成员的默认访问标识符是 private。
//数据类型 <data type> 指定了变量的类型，返回类型 <return type> 指定了返回的方法返回的数据类型。
//如果要访问类的成员，你要使用点（.）运算符。
//点运算符链接了对象的名称和成员的名称。

2、创建对象和使用对象

//创建一个Box类并使用
using System;
namespace BoxApplication
{
    class Box
    {
       public double length;   // 长度
       public double breadth;  // 宽度
       public double height;   // 高度
    }
    class Boxtester
    {
        static void Main(string[] args)
        {
            Box Box1 = new Box();        // 声明 Box1，类型为 Box
            Box Box2 = new Box();        // 声明 Box2，类型为 Box
            double volume = 0.0;         // 体积

            // Box1 详述
            Box1.height = 5.0;
            Box1.length = 6.0;
            Box1.breadth = 7.0;

            // Box2 详述
            Box2.height = 10.0;
            Box2.length = 12.0;
            Box2.breadth = 13.0;

            // Box1 的体积
            volume = Box1.height * Box1.length * Box1.breadth;
            Console.WriteLine("Box1 的体积： {0}",  volume);

            // Box2 的体积
            volume = Box2.height * Box2.length * Box2.breadth;
            Console.WriteLine("Box2 的体积： {0}", volume);
            Console.ReadKey();
        }
    }
}

3、类的使用案例（车辆和向量类的定义和使用）

定义一个车辆类，具有Run和Stop等方法，具有Speed速度MaxSpeed、Weight等域。
定义一个车辆类

```

4、析构函数

类的 析构函数 是类的一个特殊的成员函数，当类的对象超出范围时执行。
析构函数的名称是在类的名称前加上一个波浪形（~）作为前缀，它不返回值，也不带任何参数。
析构函数用于在结束程序（比如关闭文件、释放内存等）之前释放资源。析构函数不能继承或重载。
实例：

```csharp using System; namespace LineApplication { class Line { private double length; // 线条的长度 public Line() // 构造函数 { Console.WriteLine("对象已创建"); } ~Line() //析构函数 { Console.WriteLine("对象已删除"); }

     public void setLength( double len )
     {
        length = len;
     }
     public double getLength()
     {
        return length;
     }

     static void Main(string[] args)
     {
        Line line = new Line();
        // 设置线条长度
        line.setLength(6.0);
        Console.WriteLine("线条的长度： {0}", line.getLength());           
     }
  }

} ```

四、访问权限控制

1、public

定义：public 是一种访问修饰符，表示被修饰的成员（如方法、变量、类等）可以被任何其他类访问。
使用场景：
当你需要让类的成员可以被其他类调用或访问时，使用 public。
例如，类的公共方法通常用于提供接口，供其他类调用。

2、private

定义：private 是一种访问修饰符，表示被修饰的成员只能在定义它的类内部被访问，其他类无法直接访问。
使用场景：
当你需要隐藏类的内部实现细节，只通过公共方法暴露功能时，使用 private。
这有助于封装类的内部状态，防止外部直接修改内部数据。

五、构造函数

1、什么是构造函数？

2、构造函数的参数问题

3、子类的构造函数

1、子类构造函数

//子类，派生类
class Boss:Aoss
{
    public Boss():base()
    {
        Console.WriteLine("构造函数：Boss");
    }
}

2、调用父类的构造函数

//父类，基类
class Aoss
{
    public Aoss()
    {
        Console.WriteLine("构造函数：Boss");
    }
}
//子类，派生类
class Boss:Aoss
{
    public Boss():base()
    {
        Console.WriteLine("构造函数：Boss");
    }
}

六、属性

1、属性的书写

//非属性写法
private int age；
//设置属性
public void SetAge（int age）
{
    this.age = age;
}
//获取属性
public int GetAge（int age）
{
    return age；
}

...Main()
{
    Cus lisi = new Cus();
    lisi.SetAge();
    Console.WriteLine(lisi.GetAge());
}

//属性的写法
public int Age
{
    get
    {
        return age；
    }
    set//Value,通过Value获取外部的值。
    {
        age = value;
    }
}
...Main()
{
    Cus lisi = new Cus();
    lisi.Age = 10;
}

2、自动属性、只读只写属性和匿名类型

属性

//只读或者只写
//只读
public int Age
{
    get
    {
        return age；
    }
}
//只写
public int Age
{
    set//Value,通过Value获取外部的值。
    {
        age = value;
    }
}

//自动创建private int age成员
public int Age {get； set；}

//自动创建模式只读只写
//只写
public int Age {get；Private set；}
//只读
public int Age {get；Private set；}

3、匿名类型

int age = 12;
var age = 12;
var age ="dslajflajl";

七、堆栈和静态存储区

1. 栈（Stack）

栈是一种后进先出（LIFO，Last In First Out）的数据结构，用于存储程序运行时的局部变量、函数调用的上下文信息（如返回地址、参数等）。

特点

自动分配和释放：
当函数被调用时，系统会为其分配一块内存空间（称为栈帧，Stack Frame），用于存储局部变量和函数调用的上下文信息。
当函数执行完毕后，栈帧会自动被释放，占用的内存空间也会被回收。
因此，栈中的数据生命周期仅限于函数的执行过程。
局部变量存储：
栈主要用于存储局部变量（在函数内部定义的变量）。
局部变量在函数调用时分配内存，在函数返回时释放内存。
效率高：
栈的分配和释放操作非常快，因为它们是连续的内存空间，且操作简单。
大小有限：
栈的大小通常由系统预先分配，且有限制（例如，几 MB）。如果栈空间不足，会导致栈溢出（Stack Overflow）错误。
线程独立：
每个线程都有自己的栈空间，线程之间的栈是隔离的。

void myFunction() {
    int localVar = 10; // 局部变量存储在栈中
}

2. 堆（Heap）

堆是一种动态分配的内存区域，用于存储动态分配的对象和数据。它由程序员手动管理，通常通过编程语言提供的内存分配和释放函数（如 C/C++ 中的 malloc/free 或 Java 中的 new）来操作。

特点

手动分配和释放：
程序员需要显式地分配和释放堆内存。
如果忘记释放，会导致内存泄漏（Memory Leak）；如果释放后继续访问，会导致未定义行为。
动态分配：
堆内存的大小可以在运行时动态调整，适合存储大小不确定或需要长期存在的数据。
生命周期灵活：
堆中的数据生命周期由程序员控制，可以跨越多个函数调用。
大小较大：
堆的大小通常比栈大得多，适合存储大量数据。
碎片化问题：
频繁的分配和释放可能导致内存碎片化，降低效率。

#include <stdlib.h>

void myFunction() {
    int* dynamicVar = (int*)malloc(sizeof(int)); // 在堆上分配内存
    *dynamicVar = 20;
    free(dynamicVar); // 手动释放内存
}

3. 静态存储区（Static Storage Area）

静态存储区用于存储静态变量（Static Variables）和全局变量（Global Variables）。这些变量的生命周期贯穿整个程序的运行过程。

特点

生命周期长：
静态变量和全局变量在程序启动时分配内存，在程序结束时释放内存。
它们的生命周期与程序的运行时间相同，而不是函数的调用过程。
全局或类级别访问：
全局变量可以在程序的任何地方访问（只要作用域允许）。
静态变量可以在类的范围内访问，但不会随着对象的创建和销毁而改变。
自动初始化：
静态变量和全局变量在程序启动时自动初始化为零（如果未显式初始化）。
存储位置固定：
静态存储区的大小在程序编译时确定，运行时不会改变。

int globalVar = 10; // 全局变量，存储在静态存储区

void myFunction() {
    static int staticVar = 20; // 静态变量，存储在静态存储区
    staticVar++;
    printf("StaticVar: %d\n", staticVar);
}

八、值类型和引用类型

值类型和引用类型

类型被分为两种：值类型(整数，bool struct char ⼩数)和引⽤类型（string 数组⾃定义的类，内置的类）。
值类型只需要⼀段单独的内存，⽤于存储实际的数据，（单独定义的时候放在栈中）
引⽤类型需要两段内存
第⼀段存储实际的数据，它总是位于堆中
第⼆段是⼀个引⽤，指向数据在堆中的存放位置

九、封装、继承和多态

1、封装

封装被定义为"把一个或多个项目封闭在一个物理的或者逻辑的包中"。在面向对象程序设计方法论中，封装是为了防止对实现细节的访问。
C# 封装根据具体的需要，设置使用者的访问权限，并通过访问修饰符 来实现。
一个 访问修饰符 定义了一个类成员的范围和可见性。C# 支持的访问修饰符如下所示：
public：所有对象都可以访问；
private：对象本身在对象内部可以访问；
protected：只有该类对象及其子类对象可以访问
internal：同一个程序集的对象可以访问；
protected internal：访问限于当前程序集或派生自包含类的类型。

封装层级

2、继承

继承是什么？

很多类中有相似的数据，⽐如在⼀个游戏中，有Boss类，⼩怪类Enemy，这些类他们有很多相同的属性，有不同的，这个时候我们可以使⽤继承来让这两个类继承⾃同⼀个类。

继承的类型
实现继承

表⽰⼀个类型派⽣于⼀个基类型,它拥有该基类型的所有成员字段和函数。在实现继

承中,派⽣类型采⽤基类型的每个函数的实现代码,除⾮在派⽣类型的定义中指定重写

某个函数的实现代码。在需要给现有的类型添加功能,或许多相关的类型共享⼀组重

要的公共功能时,这种类型的继承⾮常有⽤。
接口继承

表⽰⼀个类型只继承了函数的签名,没有继承任何实现代码。在需要指定该类型具有某些可⽤的特性时,最好使⽤这种类型的继承。
多重继承

⼀些语⾔(C++)⽀持所谓的 “多重继承”,即⼀个类派⽣⾃多个类。使⽤多重继承的优点是有争议的:⼀⽅⾯,毫⽆疑问,可以使⽤多重继承编写⾮常复杂、但很紧凑的代码,。另⼀⽅⾯,使⽤多重实现继承的代码常常很难理解和调试。如前所述,简化健壮代码的编写⼯作是开发 C#的重要设计⽬标。因此,C#不⽀持多重实现继承。⽽ C#允许类型派⽣⾃多个接 Unity 1143 C#编程-第⼆季-⾯向对象 16 ⼝— — 多重接⼝继承。这说明,C#类可以派⽣⾃另⼀个类和任意多个接⼝。更准确地说, System.Object 是⼀个公共的基类,所以每个 C#(除了Object类之外)都有⼀个基类,还可以有任意多个基接⼝。

3、多态

多态是同一个行为具有多个不同表现形式或形态的能力。
多态性意味着有多重形式。在面向对象编程范式中，多态性往往表现为"一个接口，多个功能"。
多态性可以是静态的或动态的。在静态多态性中，函数的响应是在编译时发生的。在动态多态性中，函数的响应是在运行时发生的。
在 C# 中，每个类型都是多态的，因为包括用户定义类型在内的所有类型都继承自 Object。
多态就是同一个接口，使用不同的实例而执行不同操作，如图所示：

多态参考图

十、继承中子类父类的方法重写（虚方法和隐藏方法）

1、什么是虚方法（virtual）？

在继承中，子类需要对父类的方法进行重写，用到的方法就是虚方法。

2、虚方法实例

//1、把⼀个基类函数声明为virtual,就可以在任何派⽣类中重写该函数:
class MyBaseClass
{
    public virtual string VirtualMethod()
    {
    return "Method is called in base class";
    }
}

//2、在派⽣类中重写另外⼀个函数时，要使⽤override关键字显⽰声明
class MyDerivedClass:MyBaseClass
{
    public override string VirtualMethod()
    {
    return "Method is called in derivedclass.";
    }
}

...main()
{

}

3、隐藏方法

隐藏继承的成员。

4、隐藏方法实例

//隐藏方法的使用
public new void AI()
{
    Console.WriteLine("Boss自己的AI");
}

//方法实例
...Main()
{
    Boss b = new Boss();
    b.AI();
}

十一、抽象类和密封类

1、抽象类

C#允许把类和函数声明为 abstract。抽象类不能实例化,抽象类可以包含普通函数和抽象
函数，抽象函数就是只有函数定义没有函数体。显然,抽象函数本⾝也是虚拟的Virtual(只有函数定义，没有函数体实现)。
类是⼀个模板，那么抽象类就是⼀个不完整的模板，我们不能使⽤不完整的模板去构造对象。
实例：

csharp abstract class Building { public abstract decimal CalculateHeatingCost(); }

2、密封类和密封方法

C#允许把类和⽅法声明为 sealed。
对于类 ,这表⽰不能继承该类；
对于⽅法表⽰不能重写该⽅法。
实例：

csharp sealed FinalClass { // etc }

什么时候使⽤密封类和密封⽅法？
防⽌重写某些类导致代码混乱
商业原因
实例：

```csharp class Child:Base {

} ```

十二、接口

1、只包含方法的定义没有包含方法的实现

2、定义接口

//创建一个接口
public interface IFlyHandler
{
    public void Fly();
}

3、实现接口

//类似于继承
public class Type1Enemy:IFlyHandler
{

}

4、接口的意义抽象

USB接⼝，⽿机接⼝。只提供了接⼝，没有提供实现，让其他开发商实现。
定义⼀个接⼝在语法上跟定义⼀个抽象类完全相同，但不允许提供接⼝中任何成员的实现
⽅式，⼀般情况下，接⼝只能包含⽅法，属性，索引器和事件的声明。
接⼝不能有构造函数，也不能有字段，接⼝也不允许运算符重载。
接⼝定义中不允许声明成员的修饰符，接⼝成员都是公有的

5、接口的继承

1.接⼝可以彼此继承，其⽅式和类的继承⽅式相同

2.实例

public interface A{
void Method1();
}
public interface B:A{
void Method2();
}

十三、索引器

1、使用索引器

static void Main(string[] args)
{
    int[] arr = {32,45,12,34,15};
    //索引器赋值
    arr[2] = 100;
    //索引器取值
    Console.WriteLine(arr[0]);
}

2、创建索引器

//创建基本的索引器（数组实现程序）
class Test
{
    public int this [int index] 
    {
        get
        {
            return 100;
        }
        set
        {
            //value
            Console.WriteLine(value);
        }
    }
}

//标注呢的数组实现程序
class Test
{
    private string[] name =new string[10];
    public int this [int index] 
    {
        get
        {
            return name[index];
        }
        set
        {
            //value
            name[index] = value;
        }
    }
}

十四、运算符重载

十五、列表（List）集合类

1、什么是List?

List<T> 是基于数组实现的集合，允许动态地添加、删除和访问元素。它类似于传统的数组，但比数组更灵活，因为它的大小可以根据需要动态调整。
在C#中，List<T> 是一种非常常用的数据结构，属于泛型集合的一部分，位于 System.Collections.Generic 命名空间中。它是一个动态数组，用于存储一系列具有相同类型的元素。

2、实例：

using System.Collections.Generic;

List<int> myList = new List<int>(); // 创建一个存储整数的 List

3、列表List的创建和使用

创建列表 ( 列表可以存储任何类型的数据，在创建列表对象的时候⾸先要指定你要创建的这个列表要存储什么类型的 ) （泛型）

csharp List<int> scoreList = new List<int>(); new List<int>(){1,2,3} new List<string>(){"one","two"} var scoreList = new List<int>();

往列表中插⼊数据

csharp scoreList.Add(12); scoreList.Add(45);

获取列表中有多少个数据，类似数组的Length

csharp scoreList.Count;

修改List里面的值（和数组没啥区别）

csharp scoreList[3] = 100;

十六、泛型类/泛型方法

1、泛型是什么？

通过参数化类型来实现在同⼀份代码上操作多种数据类型。利⽤ “ 参数化类型 ” 将类型抽象化，从⽽实现灵活的复⽤。

2、泛型类的定义

定义⼀个泛型类就是指的是，定义⼀个类，这个类中某些字段的类型是不确定的，这些类型可以在类构造的时候确定下来 , 举例 :

//创建⼀个类处理int类型和double类型的相加
class ClassA<T>
{ 
    private T a; 
    private T b; 
    public ClassA(T a,T b)
    { 
        this.a = a ;
        this.b = b; 
    } 
    public T GetSum()
    { 
    return a+“”+b; 
    } 
}

3、泛型方法

定义泛型⽅法就是定义⼀个⽅法，这个⽅法的参数的类型可以是不确定的，当调⽤这个⽅法的时候再去确定⽅法的参数的类型。

//实现任意类型组拼成字符串的⽅法
public static T GetSum<T>(T a,T b)
{ 
    return a+""+b; 
} 
GetSum<int>(23,12);  
GetSum<double>(23.2,12);

十七、创建自己的MyList列表

1、List所需要的功能列表

方法/属性	解释
（1）Capacity	获取容量大小
（2）Add（）	添加元素
（3）Insert（）	方法插⼊元素
（4）[index]	访问元素 ( 索引器 )
（5）Count	属性访问元素个数
（6）RemoveAt（）	方法移除指定位置的元素
（7）IndexOf（）	方法取得⼀个元素所在列表中的索引位置，从前往后搜索，搜索到满足条件的就停止，如果没有找到指定元素就返回-1
（8）LastIndexOf（）	方法取得⼀个元素所在列表中的索引位置，是从后往前搜索，搜索到满足条件的就停止，如果没有找到指定元素就返回-1
（9）Sort（）	对列表中是元素进⾏从⼩到⼤排序
（10）索引器	通过 [index] 这种形式去访问数据，就是索引器

一、调试和错误处理

二、什么是面相对象的编程？

1、什么是面向对象的编程？

2、为什么使用面向对象的编程？

三、类

1、定义类

2、创建对象和使用对象

3、类的使用案例（车辆和向量类的定义和使用）

定义一个车辆类，具有Run和Stop等方法，具有Speed速度MaxSpeed、Weight等域。

4、析构函数

四、访问权限控制

1、public

2、private

五、构造函数

1、什么是构造函数？

2、构造函数的参数问题

3、子类的构造函数

1、子类构造函数

2、调用父类的构造函数

六、属性

1、属性的书写

2、自动属性、只读只写属性和匿名类型

3、匿名类型

七、堆栈和静态存储区

1. 栈（Stack）

特点

2. 堆（Heap）

特点

3. 静态存储区（Static Storage Area）

特点

八、值类型和引用类型

九、封装、继承和多态

1、封装

2、继承

3、多态

十、继承中子类父类的方法重写（虚方法和隐藏方法）

1、什么是虚方法（virtual）？

2、虚方法实例

3、隐藏方法

4、隐藏方法实例

十一、抽象类和密封类

1、抽象类

2、密封类和密封方法

十二、接口

1、只包含方法的定义没有包含方法的实现

2、定义接口

3、实现接口

4、接口的意义抽象

5、接口的继承

十三、索引器

十四、运算符重载

十五、列表（List）集合类

1、什么是List?

2、实例：

3、列表List的创建和使用

十六、泛型类/泛型方法

1、泛型是什么？

2、泛型类的定义

3、泛型方法

十七、创建自己的MyList列表

1、List所需要的功能列表