你所举的第二个例子掩盖了母子的“GetData”,它并没有推翻它。

例:

private class Base
{
    public virtual void Test()
    {
        Console.WriteLine("Base");
    }

    public void Test2()
    {
        Console.WriteLine("Base");
    }
}

private class Derived : Base
{
    public override void Test()
    {
        Console.WriteLine("Derived");
    }

    public void Test2()
    {
        Console.WriteLine("Derived");
    }
}

static void Main()
{
    Base b = new Base();
    Derived d = new Derived();
    Base dInB = new Derived();

    b.Test();
    d.Test();
    dInB.Test();

    b.Test2();
    d.Test2();
    dInB.Test2();

    Console.ReadKey(true);
}

产出:

Base    // Base.Test()
Derived // Derived.Test()
Derived // Derived.Test()
Base    // Base.Test2()
Derived // Derived.Test2()
Base    // You think you re calling Derived.Test2(), but you actually call Base.Test2()

实际上,该样本无效,因为它应当使用<代码>new,关键词载于public new void Test2( in the Derived category。

它与运营商超负荷运作一样。 这实际上并不凌驾于任何东西之上。 当您有准确的类型<代码> 衍生出时,则采用新的方法。

www.un.org/Depts/DGACM/index_spanish.htm 你们必须真正谨慎地与隐蔽的成员打交道,这根本不像压倒一切(阶级)或执行(内部)。 只有当您具备<><>>>>>>> >> > > >。 字母缩略语 method,否则就仍然指基型方法!

不同之处在于,在第一个案例中,你是压倒一切的,在第二种情况下,你藏匿起来完全不同。

在第一个案件中:

class B: A
{
    void Foo()
    {
        B b = new B();
        A a = b;

        a.GetData() //B s GetData() will be called
        b.GetData() //B s GetData() will be called
    }
}

另一方面,第二起案件:

class B: A
{
    void Foo()
    {
        B b = new B();
        A a = b;

        a.GetData() //A s GetData() will be called
        b.GetData() //B s GetData() will be called
    }
}

在第二种情况下,你只是躲藏了GetData(GetData)(A)的实施,但是,即使变数指的是B类,你总是能够通过一个变式的A来指执行。

public class A
{
    public virtual string GetData() { return "A";}
}

public class B : A
{
    public override string GetData() { return "B"; }
}

如果你在使用下面的24个班级,你会有什么期望?

        A a = new A();
        B b = new B();
        A c = new B();

        Console.WriteLine(a.GetData());
        Console.WriteLine(b.GetData());
        Console.WriteLine(c.GetData());

这将印刷“A”“B”“B”。 变数c被储存为A类,但在实施该方法时,该代码被“实际”执行。 (见虚拟职能表和解决原则的角度)

如果你不像以下代码那样使用虚拟和压倒性,将印刷“A”“B”“A”。

public class A
{
    public string GetData() { return "A";}
}

public class B : A
{
    public new string GetData() { return "B"; }
}