C# 程序设计基础 —— 面向对象编程（Object-Oriented Programming，简称 OOP）详解

在当今的软件开发领域，面向对象编程（Object-Oriented Programming，简称 OOP）已经成为一种主流且强大的编程范式。C# 作为一门现代的、面向对象的编程语言，将面向对象的理念融入到了语言的核心设计之中，为我们构建复杂而高效的软件系统提供了强大的支持。

如果你是一名初学者，正在踏上 C# 程序设计的学习之旅，那么深入理解面向对象是至关重要的一步。它不仅能够帮助你更好地组织代码，提高代码的可维护性和可扩展性，还能让你以一种更加贴近现实世界的方式来思考和解决问题。通过面向对象，你可以将复杂的系统分解为一个个相互协作的对象，每个对象都封装了特定的数据和行为，从而使得整个系统更加清晰、易于理解和管理。

1. 面向对象概述

1.1 面向对象的基本概念

面向对象（Object-Oriented Programming，OOP）是一种程序设计范式，它将数据和操作数据的方法封装在一起，形成一个对象。对象是面向对象编程的核心概念，它具有状态（属性）和行为（方法）。在C#中，对象是通过类（Class）来定义的。类是对象的模板，它定义了对象的结构和行为。例如，一个Person类可以定义人的属性（如Name、Age）和行为（如Speak、Walk）。

public class Person
{
// 属性
public string Name { get; set; }
public int Age { get; set; }

// 方法
public void Speak(string message)
{
Console.WriteLine($"{Name} says: {message}");
}

public void Walk()
{
Console.WriteLine($"{Name} is walking");
}
}

在面向对象编程中，还有三个基本特性：封装（Encapsulation）、继承（Inheritance）和多态（Polymorphism）。

• 封装：封装是将数据和操作数据的方法封装在一起，隐藏内部实现细节，只暴露必要的接口。例如，Person类的Name和Age属性可以通过get和set访问器来访问和修改，但内部的具体实现细节对用户是隐藏的。

• 继承：继承允许一个类（子类）继承另一个类（父类）的属性和方法。子类可以扩展或修改父类的行为。例如，Student类可以继承Person类，同时添加自己的属性和方法，如Grade和Study。

public class Student : Person
{
public int Grade { get; set; }

public void Study()
{
Console.WriteLine($"{Name} is studying in grade {Grade}");
}
}

• 多态：多态允许一个接口或基类引用不同的实现或派生类对象。多态主要有两种形式：方法重载（Overloading）和方法覆盖（Overriding）。方法重载是指在同一个类中定义多个同名方法，但参数类型或数量不同。方法覆盖是指子类重写父类的方法。

public class Animal
{
public virtual void MakeSound()
{
Console.WriteLine("Animal makes a sound");
}
}

public class Dog : Animal
{
public override void MakeSound()
{
Console.WriteLine("Dog barks");
}
}

1.2 面向对象的优势

面向对象编程具有以下优势：

• 可维护性：面向对象的设计使得代码更加模块化，每个类都可以独立开发和维护。例如，Person类和Student类可以分别由不同的开发人员开发，互不干扰。

• 可扩展性：通过继承和多态，可以轻松地扩展系统的功能。例如，添加一个新的Teacher类，只需要继承Person类并添加特定的属性和方法即可。

• 可重用性：面向对象的设计使得代码可以被重用。例如，Person类可以在多个项目中被重用，而不需要重新编写代码。

• 可理解性：面向对象的设计更加接近人类的思维方式，使得代码更容易理解和阅读。例如，Person类和Student类的结构和行为更加直观，符合人类的认知习惯。

2. 类与对象

2.1 类的定义与结构

在C#中，类是面向对象编程的核心组成部分，它是对象的模板，定义了对象的结构和行为。类的定义通常包括成员变量（属性）和成员方法（行为）。

类的定义语法

