C#中重写override与覆盖new的本质区别及使用场景

1. 核心概念辨析

第1步：理解重写(override)

目的：实现运行时多态，允许派生类提供基类虚方法的特定实现。

入口/前提：基类方法必须标记为 virtual、abstract 或 override。派生类使用 override 关键字。

关键特性：

• 访问修饰符：重写方法的访问级别必须与原方法相同或更宽松（例如，基类是 protected，重写可以是 protected 或 public）。
• 签名一致性：方法名、参数列表和返回类型必须完全一致。
• 多态体现：即使使用基类引用指向派生类对象，调用的也是派生类的实现。

public override ReturnType MethodName(params)
{
    // 派生类实现逻辑
}

第2步：理解覆盖/隐藏(new)

目的：在派生类中隐藏基类的同名成员，而非替换其功能。常用于无法修改的第三方库或历史遗留代码的扩展。

入口/前提：基类成员可以是 virtual、普通方法(sealed除外)、字段等。派生类使用 new 关键字显式声明。

关键特性：

• 非多态：这是编译时的静态绑定。如果变量类型是基类，即使实例是派生类，调用的仍是基类方法。
• 兼容性：基类方法不需要标记为 virtual。但如果是 virtual 方法，编译器会发出警告，建议优先使用 override。
• 独立性：隐藏后，派生类中的新成员与基类成员在派生类作用域内完全独立，互不干扰。

public new ReturnType MemberName(params)
{
    // 新成员实现逻辑
}

2. 行为差异演示与分析

为了直观展示两者的不同，我们构建一个包含基类、重写派生类和覆盖派生类的测试场景。

第3步：定义基类与派生类结构

基类定义一个虚方法，两个派生类分别使用 override 和 new 进行处理。

// 基类
public class FatherClass
{
    public virtual string GetName()
    {
        return "我是父类中的虚拟方法";
    }
}

// 子类1：使用重写(override)
public class SonClass1 : FatherClass
{
    public override string GetName()
    {
        return "我是子类1中的重写方法";
    }
}

// 子类2：使用覆盖(new)
public class SonClass2 : FatherClass
{
    public new string GetName()
    {
        return "我是子类2中的覆盖方法";
    }
}

第4步：执行多态与静态绑定的对比测试

通过直接实例化子类和使用基类引用指向子类两种方式进行调用，观察输出结果。

public class Program
{
    public static void Main(string[] args)
    {
        // 1. 正常子类实例调用
        FatherClass fatherClass = new FatherClass();
        Console.WriteLine($"直接调用父类: {fatherClass.GetName()}");

        SonClass1 s1 = new SonClass1();
        Console.WriteLine($"直接调用子类1(override): {s1.GetName()}");

        SonClass2 s2 = new SonClass2();
        Console.WriteLine($"直接调用子类2(new): {s2.GetName()}");

        // 2. 关键测试：父类引用指向子类对象
        FatherClass f1 = new SonClass1(); // 多态场景
        Console.WriteLine($"父类引用->子类1(override): {f1.GetName()}");

        FatherClass f2 = new SonClass2(); // 静态绑定场景
        Console.WriteLine($"父类引用->子类2(new): {f2.GetName()}");
    }
}

3. 运行结果解读

执行上述代码，控制台输出如下：

直接调用父类: 我是父类中的虚拟方法
直接调用子类1(override): 我是子类1中的重写方法
直接调用子类2(new): 我是子类2中的覆盖方法
父类引用->子类1(override): 我是子类1中的重写方法
父类引用->子类2(new): 我是父类中的虚拟方法

分析结论：

1. 直接调用：无论哪种方式，子类实例都调用自己的成员，结果符合预期。
2. 父类引用调用子类1 (override)：由于使用了 override，f1 指向的是 SonClass1 的动态类型，触发多态机制，输出了子类的文字。
3. 父类引用调用子类2 (new)：f2 的静态类型是 FatherClass。由于 SonClass2 使用了 new，它只是“隐藏”了父类方法，并未替换。因此，编译器根据变量类型 FatherClass 选择了父类的方法实现。

4. 使用规则与最佳实践

第5步：明确适用边界

第6步：决策指南

• 优先使用 override：在设计类库或进行正常继承时，若要改变行为以支持多态，几乎总是应该使用 override。这是面向对象设计的核心模式。
• 谨慎使用 new：仅在以下情况考虑使用：
  - 基类是密封类 (sealed) 或非虚方法，但你希望提供一个不同的实现且不希望发生多态。
  - 你正在扩展一个不可更改的第三方类，不想意外地通过基类接口触发子类的副作用。

5. 常见问题排查

Q: 为什么我对虚方法用了 new 编译器只警告不报错？

A: C# 允许这样做是为了向后兼容和灵活性。但这通常意味着你的代码意图不明确：你是想隐藏它还是重用它？如果是想改变多态行为，请改用 override。如果在设计中确定要隐藏，添加 new 关键字可以消除警告并明确传达给其他开发者。

Q: 抽象方法和接口能使用 new 吗？

A: 不能。抽象方法和接口成员强制要求派生类提供实现，这本质上就是隐式的 override 机制，不存在“隐藏”的概念，必须使用 override (或在未指定时由编译器自动生成 override)。

总结

C# 中的 override 是实现多态的桥梁，它让基类指针能够智能地调用子类的最新实现；而 new 则是成员的“隐身术”，它在派生类内部创建了一个独立的副本，切断了与基类实现的动态联系。掌握这两者的区别，能够帮助你在设计继承体系时做出更精准的技术选型，避免潜在的逻辑陷阱。

以上就是C#中重写override与覆盖new的本质区别及使用场景的详细内容，更多关于C# 重写 覆盖多态的资料请关注本站其它相关文章！