C# override new

• override是指“覆盖”，是指子类覆盖了父类的方法。子类的对象无法再访问父类中的该方法。
• new是指“隐藏”，是指子类隐藏了父类的方法，当然，通过一定的转换，可以在子类的对象中访问父类的方法。

重载

首先重载是指具有相同的方法名，通过改变参数的个数或者参数类型实现同名方法的不同实现。 

覆盖(重写)

重写则是只在继承中，子类通过override关键字修饰方法，实现父类和子类相同方法的不同实现，注意，父类方法必须是用virtual或者abstract关键字修饰的虚方法或者抽象方法，例如：

public class A
{
public virtual void Show()
{
Console.Write(“父类”);
}
}
 
public class B:A
{
public override void Show()
{
Console.Write(“子类”);
}
}
 
public static void Main(string[] args)
{
B sub=new B();
A sup = new B();
sup.Show();
sub.Show();
Console.ReadKey();
} 

输出结果是：子类 子类

隐藏

隐藏则是指在继承中，子类通过在与父类相同方法名之前用new修饰的一个新的方法的定义，如：

public class A
{
public void Show()
{
Console.Write(“父类”);
}
}
 
public class B:A
{
public new void Show()
{
Console.Write(“子类”);
}
}
public static void Main(string[] args)
{
B sub=new B();
A sup = new B();
sup.Show();
sub.Show();
Console.ReadKey();
} 

输出结果为：父类 子类 

注意：new可以不用写也可以成功执行 

由上面的结果可以知道，重写的结果是当进行父类对象在初始化的时候向下转型的时候，该对象将引用的方法是子类重写后的方法，如果是覆盖的话，那么该对象引用的方法依然是父类的方法，也就是说子类的方法和父类的方法没有什么联系。

总结

1）当用子类对象实例化父类的时候，如 A sup = new B()，重写会改变父类方法的功能，即调用子类的功能；覆盖不会改变父类方法的功能，仍然调用父类功能。

2）虚方法、实方法都可以被覆盖（new），抽象方法，接口 不可以。

3）重写（override）：用virtual或者abstract关键字修饰的方法（抽象方法，接口，虚方法），实方法不可以。

4）重写使用的频率比较高，实现多态；覆盖用的频率比较低，用于对以前无法修改的类进行继承的时候。

5)  override可以通过父类的引用调用子类的方法，new只能各自调用各自的方法。Override后，除非你用代码调用父类的方法，不然是不会执行父类的方法。

 因此，可以简单的这么理解，“重写”就是重新实现了父类的方法，而“覆盖”只是把父类中的方法藏了起来，通过父类的引用来调用这个方法的时候，这个被“隐藏”

的方法就被激活了。

virtual修饰的方法为虚方法，暗示其子类最好有自己的实现 

override修饰的方法为重写方法，表示覆盖了基类原有方法的实现

virtual出问题主要是由于声明对象的类和对象实际所属的类不是一个类，一般都是父类和子类的关系。比如：
ClassParent obj = new ClassSub(),这是根源。

virtual和非virtual关键是在运行时候，而不是在编译时候。

1, 如果方法不是virtual的，编译器就使用声明的类对应的类型，也就是说，不是virtual的，在编译时候，就定了

2, 如果方法是Virtual的，然后子类使用了override, 编译器就生产代码。然后，在运行的时候，进行检测，看对象属于哪个类，然后调用这个类的方法。 这个是最常用的方法,基本上所有书上说的就是这个，我就不多此一举了。

3，如果一个父类的方法是virtual,子类不是用override，而是用new来覆盖了，那么运行子类的时候，还是执行声明的类的方法。

首先看下面的代码：

namespace CSharpTest
{
    class C
    {
        public virtual void fun()
        {
            Console.WriteLine("这是一个虚方法");
        }
    }
    class C1 : C
    {
        public override void fun()
        {
            Console.WriteLine("使用override关键字修饰的方法");
        }
    }
    class C2 : C
    {
        public new void fun()
        {
            Console.WriteLine("使用new关键字修饰的方法");
        }
    }

    class Test
    {
        public static void Main()
        {
            C c1 = new C1();
            c1.fun();
            C c2 = new C2();
            c2.fun();
        }
    }
}

猜猜上面的代码输出结果？ 
正确的结果是：

使用override关键字修饰的方法
这是一个虚方法

• 1
• 2

