C#系列-面向对象特性继承封装多态（2）

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）来执行相应的方法，这就是多态的体现。