[访问修饰符] class 类名
{
// 成员变量
[访问修饰符] 数据类型 变量名;

// 成员方法
[访问修饰符] 返回类型 方法名(参数列表)
{
// 方法体
}
}

成员变量

成员变量是类的属性，用于存储对象的状态。它们可以是各种数据类型，包括基本数据类型（如int、string）和复杂数据类型（如其他类的实例）。

成员方法

成员方法是类的行为，用于定义对象可以执行的操作。方法可以有参数，也可以有返回值。

示例

以下是一个简单的Car类的定义：

public class Car
{
// 成员变量
public string Brand { get; set; }
public int Year { get; set; }

// 成员方法
public void Start()
{
Console.WriteLine($"{Brand} car from {Year} is starting");
}

public void Stop()
{
Console.WriteLine($"{Brand} car from {Year} is stopping");
}
}

访问修饰符

C#提供了多种访问修饰符，用于控制类成员的访问权限：

• public：公开访问，任何地方都可以访问。

• private：私有访问，仅在类内部可以访问。

• protected：受保护访问，类内部和派生类可以访问。

• internal：内部访问，仅在当前程序集内可以访问。

• protected internal：受保护的内部访问，当前程序集内或派生类可以访问。

构造函数

构造函数是类的特殊方法，用于在创建对象时初始化对象的状态。构造函数的名称与类名相同，没有返回值。

public class Car
{
public string Brand { get; set; }
public int Year { get; set; }

// 构造函数
public Car(string brand, int year)
{
Brand = brand;
Year = year;
}

public void Start()
{
Console.WriteLine($"{Brand} car from {Year} is starting");
}
}

静态成员

静态成员属于类本身，而不是类的某个特定实例。静态成员可以通过类名直接访问，而不需要创建对象。

public class Car
{
public static int CarCount = 0;

public string Brand { get; set; }
public int Year { get; set; }

public Car(string brand, int year)
{
Brand = brand;
Year = year;
CarCount++;
}

public static void PrintCarCount()
{
Console.WriteLine($"Total cars: {CarCount}");
}
}

2.2 对象的创建与使用

对象是类的实例，通过类的定义创建对象，并使用对象的属性和方法。

创建对象

使用new关键字创建对象，并调用类的构造函数进行初始化。

Car myCar = new Car("Toyota", 2022);

使用对象

通过对象的名称访问其属性和方法。

myCar.Start(); // 输出：Toyota car from 2022 is starting
Console.WriteLine(myCar.Brand); // 输出：Toyota

示例：完整代码

using System;

public class Car
{
public static int CarCount = 0;

public string Brand { get; set; }
public int Year { get; set; }

public Car(string brand, int year)
{
Brand = brand;
Year = year;
CarCount++;
}

public void Start()
{
Console.WriteLine($"{Brand} car from {Year} is starting");
}

public void Stop()
{
Console.WriteLine($"{Brand} car from {Year} is stopping");
}

public static void PrintCarCount()
{
Console.WriteLine($"Total cars: {CarCount}");
}
}

public class Program
{
public static void Main()
{
Car myCar = new Car("Toyota", 2022);
myCar.Start(); // 输出：Toyota car from 2022 is starting
myCar.Stop(); // 输出：Toyota car from 2022 is stopping

Car.PrintCarCount(); // 输出：Total cars: 1
}
}

对象的生命周期

对象的生命周期从创建开始，到被垃圾回收器回收结束。在C#中，垃圾回收器会自动管理对象的内存，但也可以通过Dispose方法手动释放资源。

对象的比较

在C#中，对象的比较可以通过引用比较和值比较来实现：

• 引用比较：使用==或!=比较两个对象的引用是否相同。

• 值比较：通过重写Equals方法或实现IEquatable<T>接口来比较对象的值是否相同。

示例：重写Equals方法