为什么使用关键字new修饰的方法，调用的是父类的方法呢？ 
是不是很奇怪？为什么使用override关键字的子类方法被调用了，而使用new关键字的子类方法没有被调用。 
首先看看override关键字：override方法为从基类继承的成员提供新的实现。以override声明重写的方法被称为被重写的基类方法，被重写的基类方法必须具有与重写方法相同的签名。非虚方法或者静态方法不能被重写，被重写的基类必须是virtual、abstract或者override的。override声明不能改变虚方法的可访问性，override方法和virtual方法必须具有相同的访问级别修饰符。不能使用下列修饰符修饰重写方法：new、static、virtual和abstract。 
new关键字：new修饰符用来明确地隐藏由基类继承而来的成员。要隐藏继承而来的成员，可以在派生类中共用相同的名称并用new修饰符修饰它。 
下面来分析我们的程序： 
c1.fun();因为子类C1使用override关键字重写了父类的方法，基类C和子类C1都具有fun()方法，所以c1.fun()会动态调用C1的fun()方法而不是父类的。 
c2.fun();子类C2使用new关键字隐藏了父类的方法，相当于子类中的fun()方法是直接继承自父类的。而子类中使用new关键字声明的fun()方法是另一个方法，只是恰巧与子类的fun()方法同名而已（是不是有些糊涂了）。所以 c2.fun()会调用父类的fun()方法，要想调用C2的fun(）方法必须吧c2强制转换为C2.

下面看看微软官方的文档解释： 
C# 语言经过专门设计，以便不同库中的基类与派生类之间的版本控制可以不断向前发展，同时保持向后兼容。这具有多方面的意义。例如，这意味着在基类中引入与派生类中的某个成员具有相同名称的新成员在 C# 中是完全支持的，不会导致意外行为。它还意味着类必须显式声明某方法是要重写一个继承方法，还是一个隐藏具有类似名称的继承方法的新方法。 
在 C# 中，派生类可以包含与基类方法同名的方法。 
基类方法必须定义为 virtual。 
如果派生类中的方法前面没有 new 或 override 关键字，则编译器将发出警告，该方法将有如存在 new 关键字一样执行操作。 
如果派生类中的方法前面带有 new 关键字，则该方法被定义为独立于基类中的方法。 
如果派生类中的方法前面带有 override 关键字，则派生类的对象将调用该方法，而不是调用基类方法。 
可以从派生类中使用 base 关键字调用基类方法。 
override、virtual 和 new 关键字还可以用于属性、索引器和事件中。 
默认情况下，C# 方法为非虚方法。如果某个方法被声明为虚方法，则继承该方法的任何类都可以实现它自己的版本。若要使方法成为虚方法，必须在基类的方法声明中使用 virtual 修饰符。然后，派生类可以使用 override 关键字重写基虚方法，或使用 new 关键字隐藏基类中的虚方法。如果 override 关键字和 new 关键字均未指定，编译器将发出警告，并且派生类中的方法将隐藏基类中的方法。

demo1:

在函数的声明中，当有“virtual”修饰的时候，和没有virtual有什么区别呢？最重要的一点就是调用实例的函数是在编译的时候确定还是在运行的时候确定，virtual函数是在运行的时候来确定具体调用哪个类。这个特性是和父子类继承息息相关的。

 这儿有个例子，在网上很多地方被转载，我稍微扩展了一下：

    class A
    {
        public virtual void Func() // 注意virtual,表明这是一个虚拟函数  
        {
            Console.WriteLine("Func In A");
        }
 
        public void Non_virtual()
        {
            Console.WriteLine("Non virtual func in A");
        }
    }
    class B : A // 注意B是从A类继承,所以A是父类,B是子类  
    {
        public override void Func() // 注意override ,表明重新实现了虚函数  
        {
            Console.WriteLine("Func In B");
        }
 
        public void Non_virtual()
        {
            Console.WriteLine("Non virtual func in B");
        }
    }
    class C : B // 注意C是从A类继承,所以B是父类,C是子类  
    {
        public void Non_virtual()
        {
            Console.WriteLine("Non virtual func in C");
        }
    }
    class D : A // 注意D是从A类继承,所以A是父类,D是子类  
    {
        public new void Func() // 注意new ，表明覆盖父类里的同名类，而不是重新实现  
        {
            Console.WriteLine("Func In D");
        }
 
        public new void Non_virtual()
        {
            Console.WriteLine("Non virtual func in D");
        }
    }  
    
    class Program
    {
        static void Main(string[] args)
        {
            A a;         // 定义一个a这个A类的对象.这个A就是a的申明类  
            A b;         // 定义一个b这个A类的对象.这个A就是b的申明类  
            A c;         // 定义一个c这个A类的对象.这个A就是c的申明类  
            A d;         // 定义一个d这个A类的对象.这个A就是d的申明类  
            a = new A(); // 实例化a对象,A是a的实例类  
            b = new B(); // 实例化b对象,B是b的实例类  
            c = new C(); // 实例化c对象,C是c的实例类  
            d = new D(); // 实例化d对象,D是d的实例类  
            a.Func();    // 执行a.Func：1.先检查申明类A 2.检查到是虚拟方法 3.转去检查实例类A，就为本身 4.执行实例类A中的方法 5.输出结果 Func In A  
            b.Func();    // 执行b.Func：1.先检查申明类A 2.检查到是虚拟方法 3.转去检查实例类B，有重写的 4.执行实例类B中的方法 5.输出结果 Func In B  
            c.Func();    // 执行c.Func：1.先检查申明类A 2.检查到是虚拟方法 3.转去检查实例类C，无重写的 4.转去检查类C的父类B，有重载的 5.执行父类B中的Func方法 5.输出结果 Func In B  
            d.Func();    // 执行d.Func：1.先检查申明类A 2.检查到是虚拟方法 3.转去检查实例类D，无重写的（这个地方要注意了，虽然D里有实现Func()，但没有使用override关键字，所以不会被认为是重写） 4.转去检查类D的父类A，就为本身 5.执行父类A中的Func方法 5.输出结果 Func In A  
            D d1 = new D();
            d1.Func(); // 执行D类里的Func()，输出结果 Func In D  
 
            a.Non_virtual(); //执行A类的Non_virtual 输出 Non virtual func in A
            b.Non_virtual(); //执行A类的Non_virtual 输出 Non virtual func in A
            c.Non_virtual(); //执行A类的Non_virtual 输出 Non virtual func in A
            d.Non_virtual(); //执行A类的Non_virtual 输出 Non virtual func in A
            d1.Non_virtual(); //执行D类的Non_virtual 输出 Non virtual func in D
 
            Console.ReadLine();  
        }
    }

具体在检查的时候，遵循的规则，已经有人在网上做了很详细的阐述，我在这里引用一下：

虚拟函数从C#的程序编译的角度来看，它和其它一般的函数有什么区别呢？一般函数在编译时就静态地编译到了执行文件中，其相对地址在程序运行期间是不发生变化的，也就是写死了的！而虚函数在编译期间是不被静态编译的，它的相对地址是不确定的，它会根据运行时期对象实例来动态判断要调用的函数，其中那个申明时定义的类叫申明类，那个执行时实例化的类叫实例类。

如：飞禽 bird = new 麻雀();
那么飞禽就是申明类，麻雀是实例类。

具体的检查的流程如下

1、当调用一个对象的函数时，系统会直接去检查这个对象申明定义的类，即申明类，看所调用的函数是否为虚函数；

2、如果不是虚函数，那么它就直接执行该函数。而如果有virtual关键字，也就是一个虚函数，那么这个时候它就不会立刻执行该函数了，而是转去检查对象的实例类。

3、在这个实例类里，他会检查这个实例类的定义中是否有重新实现该虚函数（通过override关键字），如果是有，那么OK，它就不会再找了，而马上执行该实例类中的这个重新实现的函数。而如果没有的话，系统就会不停地往上找实例类的父类，并对父类重复刚才在实例类里的检查，直到找到第一个重载了该虚函数的父类为止，然后执行该父类里重载后的函数。

在上面的规则中，可以看到，如果子类没有override的修饰，那么就算父类是virtual的方法，子类的方法也无法被调用，而会去它的父类中找override的方法，直到找到祖先类。所以在面向对象的开发过程中，如果要实现Dependency Injection、IoC等设计模式，就必须非常留意类设计中继承方法的声明，否则很可能导致实际的程序运行与预期不符。

demo2:

virtual出问题主要是由于声明对象的类和对象实际所属的类不是一个类，一般都是父类和子类的关系。比如：
ClassParent obj = new ClassSub(),这是根源。

virtual和非virtual关键是在运行时候，而不是在编译时候。

1, 如果方法不是virtual的，编译器就使用声明的类对应的类型，也就是说，不是virtual的，在编译时候，就定了。

2, 如果方法是Virtual的，然后子类使用了override, 编译器就生产代码。然后，在运行的时候，进行检测，看对象属于哪个类，然后调用这个类的方法。 

3，如果一个父类的方法是virtual,子类不是用override，而是用new来覆盖了，那么运行子类的时候，还是执行声明的类的方法。

demo3:

new在用作修饰符时，new关键字可以在派生类中隐藏基类的方法，也就说在使用派生类的方法是调用的方法是New关键字新定义出来的方法，而不是基类的方法。在不使用New关键字来隐藏基类方法也是可以的，编译器会出现一个警告，提示如果有意去隐藏基类的方法，请使用New关键字修饰。

    这里有个注意事项就是New和Override这两个关键字是互斥的。不可以同时使用。

    二、Override

    Override关键字主要是提供派生类对基类方法的新实现，重写的基类方法必须和Override的方法具有相同的签名，此关键字不可以用于重写非虚方法和静态方法，与其配套使用的关键字是Virtual、abstract、Override。与此同时，Override方法还不可以修改Virtual方法的可访问性，Override方法和Virtual方法必须具有相同的访问修饰符，不能使用修饰符 new、static、virtual 或abstract 来修改 override 方法。

Virtual 关键字允许在派生类中重写这些对象，默认情况下，方法是非虚拟的，不可以重写非虚方法，virtual关键字不可以与static、abstract、private、override一起使用。Virtual关键字又是和override紧密不可分的，如果要实现Virtual方法就必须要使用override或new关键字（new和override产生的机理不同）。

    New关键字主要用来区别派生类和基类同名方法的选择问题，通过隐藏基类方法，达到使编译器调用正确的方法的目的。Override主要用来对基类的方法和虚方法进行重写。

deme3:

1. abstract 修饰符指示所修饰的内容缺少实现或未完全实现。 abstract 修饰符可用于类、方法、属性、索引器和事件。在类声明中使用abstract修饰符以指示某个类只能是其他类的基类。标记为抽象或包含在抽象类中的成员必须通过从抽象类派生的类来实现。

(1)抽象类具有以下特性：

1) 抽象类不能实例化。

