关于虚拟/新建/覆盖的混淆

Question

我对 virtual/new/override 的事情有点困惑。这是一个例子：

class A
{
    public virtual void mVVirtual() { Console.WriteLine("A::mVVirtual"); }
}

class B : A
{
    public virtual void mVVirtual() { Console.WriteLine("B::mVVirtual"); }
}

class C : B
{
    public override void mVVirtual() { Console.WriteLine("C::mVVirtual"); }
}


class Test
{
    static void Main()
    {
        B b1 = new C();
        b1.mVVirtual();    //C::mVVirtual ... I understand this

        A a2 = new C();
        a2.mVVirtual();    //A::mVVirtual ... ???
    }
}

我不明白为什么在第二次调用中我们得到 A::mVVirtual。我通常用这个“算法”来处理这些问题：

1. 检查保存名为 mVVirtual 的实例方法的对象引用的变量类型？没有……但有一个具有该签名和名称的虚拟方法！
2. 虚拟方法？然后，让我们检查 a2 (C) 所持有的对象的类型，以覆盖该方法。它有一个->执行C::mVVirtual！

我的“算法”哪里错了？我真的对此感到困惑，非常感谢一些帮助。

Answer 1

这是您对虚拟方法的看法。类的每个实例都有保存方法的“盒子”。当您将一个方法标记为虚拟时，它会说创建一个新的“盒子”并在其中放入一个方法。当您在派生类中将方法标记为override时，它会保留基类中的“框”，但会在其中放入一个新方法。

因此，这里有一个类 A 和一个名为 mVVirtual 的方法，该方法被标记为 virtual。这表示创建一个名为 mVVirtual 的新“盒子”，并在其中添加一个带有定义的方法

Console.WriteLine("A::mVVirtual"); 

然后您就有一个派生类 B 和一个名为 mVVirtual 的方法> 被标记为虚拟。这表示创建一个名为 mVVirtual 的新“盒子”，并在其中放入一个带有定义的方法

Console.WriteLine("B::mVVirtual"); 

特别是，从 A 继承的“盒子”被隐藏了！类型为 B 的对象或从 B 派生的类无法看到它。

那么您就有一个派生类 C 和一个名为 mVVirtual 的方法，该方法被标记为 override。这表示采用从 B 继承的名为 mVVirtual 的“盒子”，并在其中添加一个不同的方法和定义。

Console.WriteLine("C::mVVirtual"); 

现在，当您拥有时，

B b1 = new C(); 
b1.mVVirtual();

您将告诉编译器 b1 是一个 B，因此 b1.mVVirtual() 会在“盒子”mVVirtual 中查找并找到具有定义的方法，

Console.WriteLine("C::mVVirtual"); 

因为 < code>b1 实际上是一个 C，这就是 C 实例的“盒子”mVVirtual 中的内容。

但是，当您

A a2 = new C(); 
a2.mVVirtual();

告诉编译器 a2 是 A 时，它会在“盒子”中查找并找到

Console.WriteLine("A::mVVirtual");

编译器无法知道 a2< /code> 实际上是一个 C （您将其输入为 A），因此它不知道 a2 实际上是一个实例派生自隐藏了由 A 定义的“盒子”mVVirtual 的类。它所知道的是 A 有一个名为 mVVirtual 的“盒子”，因此它会发出代码来调用该“盒子”中的方法。

因此，尝试简洁地说：

class A {
    public virtual void mVVirtual() { Console.WriteLine("A::mVVirtual"); }
}  

定义一个类，它有一个全名为 A::mVVirtual 的“盒子”，但您可以通过名称 mVVirtual 来引用它。

class B : A 
{
    // "new" method; compiler will tell you that this should be marked "new" for clarity.
    public virtual void mVVirtual() { Console.WriteLine("B::mVVirtual"); }
}  

定义一个类，该类有一个全名为 B::mVVirtual 的“盒子”，但您可以通过名称 mVVirtual 来引用它。引用B.mVVirtual不会引用全名为A::mVVirtual的“盒子”；类型为 B 的对象（或从 B 派生的类）无法看到“盒子”。

class C : B
{
    public override void mVVirtual() { Console.WriteLine("C::mVVirtual"); }
}  

定义一个类，它采用全名为 B::mVVirtual 的“盒子”，并在其中放入不同的方法。

然后

A a2 = new C(); 
a2.mVVirtual();

说 a2 是 A，以便 a2.mVVirtual 在全名 A::mVVirtual< 的“盒子”中查找/code> 并调用该“盒子”中的方法。这就是您

A::mVVirtual

在控制台上看到的原因。

还有另外两个方法注释器。 abstract 创建一个新的“盒子”，但不会在“盒子”中放入方法定义。 new 创建一个新的“盒子”，并将方法定义放入“盒子”中，但不允许派生类将自己的方法定义放入“盒子”中（使用 virtual< /code> 如果你想这样做）。

抱歉啰嗦了，但希望能有所帮助。

Answer 2

更新：有关此语言功能的更多信息，请参阅此处的后续问题：有关虚拟/新...加上界面的更多信息！

Jason 的答案是正确的。总结得更简洁一些。

你有三种方法。称他们为 MA、MB 和 MC。