public class Car : IEquatable<Car>
{
public string Brand { get; set; }
public int Year { get; set; }

public Car(string brand, int year)
{
Brand = brand;
Year = year;
}

public override bool Equals(object obj)
{
return Equals(obj as Car);
}

public bool Equals(Car other)
{
return other != null && Brand == other.Brand && Year == other.Year;
}

public override int GetHashCode()
{
return HashCode.Combine(Brand, Year);
}
}

public class Program
{
public static void Main()
{
Car car1 = new Car("Toyota", 2022);
Car car2 = new Car("Toyota", 2022);

Console.WriteLine(car1 == car2); // 输出：False
Console.WriteLine(car1.Equals(car2)); // 输出：True
}
}

通过以上内容，我们详细介绍了类的定义与结构，以及对象的创建与使用。这些是面向对象编程的基础，掌握它们将有助于更好地理解和应用C#面向对象的特性。

3. 封装机制

3.1 私有成员与公有接口

封装是面向对象编程的核心特性之一，它允许将数据和操作数据的方法封装在一起，隐藏内部实现细节，只暴露必要的接口。在C#中，封装主要通过访问修饰符来实现。

私有成员

私有成员是类的内部实现细节，只能在类的内部访问。它们通常用于存储对象的状态，如成员变量。通过将成员变量设置为private，可以防止外部代码直接访问和修改这些变量，从而保护对象的内部状态。

public class Person
{
private string name;
private int age;

public void SetName(string name)
{
this.name = name;
}

public string GetName()
{
return name;
}

public void SetAge(int age)
{
this.age = age;
}

public int GetAge()
{
return age;
}
}

公有接口

公有接口是类对外暴露的接口，允许外部代码通过这些接口与对象进行交互。公有接口通常由公有方法组成，这些方法可以访问和修改私有成员变量。

public class Person
{
private string name;
private int age;

public void SetName(string name)
{
this.name = name;
}

public string GetName()
{
return name;
}

public void SetAge(int age)
{
this.age = age;
}

public int GetAge()
{
return age;
}
}

通过这种方式，Person类的内部实现细节被隐藏起来，外部代码只能通过SetName、GetName、SetAge和GetAge方法来访问和修改对象的状态。

优势

封装的主要优势包括：

• 数据隐藏：保护对象的内部状态，防止外部代码直接访问和修改私有成员变量。

• 代码安全性：通过控制对成员变量的访问，可以确保对象的状态始终保持一致。

• 代码维护性：封装使得代码更加模块化，每个类都可以独立开发和维护，互不干扰。

3.2 属性的使用

在C#中，属性（Properties）是封装的另一种实现方式。属性提供了一种更简洁的方式来访问和修改私有成员变量，同时保持封装的特性。

属性的定义

属性由get和set访问器组成，分别用于获取和设置私有成员变量的值。get访问器返回属性的值，set访问器设置属性的值。

public class Person
{
private string name;
private int age;

public string Name
{
get { return name; }
set { name = value; }
}

public int Age
{
get { return age; }
set { age = value; }
}
}

自动实现的属性

C#还支持自动实现的属性，这种属性不需要显式定义私有成员变量，编译器会自动为它们生成私有成员变量。

public class Person
{
public string Name { get; set; }
public int Age { get; set; }
}

只读和只写属性

属性可以是只读的或只写的。只读属性只有get访问器，没有set访问器；只写属性只有set访问器，没有get访问器。

public class Person
{
private string name;
private int age;

public string Name
{
get { return name; }
}

public int Age
{
set { age = value; }
}
}

属性的优势

使用属性的优势包括：

• 简洁性：属性提供了一种更简洁的方式来访问和修改私有成员变量。

• 封装性：属性仍然保持封装的特性，可以在get和set访问器中添加逻辑，如验证输入值。

• 灵活性：属性可以在不改变外部代码的情况下，随时修改内部实现。

