如果派生类没有重写该方法，则应调用哪个版本

本文关键字：调用 版本 方法 派生 重写 如果 | 更新日期: 2023-09-27 18:22:27

我试图理解C#中重写和虚拟的需求，所以我写了以下代码：

using System;
namespace Override
{
    class Base 
    {
        public virtual void method() 
        {
            Console.WriteLine("Base method");
        }
    }
    class Derived : Base 
    {
        public override void method()
        {
            Console.WriteLine("Derived method");
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            Derived d = new Derived();
            d.method();
        }
    }
}

我期待着"派生方法"被调用并打印出来。然后，我在不使用虚拟/覆盖组合的情况下编写了以下代码。

using System;
namespace Override
{
    class Base 
    {
        public void method() 
        {
            Console.WriteLine("Base method");
        }
    }
    class Derived : Base 
    {
        public void method()
        {
            Console.WriteLine("Derived method");
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            Derived d = new Derived();
            d.method();
        }
    }
}

我得到了同样的结果，即"派生方法"被调用并打印出来。我的问题是，如果代码像我预期的那样在没有虚拟/覆盖的情况下工作，那么它们的需求是什么？还是我这里遗漏了什么？

如果派生类没有重写该方法，则应调用哪个版本

在源代码中，您总是在进行简单的继承，而没有任何多态行为。您总是创建派生类的实例，并将其分配给派生类实例变量。

DerivedClass d = new DerivedClass(); // here no polymorphism, and only inheritance is there

所以，当您使用类变量调用方法时，它将始终调用DerivedClass方法，无论该方法是虚拟的还是不在父类中。

在多态性中，程序不知道调用方法的类的确切类型（这个概念称为后期绑定）。如以下示例所示：

BaseClass b = new DerivedClass(); // here b is a base class instance but initiated using derived class

调用b.method（）后，它将进行后期绑定并显示多态行为（仅当该方法在基类中设置为虚拟时）

注意：虚拟关键字延迟将方法的正确版本绑定到运行时，并且是实现多态性的核心关键字。因此，对于确切的多态行为，在父类中将方法声明为虚拟的，然后在子类中，ovverride该方法

virtual允许在运行时根据编译时不可用的信息选择方法的正确版本。考虑对您的示例进行以下调整：

using System;
namespace Override
{
    class Base 
    {
        public virtual void method() 
        {
            Console.WriteLine("Base method");
        }
    }
    class Derived : Base 
    {
        public override void method()
        {
            Console.WriteLine("Derived method");
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            Derived d = new Derived();
            Base b = d;
            b.method();
        }
    }
}

对于virtual/override，此代码将显示Derived method，因为在运行时我们可以看到b实际上是一个Derived实例。如果没有virtual/override，它将显示Base method，因为声明的b类型是Base。

这是您缺少的测试：

Base d = new Derived();
d.method(); // "Derived method"
Base b = new Base();
b.method(); // "Base method"

还可以想象一下，如果您有一个由不同继承对象组成的Base对象集合。virtual关键字允许那些Base对象了解它们在运行时的实际类型。

List<Base> collection = new List<Base>();
collection.Add(new Base());
collection.Add(new Derived()};
collection.Add(new Base());
foreach(Base b in collection)
{
     b.method(); // will print out "Base" or "Derived" correctly
}

请参阅差异

        class Base 
        {
            public void method() 
            {
                Console.WriteLine("Base method");
            }
        }
        class Derived : Base 
        {
            public void method()
            {
                Console.WriteLine("Derived method");
            }
        }
        class Program
        {
            static void Main(string[] args)
            {
                Derived d;
                d = new Derived();
                d.method();
                d = new Base();
                d.method();
            }
        }

输出：
派生方法
派生方法

            class Base 
            {
                public virtual void method() 
                {
                    Console.WriteLine("Base method");
                }
            }
            class Derived : Base 
            {
                public override void method()
                {
                    Console.WriteLine("Derived method");
                }
            }
            class Program
            {
                static void Main(string[] args)
                {
                    Derived d;
                    d = new Derived();
                    d.method();
                    d = new Base();
                    d.method();
                }
            }

输出：
派生方法
基本方法

基类指针可用于指向基类的对象或从基类派生的任何对象。因此，当基类对象指向派生类时，虚拟方法的需求就显现出来了 
Base d = new Derived();
d.method(); // "Derived method"

Derived类上的方法"method"将隐藏基类的实现，这就是您收到消息"Derived method"的原因。

虚拟和抽象有很多用途，但有一个例子是基类中的功能可能不适合从基类继承的所有类的情况。使用virtual允许另一个类完全覆盖该功能并提供自己的实现。

相关文章：