C# 面向对象三大特性详解：封装、继承与多态实战

结果或目标

面向对象编程旨在模仿现实世界，将事物抽象为拥有状态和行为“对象”。其核心价值在于通过封装屏蔽内部复杂性以保障安全，通过继承实现代码重用与层次分类，通过多态提供统一的调用接口以适应不同对象的特定行为。最终目标是编写出结构清晰、易于修改且具备高度复用性的程序。

准备条件

1. 开发环境：已安装支持 C# 的 IDE（如 Visual Studio）。代码示例基于 .NET 标准语法。
2. 基础概念：了解类（Class）、对象（Object）、方法（Method）及属性（Property）的基本用法。

真实操作顺序

第1步：理解并实现封装（Encapsulation）

封装是将数据（属性）和操作数据的方法绑定在一起，并限制对内部状态的直接访问。在 C# 中，通常通过访问修饰符（如 private、public）实现。

• 目的：隐藏内部实现细节，防止外部代码随意修改关键数据，减少类之间的耦合。
• 操作要点：
• 将成员变量设为 private，仅通过公共属性或方法进行读写。
• 提供稳定的公有接口（Public Interface），即使内部逻辑改变，只要接口不变，依赖该类的其他代码无需修改。

第2步：构建类层次——继承（Inheritance）

继承允许创建一个新类（派生类/子类）来复用现有类（基类/父类）的功能，并进行扩展。这有助于建立清晰的分类结构。

• 目的：避免重复编写相同代码，体现“IS-A”关系（如圆是一种形状）。
• 操作要点：
• 使用 : 符号表示继承，例如 class Circle : Shape。
• 基类可以包含虚方法（virtual）供子类重写，或抽象方法（abstract）强制子类实现。
• 使用 : base(...) 调用父类构造函数以初始化共享状态。

第3步：应用多态性（Polymorphism）

多态是指同一个接口在不同对象上表现出不同的行为。在 C# 中，主要通过方法重写（Override）和向上转型（Upcasting）实现。

• 目的：使代码能够以统一的方式处理不同类型的对象，增强系统的灵活性和可扩展性。
• 操作要点：
• 子类使用 override 关键字重写父类的 virtual 或 abstract 方法。
• 将子类实例赋值给父类类型的引用（例如 IList<Shape> 中存储 Circle 和 Rectangle）。
• 调用父类定义的通用方法时，实际执行的是子类的特定实现。

完成判断：代码实例

以下代码完整展示了上述三个特性的结合应用。我们定义一个抽象基类 Shape，并创建 Circle 和 Rectangle 两个子类。

1. 定义抽象基类 Shape（体现封装与继承的基础）

/// <summary>
/// 形状基类
/// </summary>
public abstract class Shape
{
    /// <summary> 
    /// 形状名称 - 使用 private set 体现封装
    /// </summary>
    public string ShapeName { get; private set; }

    public Shape(string shapeName)
    {
        ShapeName = shapeName;
    }

    /// <summary>
    /// 输出形状周长 - virtual 允许子类覆盖
    /// </summary>
    public virtual void PrintPerimeter(double perimeter)
    {
        Console.WriteLine(ShapeName + " Perimeter: " + perimeter);
    }

    /// <summary>
    /// 输出形状面积 - virtual 允许子类覆盖
    /// </summary>
    public virtual void PrintArea(double area)
    {
        Console.WriteLine(ShapeName + " Area: " + area);
    }

    /// <summary>
    /// 计算形状周长 - abstract 强制子类实现
    /// </summary>
    public abstract double CalculatePerimeter();

    /// <summary>
    /// 计算形状面积 - abstract 强制子类实现
    /// </summary>
    public abstract double CalculateArea();
}

2. 实现具体子类 Circle（继承与方法重写）

/// <summary>
/// 圆 - 继承自 Shape
/// </summary>
public class Circle : Shape
{
    /// <summary>
    /// 圆的半径 - 公开属性供外部设置
    /// </summary>
    public double R { get; set; }

    public Circle()
      : base("Circle") // 调用父类构造函数
    {
        this.R = 0;
    }

    /// <summary>
    /// 重写计算周长方法
    /// </summary>
    public override double CalculatePerimeter()
    {
        return 2 * Math.PI * R;
    }

    /// <summary>
    /// 重写计算面积方法
    /// </summary>
    public override double CalculateArea()
    {
        return Math.PI * R * R;
    }
}

3. 实现具体子类 Rectangle（继承与方法重写）

public class Rectangle : Shape
{
    /// <summary>
    /// 长方形的宽度
    /// </summary>
    public double Width { get; set; }

    /// <summary>
    /// 长方形的高度
    /// </summary>
    public double Height { get; set; }

    public Rectangle()
      : base("Rectangle")
    {
        Width = 0;
        Height = 0;
    }

    /// <summary>
    /// 重写计算周长方法
    /// </summary>
    public override double CalculatePerimeter()
    {
        return (Width + Height) * 2;
    }

    /// <summary>
    /// 重写计算面积方法
    /// </summary>
    public override double CalculateArea()
    {
        return Width * Height;
    }
}

4. 测试多态性（Unified Interface）

通过将不同类型的对象存入父类类型的集合中，验证多态效果。

Circle circle = new Circle();
circle.R = 20;

// 注意：原文代码中包含 Square，但此处未定义 Square 类。
// 为保持代码可编译性，下面仅演示 Circle 和 Rectangle。
// 若需使用 Square，需先定义类似的 Square 类并继承 Shape。

Rectangle rectangle = new Rectangle();
rectangle.Width = 20;
rectangle.Height = 30;

// 多态的核心：将子类实例赋给父类类型的列表
IList<Shape> shapeList = new List<Shape&gt();
shapeList.Add(circle);
shapeList.Add(rectangle);

foreach (var shape in shapeList)
{
    // 运行时将根据实际对象类型调用对应的 Calculate... 方法
    shape.PrintPerimeter(shape.CalculatePerimeter());
    shape.PrintArea(shape.CalculateArea());
}

简要总结

在这个例子中，Shape 作为基类定义了共同的契约和默认行为（封装），Circle 和 Rectangle 通过继承复用了打印逻辑并实现了特定的计算逻辑（继承），最后通过 IList<Shape> 的统一循环调用来执行不同对象的专属算法（多态）。这种模式使得新增新的形状（如三角形）变得非常容易：只需新增一个继承自 Shape 的类并实现抽象方法即可，无需修改现有的遍历和打印代码。

以上就是 C# 面向对象三大特性：封装、继承、多态的详细内容，更多关于 C# 编程技巧的资料请关注本站其它相关文章！