在这一篇中，我们将探讨 C# 中面向对象编程（OOP）的基础概念。面向对象编程是一种编程范式，它使用“对象”来表示和管理数据。对象是程序中的实体，它封装了数据和对数据的操作。我们将讨论一些重要的OOP概念，包括类、对象、封装、继承和多态。

类与对象

在 C# 中，类是对象的蓝图或模板。它定义了对象的属性和方法。对象则是类的实例。你可以将类类比于一种描述，具体的对象则是这种描述的实现。

示例

以下是一个简单的 C# 类和对象的例子：

public class Car
{
    public string Make { get; set; }
    public string Model { get; set; }
    public int Year { get; set; }

    public void DisplayInfo()
    {
        Console.WriteLine($"Car Info: {Year} {Make} {Model}");
    }
}

class Program
{
    static void Main(string[] args)
    {
        Car myCar = new Car();
        myCar.Make = "Toyota";
        myCar.Model = "Camry";
        myCar.Year = 2020;

        myCar.DisplayInfo(); // 输出: Car Info: 2020 Toyota Camry
    }
}
复制

在这个例子中，我们定义了一个 Car 类，它包含 Make、Model 和 Year 等属性，以及一个方法 DisplayInfo，用于显示汽车的信息。然后我们在 Main 方法中实例化了一个 Car 对象。

封装

封装是面向对象编程的一个重要特性。它指的是将数据（属性）和处理数据的代码（方法）放在一起，并对外界隐藏内部实现细节。封装有助于提高代码的安全性和可维护性。

在 C# 中，我们可以通过访问修饰符（如 public、private、protected 等）来控制类的成员能被外部访问的程度：

public class BankAccount
{
    private decimal balance; // 私有字段

    public void Deposit(decimal amount)
    {
        if (amount > 0)
            balance += amount;
    }

    public decimal GetBalance()
    {
        return balance;
    }
}
复制

在上面的例子中，balance 字段是私有的，外部无法直接访问它。用户必须使用 Deposit 和 GetBalance 方法来与 balance 进行交互（即进行存款和查询余额）。

继承

继承允许一个类（子类）从另一个类（父类）获取属性和方法，以实现代码的重用。C# 支持单继承，也就是说一个类只能继承自一个直接父类，但可以实现多个接口。

示例

public class Vehicle
{
    public void Start()
    {
        Console.WriteLine("Vehicle is starting");
    }
}

public class Bicycle : Vehicle // Bicycle 继承自 Vehicle
{
    public void RingBell()
    {
        Console.WriteLine("Ring ring!");
    }
}

class Program
{
    static void Main(string[] args)
    {
        Bicycle myBicycle = new Bicycle();
        myBicycle.Start(); // 输出: Vehicle is starting
        myBicycle.RingBell(); // 输出: Ring ring!
    }
}
复制

在这个例子中，Bicycle 类继承了 Vehicle 类的 Start 方法，因此可以直接调用这个方法。

多态

多态是指同一个方法在不同对象上的不同表现。它通常与方法重写和接口一起使用。C# 中的多态是通过虚方法和重写实现的。

示例

public class Animal
{
    public virtual void Speak()
    {
        Console.WriteLine("Animal speaks");
    }
}

public class Dog : Animal
{
    public override void Speak()
    {
        Console.WriteLine("Woof!");
    }
}

public class Cat : Animal
{
    public override void Speak()
    {
        Console.WriteLine("Meow!");
    }
}

class Program
{
    static void Main(string[] args)
    {
        Animal myAnimal;

        myAnimal = new Dog();
        myAnimal.Speak(); // 输出: Woof!

        myAnimal = new Cat();
        myAnimal.Speak(); // 输出: Meow!
    }
}
复制

在这个例子中，Animal 类有一个虚方法 Speak。我们在 Dog 和 Cat 类中重写了 Speak 方法。当我们使用 Animal 类型的引用来调用 Speak 方法时，根据实际对象的类型，它会调用适当的重写方法。

总结

在这一篇中，我们探讨了 C# 面向对象编程的基础概念，包括 类、对象、封装、继承 和 多态。这些概念是理解 C# 编程的重要基础。在下一篇中，我们将进一步研究面向对象编程中的属性与方法，继续深入这一主题。希望你在学习这段旅程中获得乐趣，并且能够将这些知识应用于实际编程中！