C# OOP 从零到精通：类、对象、继承与多态的深度解析

C# OOP 深度解析：类、对象、继承与多态

面向对象编程（OOP）是C#的核心范式，通过类、对象、继承和多态构建模块化、可扩展的代码体系。以下从基础到高级逐步解析：

---

一、类与对象：万物皆对象

类是对象的蓝图，定义属性和行为；对象是类的实例化实体。

// 定义类
public class Person
{
    // 属性（字段封装）
    public string Name { get; set; } 
    private int _age;  // 私有字段
    
    // 构造函数
    public Person(string name, int age)
    {
        Name = name;
        _age = age;
    }
    
    // 方法
    public void Greet() 
    {
        Console.WriteLine($"Hello, I'm {Name}!");
    }
}

// 创建对象
Person person = new Person("Alice", 30);
person.Greet();  // 输出: Hello, I'm Alice!

关键点：

• 类封装数据（属性）和行为（方法）
• 构造函数初始化对象状态
• private实现封装，隐藏内部细节

---

二、继承：代码复用与层次化设计

子类继承父类特性，扩展新功能。C#使用:符号表示继承。

// 基类
public class Animal
{
    public string Species { get; set; }
    public virtual void Speak() => Console.WriteLine("Animal sound");
}

// 派生类
public class Dog : Animal
{
    public Dog() => Species = "Canine";
    
    // 重写父类方法
    public override void Speak() => Console.WriteLine("Woof!");
}

// 使用继承
Dog myDog = new Dog();
myDog.Speak();  // 输出: Woof!

核心规则：

1. 子类自动获得父类公共成员
2. virtual允许方法被重写，override显式重写
3. 单继承限制：C#不支持多类继承（但支持多接口）

---

三、多态：同一接口，多种实现

多态分为静态（编译时）和动态（运行时）：
1. 静态多态（重载）
同一方法名，不同参数列表：

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

2. 动态多态（重写 + 接口）
通过继承实现运行时绑定：

Animal animal1 = new Dog();  // 父类引用指向子类对象
Animal animal2 = new Cat();  // 假设Cat类也继承Animal
animal1.Speak();  // 输出: Woof! (实际调用Dog的方法)
animal2.Speak();  // 输出: Meow! (实际调用Cat的方法)

3. 接口多态
接口定义契约，类实现具体行为：

public interface IDrawable
{
    void Draw();
}

public class Circle : IDrawable
{
    public void Draw() => Console.WriteLine("Drawing circle");
}

public class Square : IDrawable
{
    public void Draw() => Console.WriteLine("Drawing square");
}

// 多态调用
IDrawable[] shapes = { new Circle(), new Square() };
foreach (var shape in shapes)
{
    shape.Draw();  // 根据实际对象类型调用不同实现
}

---

四、关键概念对比

特性	继承	多态
目的	代码复用/层次扩展	统一接口多样化实现
实现	class Child : Parent	virtual/override + 接口
绑定	编译时确定类型	运行时动态绑定
灵活性	受限于单继承	通过接口突破限制

---

五、最佳实践

1. 继承慎用：优先组合而非继承，避免过度层级
2. 多态优化：
   • 使用接口解耦（如IEnumerable）
   • abstract class强制派生类实现抽象方法
3. SOLID原则：
   • 开闭原则（通过继承/多态扩展）
   • 里氏替换（子类可替换父类）

// 抽象类示例
public abstract class Shape
{
    public abstract double Area();  // 强制子类实现
}

public class Rectangle : Shape
{
    public double Width { get; set; }
    public double Height { get; set; }
    
    public override double Area() => Width * Height;  // 多态实现
}

---

总结

• 类与对象：构建程序的基本单元
• 继承：建立"is-a"关系，纵向扩展功能
• 多态：通过接口/重写实现"同一操作，不同行为"
  掌握OOP三大支柱，可显著提升代码的可维护性、扩展性和复用性。