关于虚拟/新/覆盖的困惑

Question

我对@9​​87654321@/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

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

所以这里有一个类A 和一个名为mVVirtual 的方法，标记为virtual。这就是说创建一个名为mVVirtual 的新“盒子”，并在其中放入一个带有定义的方法

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

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

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

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

然后你有一个派生类C 和一个名为mVVirtual 的方法被标记为override。这表示取名为 mVVirtual 的“盒子”继承自 B，并在其中定义一个不同的方法

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

现在，当你有

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

您是在告诉编译器 b1 是 B，以便 b1.mVVirtual() 在“框”中查找 mVVirtual 并找到具有定义的方法

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

因为b1 确实是C，这就是mVVirtual 中C 实例的“盒子”中的内容。

但是当你有

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

您是在告诉编译器 a2 是 A，因此它会在“框”中查找并找到

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

编译器无法知道a2 确实是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的“盒子”；类型为 Bs 的对象（或派生自 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 的“框”中查找并调用该“框”中的方法。这就是你看到的原因

A::mVVirtual

在控制台上。

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

抱歉啰嗦了，希望对你有所帮助。

Answer 2

更新：有关此语言功能的更多信息，请参阅此处的后续问题：More about Virtual / new...plus interfaces!

杰森的回答是正确的。总结的更简洁一些。

你有三种方法。称它们为 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，因此在方法前面有一个 implicit new。这打破了继承链。您的代码正在调用类型 A 的方法，并且由于隐含的 new，没有覆盖该方法的继承类。所以它必须调用A类的实现。

Answer 4

最好的想法是虚拟方法使用 actual（或 concrete）类型决定执行什么实现的对象，其中非虚拟方法使用'声明的变量的类型来访问该方法来决定运行哪个...

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

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. 

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

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

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

如果您调用非虚拟方法，（无论继承更改实际对象的类型可能有多远），编译器都会访问变量声明类型的方法表。该表在链中的任何派生类型中没有。

Answer 5

我是这样理解的

A 是基类
B 继承 A 但不覆盖它
C 继承 B 但确实覆盖它

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