C#中使用Override和New关键字进行版本控制_Java

1. 基础概念

1.1 override

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

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

1.2 new

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

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

2. 示例代码

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.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 关键字隐藏了基类中的同名方法。