2) 抽象类可以包含抽象方法和抽象访问器。

3) 不能用 sealed 修饰符修饰抽象类，因为这两个修饰符的含义是相反的。采用 sealed 修饰符的类无法继承，而 abstract 修饰符要求对类进行继承。

4) 从抽象类派生的非抽象类必须包括继承的所有抽象方法和抽象访问器的实际实现。

5) 在方法或属性声明中使用 abstract 修饰符以指示方法或属性不包含实现。

(2)抽象方法具有以下特性：

1) 抽象方法是隐式的虚方法。

2) 只允许在抽象类中使用抽象方法声明。

3) 因为抽象方法声明不提供实际的实现，所以没有方法体；方法声明只是以一个分号结束，并且在签名后没有大括号 ({ })。

(3)在抽象方法声明中使用 static 或 virtual 修饰符是错误的。除了在声明和调用语法上不同外，抽象属性的行为与抽象方法一样。在静态属性上使用abstract修饰符是错误的。在派生类中，通过包括使用 override 修饰符的属性声明，可以重写抽象的继承属性。

2. virtual关键字用于修饰方法、属性、索引器或事件声明，并使它们可以在派生类中被重写。虚拟成员的实现可由派生类中的重写成员更改。调用虚方法时，将为重写成员检查该对象的运行时类型。将调用大部分派生类中的该重写成员，如果没有派生类重写该成员，则它可能是原始成员。默认情况下，方法是非虚拟的。不能重写非虚方法。virtual 修饰符不能与 static、abstract, private 或 override 修饰符一起使用。和抽象方法的相同点是都用了override关键字进行重写方法，不同点是抽象方法必须存在于抽象类中，而子类必须重写，除非子类也是抽象的。