您有两个“盒子”，或者通常称为插槽。我们将坚持使用 Jason 的命名法。将它们称为 BOX1 和 BOX2。

“A”定义BOX1。

“B”定义了BOX2。

“C”定义无框；它重用了 BOX2。

当您说“new A()”时，BOX1 会填充 MA。

当您说“new B()”时，BOX1 填充为 MA，BOX2 填充为 MB。

当您说“new C()”时，BOX1 填充为 MA，BOX2 填充为 MC。

现在假设您有一个 A 类型的变量，以及对该方法的调用。原因就像编译器一样。编译器会说“类型 A 上是否有与该名称匹配的框？”是的，有一个：BOX1。因此，编译器生成对 BOX1 内容的调用。

正如我们所看到的，BOX1 的内容始终是 MA，因此无论变量实际上是否持有对 A、B 或 C 的引用，总是会调用 MA。

现在假设您有一个 B 类型的变量，并且有一个调用到方法。再次，像编译器一样思考。编译器会说“类型 B 上是否有与该名称匹配的框？”是的，有两个按名称匹配的框。编译器会说“这两者中哪一个与 B 的关联更紧密？”答案是 BOX2，因为 B 声明了 BOX2。因此，编译器生成对 BOX2 的调用。

如果变量包含 B，这将调用 MB，因为在 B 中，BOX2 包含 MB。如果变量包含 C，这将调用 MC，因为在 C 中，BOX2 包含 MC。

现在清楚了吗？请记住，重载分辨率只是选择该框。框中的内容取决于运行时的对象。

Answer 3

你有隐藏警告吗？当我做你所做的事情时，我收到以下警告：

“ProjectName.ClassName.B.mVVirtual()”隐藏继承成员“ProjectName.ClassName.A.mVVirtual()”。要使当前成员覆盖该实现，请添加 override 关键字。否则添加新关键字。

如果你在B类中使用了override，你就不会遇到这个问题；这两种情况都会给你“C::mVVirtual”。由于您没有在 B 类中使用 override，因此该方法前面有一个隐式 new。这打破了继承链。您的代码正在调用类型 A 上的方法，并且由于隐式 new ，没有继承类重写该方法。所以它必须调用A类的实现。

Answer 4

最好的思考方式是，虚拟方法使用对象的实际（或具体）类型来决定执行什么实现，其中非虚拟方法使用您用来访问该方法的变量的声明类型来决定运行哪个...

覆盖意味着您正在编写一个方法将“替换”继承链上方的虚拟或抽象方法（具有相同名称/签名）的实现。

new 当链上有一个具有相同名称/签名的非虚拟方法时使用，您要添加的方法将替换该方法...

区别如下，

class base     { public virtual void  foo() { Console.write("base.foo"); } }
class derived  { public override void foo() { Console.write("derived.foo"); } }
base b = new base();
b.foo()  // prints "base.foo" // no issue b is a base and variable is a base
base b = new derived();
b.foo(); // prints "derived.foo" because concrete tyoe is derived, not base

但

class base     { public void  foo() { Console.write("base.foo"); } }
class derived  { public new void foo() { Console.write("derived.foo"); } }
base b = new base();
b.foo()  // prints "base.foo" // no issue b is a base and variable is a base
base b = new derived();
b.foo(); // prints "base.foo" because variable b is base. 
derived d = b as derived;
d.foo()    //  prints "derived.foo" - now variable d is declared as derived. 

您的第二次调用会打印 < code>A::mvVirtual 因为该方法 (mVVirtual) 实际上是不是虚拟的（尽管它的名称如此），因为它有 new 说明符...所以它根据变量类型决定，即 A。

为了解释技术上发生的情况，每个类型都有一个“方法表”，其中包含指向所有变量的指针该类型中的方法。 （它不是具有此表的类型的实例，而是TYPE本身。）每个类型的方法表首先由所有可访问的虚拟方法构成，从object（继承链的最上面），到类型本身中声明的虚拟方法，最后。然后，在表示完所有虚拟方法之后，再次从 object 中的任何非虚拟方法添加所有非虚拟方法，首先，一直添加到对象中的任何非虚拟方法。输入本身。该表的结构如此，以便所有虚拟方法的偏移量在所有派生类的方法表中都相同，因为编译器可以从声明为其他类型的变量调用这些方法，甚至可以从在基类中声明和实现的其他方法中的代码调用这些方法具体类的类型。

当编译器解析虚拟方法调用时，它会转到对象本身类型的方法表（具体类型），而对于非虚拟调用它转到方法表以获取变量的声明类型。因此，如果您调用虚拟方法，即使是从基类型中的代码调用，如果实际的具体类型是从此基类型派生的类型，编译器也会转到该具体类型的方法表。

如果调用非虚拟方法（无论继承更改实际对象类型的程度如何），编译器都会访问 variab;es 声明类型的方法表。该表没有任何来自链中任何派生类型的内容。

Answer 5

我是这样理解的

A 是基类
B 继承 A 但不覆盖它
C 继承 B 但重写它

由于您声明 A 但初始化 C，它将忽略重写，因为基类是 A 并且 A 永远不会被 B 重写。