通过以上内容，我们详细介绍了封装机制，包括私有成员与公有接口的使用，以及属性的定义和优势。封装是面向对象编程的重要特性，掌握它将有助于更好地设计和实现C#程序。

4. 继承机制

4.1 基类与派生类

继承是面向对象编程的核心特性之一，它允许一个类（派生类）继承另一个类（基类）的属性和方法。通过继承，派生类可以复用基类的代码，同时也可以添加自己的属性和方法，或者修改基类的行为。

基类与派生类的定义

在C#中，使用:符号来表示继承关系。派生类可以继承基类的公有成员和受保护成员，但不能直接访问基类的私有成员。

public class Animal
{
public string Name { get; set; }

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

public virtual void MakeSound()
{
Console.WriteLine($"{Name} makes a sound");
}
}

public class Dog : Animal
{
public Dog(string name) : base(name)
{
}

public void Bark()
{
Console.WriteLine($"{Name} barks");
}
}

构造函数的继承

派生类的构造函数可以通过base关键字调用基类的构造函数来初始化基类成员。如果基类没有无参构造函数，派生类必须显式调用基类的构造函数。

public class Animal
{
public string Name { get; set; }

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

public class Dog : Animal
{
public Dog(string name) : base(name)
{
}
}

访问修饰符与继承

• public：公开访问，派生类可以访问基类的公有成员。

• protected：受保护访问，派生类可以访问基类的受保护成员。

• private：私有访问，派生类不能访问基类的私有成员。

• internal：内部访问，派生类在同一程序集内可以访问基类的内部成员。

• protected internal：受保护的内部访问，派生类在同一程序集内或派生类中可以访问基类的受保护内部成员。

示例：基类与派生类的使用

public class Animal
{
public string Name { get; set; }

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

public virtual void MakeSound()
{
Console.WriteLine($"{Name} makes a sound");
}
}

public class Dog : Animal
{
public Dog(string name) : base(name)
{
}

public override void MakeSound()
{
Console.WriteLine($"{Name} barks");
}

public void Bark()
{
Console.WriteLine($"{Name} barks");
}
}

public class Program
{
public static void Main()
{
Animal myAnimal = new Animal("Generic Animal");
myAnimal.MakeSound(); // 输出：Generic Animal makes a sound

Dog myDog = new Dog("Buddy");
myDog.MakeSound(); // 输出：Buddy barks
myDog.Bark(); // 输出：Buddy barks
}
}

继承的优势

• 代码复用：派生类可以复用基类的代码，减少重复代码。

• 可扩展性：通过继承，可以轻松地扩展系统的功能。

• 层次结构：继承可以形成类的层次结构，使得代码更加模块化和易于管理。

4.2 方法重写与多态

多态是面向对象编程的另一个核心特性，它允许一个接口或基类引用不同的实现或派生类对象。多态主要有两种形式：方法重载（Overloading）和方法覆盖（Overriding）。

方法重写（Overriding）

方法重写是指派生类重写基类的虚方法（virtual方法）。通过方法重写，派生类可以提供自己的实现，而不会影响基类的其他行为。

public class Animal
{
public string Name { get; set; }

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

public virtual void MakeSound()
{
Console.WriteLine($"{Name} makes a sound");
}
}

public class Dog : Animal
{
public Dog(string name) : base(name)
{
}

public override void MakeSound()
{
Console.WriteLine($"{Name} barks");
}
}

虚方法与密封方法

• 虚方法（virtual）：虚方法可以在派生类中被重写。

• 密封方法（sealed）：密封方法不能被派生类重写。

public class Animal
{
public string Name { get; set; }

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

public virtual void MakeSound()
{
Console.WriteLine($"{Name} makes a sound");
}
}

public class Dog : Animal
{
public Dog(string name) : base(name)
{
}

public override sealed void MakeSound()
{
Console.WriteLine($"{Name} barks");
}
}

示例：方法重写与多态

public class Animal
{
public string Name { get; set; }

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

public virtual void MakeSound()
{
Console.WriteLine($"{Name} makes a sound");
}
}

public class Dog : Animal
{
public Dog(string name) : base(name)
{
}

public override void MakeSound()
{
Console.WriteLine($"{Name} barks");
}
}

public class Cat : Animal
{
public Cat(string name) : base(name)
{
}

public override void MakeSound()
{
Console.WriteLine($"{Name} meows");
}
}

public class Program
{
public static void Main()
{
Animal myAnimal = new Animal("Generic Animal");
myAnimal.MakeSound(); // 输出：Generic Animal makes a sound

Animal myDog = new Dog("Buddy");
myDog.MakeSound(); // 输出：Buddy barks

Animal myCat = new Cat("Whiskers");
myCat.MakeSound(); // 输出：Whiskers meows
}
}

方法重载（Overloading）

方法重载是指在同一个类中定义多个同名方法，但参数类型或数量不同。方法重载允许方法根据参数的不同提供不同的实现。

public class Calculator
{
public int Add(int a, int b)
{
return a + b;
}

public double Add(double a, double b)
{
return a + b;
}
}

示例：方法重载

public class Calculator
{
public int Add(int a, int b)
{
return a + b;
}

public double Add(double a, double b)
{
return a + b;
}
}

public class Program
{
public static void Main()
{
Calculator calc = new Calculator();
Console.WriteLine(calc.Add(5, 3)); // 输出：8
Console.WriteLine(calc.Add(5.5, 3.3)); // 输出：8.8
}
}

通过以上内容，我们详细介绍了继承机制，包括基类与派生类的定义、构造函数的继承、访问修饰符与继承的关系，以及方法重写与多态的实现。掌握这些内容将有助于更好地理解和应用C#面向对象的特性。

5. 多态实现

5.1 方法重载与方法重写

在面向对象编程中，多态是一种重要的特性，它允许一个接口或基类引用不同的实现或派生类对象。多态主要有两种形式：方法重载（Overloading）和方法重写（Overriding）。这两种形式在C#中都有广泛的应用。

方法重载（Overloading）

方法重载是指在同一个类中定义多个同名方法，但参数类型或数量不同。方法重载允许方法根据参数的不同提供不同的实现。这使得代码更加灵活和易于维护。

public class Calculator
{
public int Add(int a, int b)
{
return a + b;
}

public double Add(double a, double b)
{
return a + b;
}
}

在上面的例子中，Calculator类定义了两个Add方法，一个接受两个int类型的参数，另一个接受两个double类型的参数。这种重载使得调用者可以根据需要选择合适的方法。

方法重写（Overriding）

方法重写是指派生类重写基类的虚方法（virtual方法）。通过方法重写，派生类可以提供自己的实现，而不会影响基类的其他行为。这使得代码更加灵活和可扩展。

public class Animal
{
public string Name { get; set; }

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

public virtual void MakeSound()
{
Console.WriteLine($"{Name} makes a sound");
}
}

public class Dog : Animal
{
public Dog(string name) : base(name)
{
}

public override void MakeSound()
{
Console.WriteLine($"{Name} barks");
}
}

在上面的例子中，Dog类重写了Animal类的MakeSound方法。当调用Dog对象的MakeSound方法时，将执行Dog类中的实现，而不是Animal类中的实现。

示例：方法重载与方法重写

public class Calculator
{
public int Add(int a, int b)
{
return a + b;
}

public double Add(double a, double b)
{
return a + b;
}
}

public class Animal
{
public string Name { get; set; }

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

public virtual void MakeSound()
{
Console.WriteLine($"{Name} makes a sound");
}
}

public class Dog : Animal
{
public Dog(string name) : base(name)
{
}

public override void MakeSound()
{
Console.WriteLine($"{Name} barks");
}
}

public class Program
{
public static void Main()
{
Calculator calc = new Calculator();
Console.WriteLine(calc.Add(5, 3)); // 输出：8
Console.WriteLine(calc.Add(5.5, 3.3)); // 输出：8.8

Animal myAnimal = new Animal("Generic Animal");
myAnimal.MakeSound(); // 输出：Generic Animal makes a sound

Animal myDog = new Dog("Buddy");
myDog.MakeSound(); // 输出：Buddy barks
}
}

方法重载与方法重写的区别

• 方法重载：

