掌握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;elseConsole.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));    // 输出：4Dog 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();  // 输出：MeowBird 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

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