关于override 与new 重写父类虚方法的一些看法（new与virtual共存）

先唠叨几点，把思路理清楚：

1.抽象类方法和虚方法都可以重写，但是我们专业的说：我们把抽象方法“实现”了，我们把 虚方法 “重写”了

2.抽象类没有实例，所以抽象方法也不能被直接调用（没有方法体）并且可以实现，抽象类可以写虚方法并且可以重写

3.虚方法可以再非抽象类与 抽象类内存在，虚方法在非抽象类里存在并且可以被实例调用

4.override 与重载是2个概念，重写与重载 在字面上就不同

5.override 在派生类重写父类方法的时候，凡是调用这个方法，我不管是直接调用这个方法，还是通过方法调用方法，他都是调用的重写的方法。

6.new 注意：条件 当派生类与父类的方法名 一样的时候存在，不然会报错（你用new 一个父类不存在的方法，那是无意义的）

7.new 用了，new是新的意思，只要生成了一个独立于父类的方法，把父类的方法隐藏了，这个方法必然是与父类的方法同名，那么派生类的这个方法与父类的这个方法，虽然字面上一样，但是他们没有半点关系，是相互独立的。但是可以调用父类的方法。

 

下面结合案例来分析：

class Test
    {
static void Main()
        {
            Father father = new Father();
            father.Speaking1();//The Father Method
            father.Speaking2();//The Father Method

            Child child = new Child();
            child.Speaking1();//The Child Method
            child.Speaking2();//The Child Method
        }
    }
class Father
    {
public virtual void Speaking1()
        {
            Console.WriteLine("The Father Method ");
        }

public virtual void Speaking2()
        {
            Speaking1();
        }
    }

class Child:Father
    {
public override void Speaking1()
        {
            Console.WriteLine("The Child Method");
        }
    }

override的情况：

1.当重写饿了speaking1,不管是怎么调用这个方法，是直接调用，还是通过方法再调用，都是调用的重写的方法

new的情况：

 Father father = new Father();
            father.Speaking1();//The Father Method
            father.Speaking2();//The Father Method

            Child child = new Child();
            child.Speaking1();//The Child Method
            child.Speaking2();//The Father Method  不同了

new之后，speaking1 方法独立了，通过speaking2方法调用的时候，它是调用了Father的方法。

 

注：如果使用了new，但是这个方法父类没有，那么会提示“不会隐藏继承的成员，不需要使用new”

new:虽然new隐藏了父类的方法，但是可以调用父类的方法

 class Test
    {
static void Main()
        {


            Child child = new Child();
            child.Speaking1();// The Father Method  The Child Method
            child.Speaking2();//The Father Method
        }
    }
class Father
    {
public virtual void Speaking1()
        {
            Console.WriteLine("The Father Method ");
        }

public virtual void Speaking2()
        {
            Speaking1();
        }
    }

class Child:Father
    {
public new void Speaking1()
        {
base.Speaking1();
            Console.WriteLine("The Child Method");
        }
    }

 

关于new与virtual共同存在：

 class Test
    {
static void Main()
        {


            Third third = new Third();
            third.Speaking2();//The Father Method
            third.Speaking1();//The Third Method



        }
    }
class Father
    {
public virtual void Speaking1()
        {
            Console.WriteLine("The Father Method ");
        }

public virtual void Speaking2()
        {
            Speaking1();
        }
    }

class Child:Father
    {
public new virtual void Speaking1()
        {
base.Speaking1();
            Console.WriteLine("The Child Method");
        }
    }

class Third : Child
    {
public override void Speaking1()
        {
            Console.WriteLine("The Third Method");
        }
    }

分析：

 

1.因为Third类重写的是Child类的speaking1方法（继承于child的方法而不是Father的方法）：（与Child类似，与基类的speaking1是独立的方法）

注：基类的virtual无法扩展到new的方法上。（因为他们是独立的）

third.Speaking2();调用基类的speaking2方法里的speaking1是基类的方法

转载于:https://www.cnblogs.com/IAmBetter/archive/2011/12/27/2303664.html