使⽤ Override 和 New 关键字进⾏版本控制（C#）

文章目录

1. 基础概念
- 1.1 override
- 1.2 new
2. 示例代码
- 1. override 关键字
- 2. new 关键字
3.完整示例测试
- 3.1 基类和派生类的定义
- 3.2 测试代码
- 3.3 运行结果
结论

在 C# 中，override 和 new 关键字用于控制类之间的成员方法的隐藏和重写。理解它们之间的差异和使用场景对于设计灵活且易于维护的代码至关重要。在这篇博客中，我们将详细探讨这两个关键字的用法，并通过示例来说明它们的实际应用。

1. 基础概念

1.1 override

override 关键字用于重写基类中已经声明为 virtual 或 abstract 的方法、属性或索引器。使用 override 关键字可以提供基类方法的新实现。它的主要特点包括：

多态性：通过重写方法，派生类可以实现特定的行为。
基类引用：即使是基类引用，调用重写的方法也会执行派生类的实现。

1.2 new

new 关键字用于隐藏基类中的成员（方法、属性或事件）。当使用 new 关键字时，派生类中的成员将隐藏基类中的同名成员。它的特点包括：

不支持多态性：基类引用仍会调用基类的方法，而不是派生类的方法。
名称隐藏：派生类中的成员遮蔽了基类中的同名成员，但两者仍然存在于不同的作用域中。

2. 示例代码

1. override 关键字

override 关键字用于子类中覆盖（重写）父类中的方法。这样做可以让子类提供特定的实现，以满足其对方法的个性需求。

示例 1：使用 override 覆盖父类方法

using System;

class Animal
{
    public virtual void MakeSound()
    {
        Console.WriteLine("Animal makes a sound");
    }
}

class Dog : Animal
{
    public override void MakeSound()
    {
        Console.WriteLine("Dog barks");
    }
}

class Program
{
    static void Main(string[] args)
    {
        Animal myAnimal = new Animal();
        Animal myDog = new Dog();

        myAnimal.MakeSound();  // 输出：Animal makes a sound
        myDog.MakeSound();     // 输出：Dog barks
    }
}

在这个例子中，Dog 类继承自 Animal 类，并覆盖了 MakeSound 方法。当 myDog.MakeSound() 被调用时，它将输出 “Dog barks”，而不是 “Animal makes a sound”。

2. new 关键字

new 关键字在C#中有两个主要用途：

它用于隐藏继承自基类的成员（方法、属性、事件等）。
它用于在接口中提供实现。
示例 2：使用 new 隐藏继承的方法

using System;

class Animal
{
    public virtual void MakeSound()
    {
        Console.WriteLine("Animal makes a sound");
    }
}

class Dog : Animal
{
    new public void MakeSound()
    {
        Console.WriteLine("Dog barks");
    }
}

class Program
{
    static void Main(string[] args)
    {
        Animal myAnimal = new Animal();
        Animal myDog = new Dog();

        myAnimal.MakeSound();  // 输出：Animal makes a sound
        myDog.MakeSound();     // 输出：Dog barks
    }
}

在这个例子中，尽管 Dog 类覆盖了 MakeSound 方法，但是由于 new 关键字的使用，基类 Animal 的 MakeSound 方法不会被隐藏。

示例 3：使用 new 在接口中提供实现

using System;

interface IMyInterface
{
    void MyMethod();
}

class MyClass : IMyInterface
{
    public void MyMethod()
    {
        Console.WriteLine("Interface method implementation");
    }
}

class Program
{
    static void Main(string[] args)
    {
        IMyInterface myClass = new MyClass();
        myClass.MyMethod();  // 输出：Interface method implementation
    }
}

在这个例子中，MyClass 类实现了 IMyInterface 接口，并使用了 new 来提供 MyMethod 的具体实现。

3.完整示例测试

3.1 基类和派生类的定义

using System;

public class Animal
{
    // 一个虚方法，可以在派生类中被重写
    public virtual void Speak()
    {
        Console.WriteLine("Animal speaks");
    }

    // 一个普通方法，可以在派生类中被隐藏
    public void Sleep()
    {
        Console.WriteLine("Animal sleeps");
    }
}

public class Dog : Animal
{
    // 重写基类的虚方法
    public override void Speak()
    {
        Console.WriteLine("Dog barks");
    }

    // 使用 new 关键字隐藏基类的同名方法
    public new void Sleep()
    {
        Console.WriteLine("Dog sleeps");
    }
}

3.2 测试代码

接下来，我们可以编写一个测试程序，来演示 override 和 new 的行为。

class Program
{
    static void Main(string[] args)
    {
        Animal myAnimal = new Animal();
        myAnimal.Speak();  // 输出: Animal speaks
        myAnimal.Sleep();  // 输出: Animal sleeps

        Animal myDog = new Dog();
        myDog.Speak();     // 输出: Dog barks (多态性)
        myDog.Sleep();     // 输出: Animal sleeps (基类方法)

        Dog realDog = new Dog();
        realDog.Speak();   // 输出: Dog barks
        realDog.Sleep();   // 输出: Dog sleeps (新定义的方法)

        Console.ReadLine();
    }
}

3.3 运行结果

运行上述程序，输出结果如下：

Animal speaks
Animal sleeps
Dog barks
Animal sleeps
Dog barks
Dog sleeps

分析

多态性：在示例中，myDog 是 Animal 类型的引用，但它指向一个 Dog 对象。调用 Speak 方法时，输出是 Dog barks，这就是多态性的体现。myDog.Sleep() 调用的是基类的 Sleep 方法，输出 Animal sleeps，因为 Sleep 方法没有被标记为 virtual。
隐藏行为：realDog.Sleep() 调用的是 Dog 类中定义的新 Sleep 方法，输出 Dog sleeps。这表明使用 new 关键字隐藏了基类中的同名方法。