Question

我对OOP的一些概念感到困惑：virtual，override，new和sealed override。任何人都可以解释这些差异吗？

我很清楚，如果要使用派生类方法，可以使用override关键字，以便派生类重写基类方法。但我不确定new和sealed override。

Answer 1

虚拟关键字用于修改方法，属性，索引器或事件声明，并允许在派生类中重写它。例如，任何继承它的类都可以覆盖此方法：使用new修饰符显式隐藏从基类继承的成员。要隐藏继承的成员，请使用相同的名称在派生类中声明它，并使用new修饰符对其进行修改。

这与多态性有关。在引用上调用虚方法时，引用引用的对象的实际类型用于决定使用哪种方法实现。当在派生类中重写基类的方法时，即使调用代码没有“知道”该对象是派生类的实例，也会使用派生类中的版本。例如：

public class Base
{
  public virtual void SomeMethod()
  {
  }
}

public class Derived : Base
{
  public override void SomeMethod()
  {
  }
}

...

Base d = new Derived();
d.SomeMethod();

最终会调用Derived.SomeMethod，如果它重写Base.SomeMethod。

现在，如果您使用 new 关键字而不是覆盖，派生类中的方法不会覆盖基类中的方法，它只会隐藏它。在这种情况下，代码如下：

public class Base
{
  public virtual void SomeOtherMethod()
  {
  }
}

public class Derived : Base
{
  public new void SomeOtherMethod()
  {
  }
}

...


Base b = new Derived();
Derived d = new Derived();
b.SomeOtherMethod();
d.SomeOtherMethod();

首先调用Base.SomeOtherMethod，然后调用Derived.SomeOtherMethod。它们实际上是两个完全独立的方法，它们碰巧具有相同的名称，而不是覆盖基本方法的派生方法。

如果未指定new或覆盖，则结果输出与指定new相同，但您也会收到编译器警告（因为您可能不知道您正在隐藏方法基类方法，或者你可能想要覆盖它，只是忘了包含关键字）。

重写属性声明可能包含密封修饰符。使用此修饰符可防止派生类进一步覆盖该属性。密封财产的存取也是密封的。

Answer 2

任何方法都可以覆盖（= virtual）或不覆盖。该决定由定义该方法的人做出：

class Person
{
    // this one is not overridable (not virtual)
    public String GetPersonType()
    {
        return "person";
    }

    // this one is overridable (virtual)
    public virtual String GetName()
    {
        return "generic name";
    }
}

现在您可以覆盖那些可覆盖的方法：

class Friend : Person
{
    public Friend() : this("generic name") { }

    public Friend(String name)
    {
        this._name = name;
    }

    // override Person.GetName:
    public override String GetName()
    {
        return _name;
    }
}

但是你不能覆盖GetPersonType方法，因为它不是虚拟的。

让我们创建这两个类的两个实例：

Person person = new Person();
Friend friend = new Friend("Onotole");

当GetPersonType实例调用非虚方法Fiend时，它实际上是Person.GetPersonType：

Console.WriteLine(friend.GetPersonType()); // "person"

当GetName实例调用虚拟方法Friend时，调用它为Friend.GetName：

Console.WriteLine(friend.GetName()); // "Onotole"

当GetName实例调用虚拟方法Person时，调用它为Person.GetName：

Console.WriteLine(person.GetName()); // "generic name"

当调用非虚方法时，不查找方法体 - 编译器已经知道需要调用的实际方法。而使用虚方法时，编译器无法确定调用哪一个，并且在类层次结构中的运行时从上到下查找，从调用该方法的实例类型开始：对于friend.GetName它从Friend类开始查找并立即找到它，对于person.GetName类，它从Person开始并在那里找到它。

有时你创建一个子类，覆盖一个虚方法，你不希望在层次结构中再次覆盖 - 你使用sealed override（说你是最后一个覆盖该方法的人）：< / p>

class Mike : Friend
{
    public sealed override String GetName()
    {
        return "Mike";
    }
}

但有时你的朋友迈克决定改变他的性别，因此他的名字改为爱丽丝:)你可以改变原始代码，或者代替迈克迈克：

class Alice : Mike
{
    public new String GetName()
    {
        return "Alice";
    }
}

在这里，您可以使用相同的名称创建一个完全不同的方法（现在您有两个）。调用哪种方法和时间？这取决于你如何称呼它：

Alice alice = new Alice();
Console.WriteLine(alice.GetName());             // the new method is called, printing "Alice"
Console.WriteLine(((Mike)alice).GetName());     // the method hidden by new is called, printing "Mike"

当您从Alice的角度拨打电话时，您拨打Alice.GetName，从Mike开始拨打电话Mike.GetName。这里没有进行运行时查找 - 因为两种方法都是非虚拟的。

您始终可以创建new方法 - 您隐藏的方法是否为虚拟方式。

这也适用于属性和事件 - 它们表示为下面的方法。

Answer 3

默认情况下，除非声明virtual或abstract，否则无法在派生类中重写该方法。 virtual表示在调用之前检查更新的实现，abstract表示相同，但保证在所有派生类中重写。此外，基类中不需要实现，因为它将在其他地方重新定义。

以上例外是new修饰符。可以使用派生类中的virtual修饰符重新定义未声明为abstract或new的方法。当在基类中调用该方法时，执行基本方法，并且在派生类中调用时，执行新方法。所有new关键字允许您在类层次结构中使用两个具有相同名称的方法

。

最后，sealed修饰符会破坏virtual方法链并使它们不再可覆盖。这不经常使用，但选项就在那里。通过一个由前一个派生的3个类的链来更有意义

A -> B -> C

如果A具有virtual或abstract方法，即overridden中的B，那么它还可以防止C更改它再次在sealed中声明B。

sealed也用于classes，您通常会遇到此关键字。

我希望这会有所帮助。

Answer 4

 public class Base 
 {
   public virtual void SomeMethod()
   {
     Console.WriteLine("B");
   }
  }

public class Derived : Base
{
   //Same method is written 3 times with different keywords to explain different behaviors. 


   //This one is Simple method
  public void SomeMethod()
  {
     Console.WriteLine("D");
  }

  //This method has 'new' keyword
  public new void SomeMethod()
  {
     Console.WriteLine("D");
  }

  //This method has 'override' keyword
  public override void SomeMethod()
  {
     Console.WriteLine("D");
  }
}

现在第一件事

 Base b=new Base();
 Derived d=new Derived();
 b.SomeMethod(); //will always write B
 d.SomeMethod(); //will always write D

现在关键字都是关于多态的

 Base b = new Derived();

在基类中使用virtual并在Derived中覆盖将赋予D（多态）。
在override中使用不virtual的{{1}}会出错。
同样地用Base写一个方法（没有覆盖）会写出＆＃39; B＆＃39;警告（因为没有进行多态）。
要隐藏此警告，请在virtual中的简单方法前面写上new。{/ li>
Derived关键字是另一个故事，它只是隐藏警告，告诉基类中有相同名称的属性。
new或virtual两者相同 new modifier
new和new不能在相同的方法或属性之前使用。
override在任何类或方法锁定它以在Derived类中使用之前它会产生编译时错误。

虚拟，覆盖，新密封和密封覆盖之间的区别

4 个答案: