C#中Override和New关键字的区别与应用场景

基本概念与默认行为

C# 在设计上允许派生类中存在与基类同名的方法，但为了保持版本兼容性和向后兼容性，编译器要求开发者必须明确指定该方法的交互方式。若不指定 new 或 override，编译器将发出警告 CS0108，并按 new 的行为执行。

• virtual：基类标记为虚方法，允许子类重写。
• override：派生类显式替代父类的虚方法实现。
• new：派生类创建独立方法，隐藏（Hide）具有相同签名的基类方法。

第一种情况：使用 override 进行重写

当派生类的方法带有 override 修饰符时，它是对基类虚拟方法的扩展和替换。这意味着无论调用对象被声明为基类类型还是派生类类型，只要它是派生类的实例，都将优先调用派生类中的覆盖方法。这是实现多态的核心手段。

实现步骤：

1. 在基类中使用 public virtual 声明方法。
2. 在派生类中使用 public override 声明同名方法。

class BaseClass
{
    public virtual void Method1()
    {
        Console.WriteLine("Base - Method1");
    }
}

class DerivedClass : BaseClass
{
    public override void Method1()
    {
        Console.WriteLine("Derived - Method1");
    }
}

第二种情况：使用 new 隐藏基类方法

new 关键字用于显式告知编译器，派生类中的方法是全新的，旨在隐藏基类中具有相同名称的成员。这通常发生在基类升级增加了新方法，而你的派生类早已定义过同名方法的情况。

使用 new 后：
- 如果以派生类类型引用对象，调用的是派生类的新方法。
- 如果以基类类型引用同一对象，依然会调用基类的方法。

class DerivedClass : BaseClass
{
    // 隐藏基类方法
    public new void Method2() 
    {
        Console.WriteLine("Derived - Method2");
    }
}

实操演示：运行时的表现差异

下面通过完整的控制台应用程序来观察 override 与 new 在不同赋值方式下的输出结果。我们分别定义了 Method1（使用 override）和 Method2（使用 new）。

测试代码：

BaseClass bc = new BaseClass();       // 基类对象
DerivedClass dc = new DerivedClass(); // 派生类对象
BaseClass bcdc = new DerivedClass();  // 用派生类实例化基类引用

// 调用 override (Method1) 的结果
bc.Method1();      // Output: Base - Method1
dc.Method1();      // Output: Derived - Method1
bcdc.Method1();    // Output: Derived - Method1 (体现多态)

// 调用 new (Method2) 的结果
bc.Method2();      // Output: Base - Method2
dc.Method2();      // Output: Derived - Method2
bcdc.Method2();    // Output: Base - Method2 (未体现多态，因为是被隐藏的)

关键点分析：
上述最后一行 bcdc.Method2() 的输出是 Base - Method2。这是因为 new 只是静态地“隐藏”了方法，而非“替换”了方法。对于基类类型的指针/引用来说，它只认识自己的 Method2。

进阶场景：基类内部调用的影响

理解这两个关键字最关键的难点在于基类方法内部调用子类方法的场景。假设基类有一个公共方法 DescribeCar，它在内部调用了虚方法 ShowDetails。

我们构造两个派生类：
- ConvertibleCar 使用 new 隐藏了 ShowDetails。
- Minivan 使用了 override 重写了 ShowDetails。

public class Car 
{ 
    public virtual void DescribeCar() { 
        Console.WriteLine("Four wheels and an engine."); 
        ShowDetails(); 
    } 
    public virtual void ShowDetails() { 
        Console.WriteLine("Standard transportation."); 
    } 
}

public class ConvertibleCar : Car 
{ 
    public new void ShowDetails() { 
        Console.WriteLine("A roof that opens up."); 
    } 
} 

public class Minivan : Car 
{ 
    public override void ShowDetails() { 
        Console.WriteLine("Carries seven people."); 
    } 
}

第1步：直接调用派生类自定义方法

如果我们创建了具体的派生类对象并直接调用各自的 ShowDetails，结果符合预期：

new ConvertibleCar().ShowDetails(); // 输出: A roof that opens up.
new Minivan().ShowDetails();        // 输出: Carries seven people.

第2步：通过基类接口调用（关键差异点）

现在，我们创建一个基类类型的列表，循环调用所有车辆的 DescribeCar 方法。由于 DescribeCar 是在基类中定义的，并且它在内部调用了 ShowDetails：

List<Car> cars = new List<Car> 
{ 
    new Car(), 
    new ConvertibleCar(), 
    new Minivan() 
};
foreach(var car in cars) car.DescribeCar();

输出结果及解析：

TestCars
----------
Four wheels and an engine.
Standard transportation. // Car: 正常调用基类 ShowDetails

Four wheels and an engine.
Standard transportation. // ConvertibleCar: 虽然对象是轿车，但因为使用了 new，DescribeCar 内部调用的仍是基类的 ShowDetails！

Four wheels and an engine.
Carries seven people.    // Minivan: 由于使用了 override，成功触发了多态，调用了子车的细节描述。

这一现象揭示了 new 的本质缺陷：在基类的逻辑内部，你无法利用 new 来改变派生类的特定行为，除非你在派生类中也重新实现了整个 DescribeCar 流程（这会破坏封装性）。

何时选择使用 override 或 new？

总结

override 是面向对象多态的灵魂，它能确保派生类的行为在基类上下文中也能正确运作；而 new 是一种防御性机制，主要用于解决命名空间污染和基类演进带来的兼容性警告，但它剥夺了方法的多态能力。在实际架构设计中，请优先考虑使用 virtual/override 来构建可扩展的继承体系。

以上就是C# Override和New关键字用法的详细内容，更多关于C#多态设计与继承的资料请关注本站其它相关文章！