深入理解C#中的面向对象编程思想

创作时间:

作者:

@小白创作中心

深入理解C#中的面向对象编程思想

引用

CSDN

https://blog.csdn.net/m0_38141444/article/details/143741201

面向对象编程（OOP）是C#及许多现代编程语言的核心编程范式之一，它通过模拟现实世界的对象来组织程序逻辑。在C#中，面向对象编程不仅仅是基础语法的学习，更重要的是理解其背后的思想和设计原则。这些思想能够帮助开发者更好地设计系统，提升代码的可维护性、可扩展性和重用性。

一、面向对象的四大基本特性

C#中的面向对象编程思想主要体现在四个基本特性上：

封装（Encapsulation）
继承（Inheritance）
多态（Polymorphism）
抽象（Abstraction）

1.1 封装（Encapsulation）

封装是指将对象的状态（字段）和行为（方法）捆绑在一起，并对外界隐藏实现细节，只暴露必要的接口。

私有化内部实现：通过访问修饰符（private、protected）将类的字段和实现细节隐藏，避免外部直接访问。
暴露公共接口：通过公共的方法（public）或属性（public）与外界交互，保证数据的一致性和安全性。
数据验证与控制：封装不仅能够隐藏数据，还可以在数据访问过程中添加验证逻辑。

代码示例：

public class BankAccount
{
    // 私有字段，外部无法直接访问
    private decimal balance;
    // 公共属性，外部可以通过属性访问和修改余额
    public decimal Balance
    {
        get { return balance; }
        private set
        {
            if (value < 0)
                throw new ArgumentException("Balance cannot be negative.");
            balance = value;
        }
    }
    // 公共方法，提供存款功能
    public void Deposit(decimal amount)
    {
        if (amount <= 0)
            throw new ArgumentException("Deposit amount must be positive.");
        Balance += amount;
    }
    // 公共方法，提供取款功能
    public void Withdraw(decimal amount)
    {
        if (amount <= 0)
            throw new ArgumentException("Withdrawal amount must be positive.");
        if (amount > Balance)
            throw new InvalidOperationException("Insufficient funds.");
        Balance -= amount;
    }
}

1.2 继承（Inheritance）

继承是面向对象的一个重要特性，它允许一个类继承另一个类的属性和方法。通过继承，可以实现代码的复用，并建立类之间的层次结构。

父类（基类）：可以提供共享的属性和方法。
子类（派生类）：继承父类的成员，并可以扩展或重写父类的方法。

代码示例：

// 基类
public class Animal
{
    public string Name { get; set; }
    public virtual void MakeSound()
    {
        Console.WriteLine("Animal sound");
    }
}
// 派生类
public class Dog : Animal
{
    public override void MakeSound()
    {
        Console.WriteLine("Bark");
    }
}
// 派生类
public class Cat : Animal
{
    public override void MakeSound()
    {
        Console.WriteLine("Meow");
    }
}
// 使用继承
var dog = new Dog();
dog.Name = "Buddy";
dog.MakeSound(); // 输出：Bark
var cat = new Cat();
cat.Name = "Whiskers";
cat.MakeSound(); // 输出：Meow

virtual和override：父类中的方法可以声明为virtual，表示允许在子类中重写（Override）。子类使用override关键字来修改父类方法的行为。

1.3 多态（Polymorphism）

多态是指相同的操作作用于不同的对象时，能够产生不同的行为。C#的多态主要体现在方法重载（Overloading）和方法重写（Overriding）上。

编译时多态（方法重载）：在同一个类中，可以定义多个相同名称但参数不同的方法。
运行时多态（方法重写）：通过继承关系，调用父类方法时，实际执行的是子类的重写方法。

代码示例：

public class Shape
{
    public virtual void Draw()
    {
        Console.WriteLine("Drawing a shape");
    }
}
public class Circle : Shape
{
    public override void Draw()
    {
        Console.WriteLine("Drawing a circle");
    }
}
public class Rectangle : Shape
{
    public override void Draw()
    {
        Console.WriteLine("Drawing a rectangle");
    }
}
// 多态
Shape shape1 = new Circle();
shape1.Draw(); // 输出：Drawing a circle
Shape shape2 = new Rectangle();
shape2.Draw(); // 输出：Drawing a rectangle

运行时多态：尽管shape1是Shape类型，但由于Circle类重写了Draw方法，最终调用的是Circle类的方法。这种行为称为运行时多态。

1.4 抽象（Abstraction）

抽象是将对象的复杂性隐藏起来，只暴露必要的功能和特性。抽象可以通过抽象类和接口来实现。

抽象类：抽象类不能直接实例化，只能作为基类提供给其他类继承。抽象类可以包含抽象方法（没有实现的方法），这些方法必须在派生类中实现。
接口：接口定义了一组方法签名，类实现接口时必须提供这些方法的具体实现。

代码示例：

// 抽象类
public abstract class Animal
{
    public abstract void MakeSound();
    public void Sleep()
    {
        Console.WriteLine("Sleeping...");
    }
}
// 实现抽象类的子类
public class Dog : Animal
{
    public override void MakeSound()
    {
        Console.WriteLine("Bark");
    }
}
// 接口
public interface IDriveable
{
    void Drive();
}
// 实现接口
public class Car : IDriveable
{
    public void Drive()
    {
        Console.WriteLine("Driving a car");
    }
}