- C# 继承
在C#中，继承是面向对象编程的一个核心概念，它允许一个类（派生类或子类）继承另一个类（基类或父类）的属性和方法。通过继承，子类可以重用基类的代码，同时还可以添加新的成员或重写基类的成员。
以下是一个简单的C#继承示例：
csharp 代码
|---|------------------------------------------|
| | // 基类（父类） |
| | public class Animal |
| | { |
| | public void Eat() |
| | { |
| | Console.WriteLine("The animal eats."); |
| | } |
| | |
| | public void Sleep() |
| | { |
| | Console.WriteLine("The animal sleeps."); |
| | } |
| | } |
| | |
| | // 派生类（子类） |
| | public class Dog : Animal |
| | { |
| | // Dog类继承了Animal类的所有公共和保护成员 |
| | // 因此，Dog类可以直接使用Eat和Sleep方法 |
| | |
| | // Dog类可以添加新的成员 |
| | public void Bark() |
| | { |
| | Console.WriteLine("The dog barks."); |
| | } |
| | } |
| | |
| | class Program |
| | { |
| | static void Main(string[] args) |
| | { |
| | // 创建Dog类的实例 |
| | Dog myDog = new Dog(); |
| | |
| | // 调用继承自Animal类的方法 |
| | myDog.Eat(); // 输出: The animal eats. |
| | myDog.Sleep(); // 输出: The animal sleeps. |
| | |
| | // 调用Dog类特有的方法 |
| | myDog.Bark(); // 输出: The dog barks. |
| | } |
| | } |
在这个例子中，Dog 类继承自 Animal 类。这意味着 Dog 类拥有 Animal 类中定义的所有公共和保护成员（在这个例子中是 Eat 和 Sleep 方法）。此外，Dog 类还可以定义它自己的新成员（在这个例子中是 Bark 方法）。
C#还支持以下类型的继承：
- 公有继承（ Public Inheritance ）：这是最常见的继承类型，在公有继承中，基类的公有和保护成员在派生类中保持原有的访问级别。
- 保护继承（ Protected Inheritance ）：在保护继承中，基类的公有和保护成员在派生类中成为保护成员。
- 私有继承（ Private Inheritance ）：在私有继承中，基类的公有和保护成员在派生类中成为私有成员。这种继承类型在C#中并不直接支持，但可以通过其他方式模拟。
在C#中，默认的继承方式是公有继承。另外，请注意，C#不支持多重继承，即一个类不能直接继承多个基类。但是，C#支持接口的多重实现，这可以作为一种实现类似多重继承效果的方式。
继承有助于组织代码，促进代码重用，并允许你创建更特定和复杂的对象层次结构。然而，过度使用继承可能导致代码变得难以理解和维护，因此在使用继承时需要谨慎考虑。
2.C# 封装
在面向对象编程中，封装（Encapsulation）是一种将对象的属性和行为（即数据和方法）结合在一个单独的实体（即对象）中的过程。封装的主要目的是隐藏对象的内部状态，只通过对象提供的方法来访问和修改这些状态。这样可以确保对象的完整性和安全性，同时使得代码更加模块化和可维护。
在C#中，封装通常是通过定义类来实现的。类定义了一个数据类型，包含数据成员（字段或属性）和方法成员（方法或事件）。类的用户（客户端代码）可以通过对象实例来访问类的公共接口，但不能直接访问对象的内部数据或实现细节。
以下是一个简单的C#封装示例：
csharp 代码
|---|--------------------------------------------------------------------------------------------|
| | // 定义一个简单的类，实现封装 |
| | public class BankAccount |
| | { |
| | // 私有字段，表示账户余额 |
| | private decimal balance; |
| | |
| | // 公共属性，提供对余额的访问和修改 |
| | public decimal Balance |
| | { |
| | get { return balance; } |
| | set |
| | { |
| | // 可以在这里添加逻辑来验证值的有效性 |
| | if (value >= 0) |
| | { |
| | balance = value; |
| | } |
| | else |
| | { |
| | throw new ArgumentException("Balance cannot be negative."); |
| | } |
| | } |
| | } |
| | |
| | // 公共方法，表示存款 |
| | public void Deposit(decimal amount) |
| | { |
| | if (amount > 0) |
| | { |
| | balance += amount; |
| | } |
| | else |
| | { |
| | throw new ArgumentException("Deposit amount must be positive."); |
| | } |
| | } |
| | |
| | // 公共方法，表示取款 |
| | public void Withdraw(decimal amount) |
| | { |
| | if (amount > 0 && balance >= amount) |
| | { |
| | balance -= amount; |
| | } |
| | else |
| | { |
| | throw new InvalidOperationException("Insufficient balance or invalid withdrawal amount."); |
| | } |
| | } |
| | } |
| | |
| | class Program |
| | { |
| | static void Main(string[] args) |
| | { |
| | // 创建BankAccount类的实例 |
| | BankAccount account = new BankAccount(); |
| | |
| | // 使用公共接口进行交互 |
| | account.Balance = 1000; // 设置初始余额 |
| | account.Deposit(500); // 存款 |
| | account.Withdraw(200); // 取款 |
| | |
| | // 无法直接访问私有字段balance |
| | // decimal balanceValue = account.balance; // 这将导致编译错误 |
| | |
| | // 但可以通过公共属性访问余额 |
| | Console.WriteLine("Current balance: " + account.Balance); |
| | } |
| | } |
在这个例子中，BankAccount 类封装了账户余额（balance）这个私有字段，并提供了一个公共属性（Balance）来安全地访问和修改它。此外，还提供了Deposit和Withdraw方法来修改余额。客户端代码（Main方法）通过创建BankAccount类的实例并使用其公共接口来与账户进行交互，而不需要了解账户余额是如何内部存储或管理的。
封装有助于保护对象的内部状态免受外部代码的意外修改，并使得类的实现细节更加安全和可维护。通过将数据和操作封装在一起，可以创建出更加健壮和易于使用的对象。
3.C# 多态
在面向对象编程中，多态（Polymorphism）是一种允许你使用父类类型的引用或接口来引用子类对象的能力。当引用被调用时，将执行与引用所绑定对象的实际类型相对应的方法。这意味着，即使引用是父类类型，也可以调用子类特有的方法。多态允许我们编写更加通用和可重用的代码，因为我们可以编写操作父类类型引用的代码，而无需关心实际对象的具体类型。
在C#中，多态通常通过以下方式实现：
- 方法重写（Method Overriding）：子类可以重写父类中的虚方法（virtual）、抽象方法（abstract）或覆盖方法（override）。当子类对象被当作父类类型引用时，调用该方法将会执行子类中的重写版本。
- 方法隐藏（Method Hiding）：子类可以隐藏父类中具有相同名称的方法。这不同于重写，因为隐藏方法不会覆盖父类方法，而是创建了一个新的方法。
- 方法重载（Method Overloading）：在同一个类中，可以定义多个具有相同名称但参数列表不同的方法。编译器根据调用时提供的参数来确定要调用哪个方法。
- 接口实现（Interface Implementation）：类可以实现一个或多个接口，并提供接口中定义的方法的具体实现。这使得可以通过接口引用来调用实现类中的方法。
下面是一个简单的C#多态示例：
csharp 代码
|---|---------------------------------------------|
| | // 定义一个动物基类 |
| | public class Animal |
| | { |
| | public virtual void Speak() |
| | { |
| | Console.WriteLine("The animal speaks."); |
| | } |
| | } |
| | |
| | // 定义一个狗类，继承自动物基类并重写Speak方法 |
| | public class Dog : Animal |
| | { |
| | public override void Speak() |
| | { |
| | Console.WriteLine("The dog barks."); |
| | } |
| | } |
| | |
| | // 定义一个猫类，继承自动物基类并重写Speak方法 |
| | public class Cat : Animal |
| | { |
| | public override void Speak() |
| | { |
| | Console.WriteLine("The cat meows."); |
| | } |
| | } |
| | |
| | class Program |
| | { |
| | static void Main(string[] args) |
| | { |
| | // 创建一个Animal类型的数组，用于存储不同类型的动物对象 |
| | Animal[] animals = new Animal[2]; |
| | |
| | // 创建Dog和Cat对象，并赋值给数组 |
| | animals[0] = new Dog(); |
| | animals[1] = new Cat(); |
| | |
| | // 遍历数组，调用每个动物的Speak方法 |
| | foreach (var animal in animals) |
| | { |
| | animal.Speak(); // 这里将调用相应对象类型的Speak方法，实现多态 |
| | } |
| | } |
| | } |
在这个例子中，Animal 类定义了一个虚方法 Speak，而 Dog 和 Cat 类重写了这个方法。在 Main 方法中，我们创建了一个 Animal 类型的数组，并存储了 Dog 和 Cat 的对象。当我们遍历这个数组并调用每个对象的 Speak 方法时，会根据实际对象的类型（Dog 或 Cat）来执行相应的方法，这就是多态的体现。