  • 在同一个类中定义多个同名方法，但参数类型或数量不同。

  • 主要用于提供多种方法实现，以满足不同的调用需求。

• 方法重写：

  • 在派生类中重写基类的虚方法。

  • 主要用于扩展或修改基类的行为，而不影响基类的其他实现。

5.2 接口与抽象类

接口（Interface）和抽象类（Abstract Class）是C#中实现多态的两种重要方式。它们都允许定义一个通用的接口或模板，但具体的实现由派生类提供。

接口

接口是一种完全抽象的类，它只定义方法、属性、事件和索引器的签名，但不提供具体的实现。接口中的所有成员都是隐式抽象的，不能包含任何具体实现。

public interface IAnimal
{
void MakeSound();
}

派生类必须实现接口中定义的所有成员。接口可以被多个类实现，这使得接口非常适合定义通用的行为。

public class Dog : IAnimal
{
public void MakeSound()
{
Console.WriteLine("Dog barks");
}
}

public class Cat : IAnimal
{
public void MakeSound()
{
Console.WriteLine("Cat meows");
}
}

抽象类

抽象类是一种不能被实例化的类，它定义了一些通用的成员，但允许派生类提供具体的实现。抽象类可以包含抽象方法、抽象属性、具体方法和具体属性。

public abstract class Animal
{
public string Name { get; set; }

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

public abstract void MakeSound();
}

派生类必须实现抽象类中定义的所有抽象成员。抽象类可以包含具体实现，这使得抽象类更适合定义通用的模板和默认行为。

public class Dog : Animal
{
public Dog(string name) : base(name)
{
}

public override void MakeSound()
{
Console.WriteLine($"{Name} barks");
}
}

public class Cat : Animal
{
public Cat(string name) : base(name)
{
}

public override void MakeSound()
{
Console.WriteLine($"{Name} meows");
}
}

接口与抽象类的区别

• 接口：

