掌握C#核心概念：类、继承、泛型等

C# 是一门功能强大且灵活的面向对象编程语言，它结合了许多现代编程语言的特点和特性。无论你是编程新手，还是有经验的开发者，理解C#中的核心概念都是非常重要的。本文将介绍C#中的类与对象、构造函数和析构函数、方法的重载与重写、继承与多态等基础知识，并为每个主题提供简要的解释和示例代码。

---

1. 类与对象

C# 是一种面向对象编程语言，类与对象是其核心。

• 类 是对象的模板，定义了对象的属性和方法。
• 对象 是类的实例，通过 new 关键字创建。

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

    public void Greet()
    {
        Console.WriteLine($"Hello, my name is {Name} and I am {Age} years old.");
    }
}

// 使用类创建对象
Person person = new Person { Name = "Alice", Age = 25 };
person.Greet();

在上面的示例中，我们定义了一个 Person 类，并创建了一个名为 person 的对象。类提供了对象的属性（Name和 Age）以及方法（Greet）。

---

2. 构造函数和析构函数

构造函数 是用于创建对象时初始化属性的方法。析构函数 则用于在对象销毁时执行清理操作。

public class Car
{
    public string Brand { get; set; }
    public Car(string brand)
    {
        Brand = brand;
        Console.WriteLine($"{brand} car created.");
    }

    ~Car()
    {
        Console.WriteLine($"{Brand} car destroyed.");
    }
}

Car myCar = new Car("Toyota");

构造函数在对象创建时被调用，而析构函数则在对象销毁时自动调用。在实际应用中，析构函数很少使用，更多时候会使用 IDisposable 接口进行资源管理。

---

3. 属性（Properties）

属性是对象的特征，通过 get 和 set 方法可以控制属性的访问和修改。

public class Circle
{
    private double _radius;

    public double Radius
    {
        get { return _radius; }
        set
        {
            if (value > 0)
                _radius = value;
            else
                Console.WriteLine("Radius must be positive.");
        }
    }

    public double GetArea()
    {
        return Math.PI * _radius * _radius;
    }
}

Circle circle = new Circle();
circle.Radius = 5;
Console.WriteLine($"Circle area: {circle.GetArea()}");

在这个例子中，Radius 是一个属性，我们通过 set 方法确保其值为正数。

---

4. 方法重载与重写

方法重载 允许在同一个类中定义多个同名的方法，只要参数列表不同即可。方法重写 则是在子类中重新定义父类的虚方法。

public class Calculator
{
    // 方法重载
    public int Add(int a, int b) => a + b;
    public double Add(double a, double b) => a + b;
}

public class Animal
{
    public virtual void Speak() => Console.WriteLine("Animal sound");
}

public class Dog : Animal
{
    // 方法重写
    public override void Speak() => Console.WriteLine("Bark");
}

Calculator calc = new Calculator();
Console.WriteLine(calc.Add(1, 2));        // 输出：3
Console.WriteLine(calc.Add(1.5, 2.5));    // 输出：4

Dog dog = new Dog();
dog.Speak();  // 输出：Bark

方法重载和重写使得同名方法可以根据上下文执行不同的操作，是实现多态的重要机制之一。

---

5. 继承与多态

继承 是面向对象编程中的核心概念之一，允许一个类继承另一个类的属性和方法。多态 则是不同对象可以通过同一个接口调用不同的实现。

public class Vehicle
{
    public virtual void Start() => Console.WriteLine("Vehicle starting");
}

public class Car : Vehicle
{
    public override void Start() => Console.WriteLine("Car starting");
}

public class Bike : Vehicle
{
    public override void Start() => Console.WriteLine("Bike starting");
}

Vehicle myCar = new Car();
Vehicle myBike = new Bike();

myCar.Start();  // 输出：Car starting
myBike.Start(); // 输出：Bike starting

通过继承，子类可以重用父类的代码，而多态使得不同的对象可以通过相同的接口调用不同的实现。

---

6. 抽象类与接口

抽象类 不能实例化，只能通过继承实现。接口 定义了类必须实现的行为。

public abstract class Animal
{
    public abstract void MakeSound();
}

public class Cat : Animal
{
    public override void MakeSound() => Console.WriteLine("Meow");
}

public interface IFlyable
{
    void Fly();
}

public class Bird : Animal, IFlyable
{
    public override void MakeSound() => Console.WriteLine("Chirp");
    public void Fly() => Console.WriteLine("Flying");
}

Cat cat = new Cat();
cat.MakeSound();  // 输出：Meow

Bird bird = new Bird();
bird.MakeSound(); // 输出：Chirp
bird.Fly();       // 输出：Flying

抽象类和接口的组合为我们提供了灵活且可扩展的设计方式。

---

7. 静态成员和静态类

静态成员 是属于类本身的，而不是对象。静态类 不能被实例化，所有成员都必须是静态的。

public static class MathHelper
{
    public static int Square(int x) => x * x;
}

int result = MathHelper.Square(5);
Console.WriteLine(result);  // 输出：25

静态类和静态成员非常适合存储无需实例化的通用功能或工具方法。

---

8. 泛型（Generics）

泛型 允许我们编写可以处理任何数据类型的类和方法，而无需为每种数据类型编写不同的代码。

public class Box<T>
{
    public T Value { get; set; }
}

Box<int> intBox = new Box<int> { Value = 123 };
Box<string> strBox = new Box<string> { Value = "Hello" };

Console.WriteLine(intBox.Value);  // 输出：123
Console.WriteLine(strBox.Value);  // 输出：Hello

泛型提高了代码的复用性，并且在编译时提供类型检查的安全性。

---

结论

C# 提供了一系列强大而灵活的工具来支持面向对象编程，包括类与对象、继承、多态、接口、泛型等概念。掌握这些基础知识有助于构建健壮且易于扩展的应用程序。希望这篇文章能够帮助你更好地理解和应用这些核心概念。