3.override 方法提供从基类继承的成员的新实现。由 override 声明重写的方法称为重写基方法。重写的基方法必须与 override 方法具有相同的签名。不能重写非虚方法或静态方法。重写的基方法必须是 virtual、abstract 或 override 的。 override 声明不能更改 virtual 方法的可访问性。 override 方法和 virtual 方法必须具有相同的访问级别修饰符。重写属性声明必须指定与继承属性完全相同的访问修饰符、类型和名称，并且被重写的属性必须是 virtual、abstract 或 override 的。

4. base和this的区别

1)base作用：用于从派生类中访问基类的成员，调用基类上已被其他方法重写的方法。指定创建派生类实例时应调用的基类构造函数。

注：从静态方法中使用 base 关键字是错误的。
2）区别：

base 是子类中引用父类，用于在派生类中访问重写的基类成员。
this 是当前类，引用自己，用于访问本类的成员，当然也包括继承而来公有和保护成员。

3）注意：
a).在静态成员中使用base和this都是不允许的。原因是，base和this访问的都是类的实例，也就是对象，而静态成员只能由类来访问，不能由对象来访问。 
b).base是为了实现多态而设计的。 
c).使用this或base关键字只能指定一个构造函数，也就是说不可同时将this和base作用在一个构造函数上。
d).除了base，访问基类成员的另外一种方式是：显示的类型转换来实现。只是该方法不能为静态方法。