  • 完全抽象，不能包含具体实现。

  • 可以被多个类实现，适合定义通用的行为。

  • 成员默认都是public，不能有访问修饰符。

• 抽象类：

  • 可以包含抽象方法和具体方法。

  • 只能被一个类继承，适合定义通用的模板和默认行为。

  • 成员可以有访问修饰符。

示例：接口与抽象类

public interface IAnimal
{
void MakeSound();
}

public abstract class Animal
{
public string Name { get; set; }

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

public abstract void MakeSound();
}

public class Dog : Animal, IAnimal
{
public Dog(string name) : base(name)
{
}

public override void MakeSound()
{
Console.WriteLine($"{Name} barks");
}
}

public class Cat : Animal, IAnimal
{
public Cat(string name) : base(name)
{
}

public override void MakeSound()
{
Console.WriteLine($"{Name} meows");
}
}

public class Program
{
public static void Main()
{
IAnimal myDog = new Dog("Buddy");
myDog.MakeSound(); // 输出：Buddy barks

IAnimal myCat = new Cat("Whiskers");
myCat.MakeSound(); // 输出：Whiskers meows
}
}

通过以上内容，我们详细介绍了多态的实现方式，包括方法重载与方法重写，以及接口与抽象类的使用。掌握这些内容将有助于更好地理解和应用C#面向对象的特性。

6. 构造函数与析构函数

6.1 构造函数的作用与使用

构造函数是类的特殊方法，其主要作用是在创建对象时初始化对象的状态。在C#中，构造函数的名称必须与类名相同，并且没有返回值。

构造函数的定义

构造函数的定义语法如下：

[访问修饰符] 类名(参数列表)
{
// 初始化代码
}

例如，以下是一个Person类的构造函数：

public class Person
{
public string Name { get; set; }
public int Age { get; set; }

public Person(string name, int age)
{
Name = name;
Age = age;
}
}

在这个例子中，Person类的构造函数接受两个参数name和age，并用它们初始化对象的Name和Age属性。

构造函数的重载

构造函数可以被重载，即一个类可以有多个构造函数，只要它们的参数列表不同即可。例如：

public class Person
{
public string Name { get; set; }
public int Age { get; set; }

public Person()
{
Name = "Unknown";
Age = 0;
}

public Person(string name)
{
Name = name;
Age = 0;
}

public Person(string name, int age)
{
Name = name;
Age = age;
}
}

在这个例子中，Person类定义了三个构造函数，分别用于初始化对象的不同属性。这使得创建对象时更加灵活。

构造函数的继承

派生类可以继承基类的构造函数，但不能直接调用基类的构造函数。派生类的构造函数可以通过base关键字显式调用基类的构造函数。例如：

public class Animal
{
public string Name { get; set; }

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

public class Dog : Animal
{
public Dog(string name) : base(name)
{
}
}

在这个例子中，Dog类的构造函数通过base(name)调用了基类Animal的构造函数，从而初始化了Name属性。

构造函数的使用场景

构造函数通常用于以下场景：

• 初始化对象的属性。

• 设置对象的默认值。

• 执行必要的初始化逻辑，如打开文件、连接数据库等。

6.2 析构函数的作用与使用

析构函数是类的特殊方法，其主要作用是在对象被销毁时执行清理工作。在C#中，析构函数的名称也是类名，但前面加上~符号，并且没有参数和返回值。

析构函数的定义

析构函数的定义语法如下：

~类名()
{
// 清理代码
}

例如，以下是一个FileHandler类的析构函数：

public class FileHandler
{
private string filePath;

public FileHandler(string filePath)
{
this.filePath = filePath;
// 打开文件
}

~FileHandler()
{
// 关闭文件
}
}

在这个例子中，FileHandler类的析构函数在对象被销毁时关闭文件，从而释放资源。

析构函数的执行时机

析构函数的执行时机由垃圾回收器（GC）决定。当垃圾回收器检测到对象不再被引用时，会调用对象的析构函数。因此，析构函数的执行是不确定的，不能保证在对象被销毁时立即执行。

析构函数的使用场景

析构函数通常用于以下场景：

• 释放非托管资源，如文件句柄、数据库连接等。

• 执行必要的清理工作，如关闭文件、释放内存等。

析构函数的注意事项

• 析构函数不能被重载。

• 析构函数不能被继承。

• 析构函数不能被显式调用。

• 析构函数的执行是不确定的，建议使用IDisposable接口来管理资源的释放。

使用IDisposable接口管理资源

为了更好地管理资源的释放，C#提供了IDisposable接口。实现IDisposable接口的类可以通过Dispose方法显式释放资源。例如：

public class FileHandler : IDisposable
{
private string filePath;
private bool disposed = false;

public FileHandler(string filePath)
{
this.filePath = filePath;
// 打开文件
}

public void Dispose()
{
Dispose(true);
GC.SuppressFinalize(this);
}

protected virtual void Dispose(bool disposing)
{
if (!disposed)
{
if (disposing)
{
// 释放托管资源
}
// 释放非托管资源
disposed = true;
}
}

~FileHandler()
{
Dispose(false);
}
}

在这个例子中，FileHandler类实现了IDisposable接口，并通过Dispose方法显式释放资源。同时，析构函数仍然存在，用于在对象被销毁时执行清理工作。

通过以上内容，我们详细介绍了构造函数与析构函数的作用与使用，以及它们在C#面向对象编程中的重要性。掌握这些内容将有助于更好地设计和实现C#程序。

7. 面向对象的应用案例

7.1 实际案例分析

面向对象编程在实际开发中有着广泛的应用，它能够帮助开发者更好地组织代码，提高代码的可维护性和可扩展性。以下是一个实际案例，通过面向对象的设计思路来解决一个具体问题。

案例背景

假设我们需要开发一个简单的学校管理系统，该系统需要管理学生、教师和课程的信息。学生和教师都属于学校人员，课程由教师授课，学生可以选择课程进行学习。

面向对象设计

在面向对象的设计中，我们可以将学生、教师、课程等概念抽象为类，并通过类之间的关系来实现系统的功能。

• Person类：作为基类，表示学校人员，包含通用属性如姓名、年龄等。

• Student类：继承自Person类，表示学生，包含学生特有的属性如学号、选修课程等。

• Teacher类：继承自Person类，表示教师，包含教师特有的属性如教师编号、教授课程等。

• Course类：表示课程，包含课程名称、课程编号、授课教师等属性。

类之间的关系

• 继承关系：Student类和Teacher类继承自Person类，复用了Person类的属性和方法。

• 关联关系：Student类与Course类之间存在关联关系，表示学生可以选择课程；Teacher类与Course类之间也存在关联关系，表示教师可以教授课程。

系统功能实现

通过面向对象的设计，我们可以轻松地实现学校管理系统的基本功能，如添加学生、添加教师、添加课程、学生选课、教师授课等。这种设计方式使得代码更加模块化，每个类都可以独立开发和维护，同时也方便了系统的扩展和修改。

7.2 代码示例

以下是基于上述设计思路的代码示例：

using System;
using System.Collections.Generic;

// Person类：基类
public class Person
{
public string Name { get; set; }
public int Age { get; set; }

public Person(string name, int age)
{
Name = name;
Age = age;
}
}

// Student类：继承自Person类
public class Student : Person
{
public string StudentId { get; set; }
public List<Course> Courses { get; set; } = new List<Course>();

public Student(string name, int age, string studentId) : base(name, age)
{
StudentId = studentId;
}

public void EnrollCourse(Course course)
{
Courses.Add(course);
Console.WriteLine($"{Name} enrolled in {course.CourseName}");
}
}

// Teacher类：继承自Person类
public class Teacher : Person
{
public string TeacherId { get; set; }
public List<Course> Courses { get; set; } = new List<Course>();

public Teacher(string name, int age, string teacherId) : base(name, age)
{
TeacherId = teacherId;
}

public void AssignCourse(Course course)
{
Courses.Add(course);
Console.WriteLine($"{Name} is assigned to teach {course.CourseName}");
}
}

// Course类
public class Course
{
public string CourseName { get; set; }
public string CourseId { get; set; }
public Teacher Teacher { get; set; }

public Course(string courseName, string courseId)
{
CourseName = courseName;
CourseId = courseId;
}
}

// 主程序
public class Program
{
public static void Main()
{
// 创建学生和教师
Student student1 = new Student("Alice", 20, "S001");
Teacher teacher1 = new Teacher("Mr. Smith", 40, "T001");

// 创建课程
Course course1 = new Course("Mathematics", "C001");

// 教师授课
teacher1.AssignCourse(course1);

// 学生选课
student1.EnrollCourse(course1);
}
}

代码说明

• Person类：作为基类，定义了学校人员的基本属性。

• Student类和Teacher类：继承自Person类，分别添加了学生和教师特有的属性和方法。

• Course类：定义了课程的基本属性，包括课程名称、课程编号和授课教师。

• 主程序：创建了学生、教师和课程的实例，并演示了学生选课和教师授课的功能。

通过这个案例，我们可以看到面向对象编程在解决实际问题时的强大能力。它不仅使得代码更加清晰和易于维护，还方便了系统的扩展和功能的增加。