目录：

一、抽象类

二、接口

三、抽象类和接口的使用

四、类和接口的区别

五、覆盖与隐藏

一、 抽象类：

用abstract修饰的类叫抽象类。抽象类是特殊的类，只是不能被实例化；除此以外，具有类的其他特性；重要的是抽象类可以包括抽象方法，这是普通类所不能的。抽象方法只能声明于抽象类中，且不包含任何实现，派生类必须覆盖它们。

用abstract修饰的方法叫抽象方法。abstract 修饰符可以和类、方法、属性、索引器及事件一起使用。一个抽象方法只包含方法头而且没有实现代码。当一个类有一个或多个抽象方法时，此类本身必须声明为abstact。一个抽象类不能实例化．因为它包含有没有实现的方法。

在类声明中使用 abstract 修饰符以指示某个类只能是其他类的基类。标记为抽象或包含在抽象类中的成员必须通过从抽象类派生的类来实现。

另外，抽象类可以派生自一个抽象类，可以覆盖基类的抽象方法也可以不覆盖，如果不覆盖，则其派生类必须覆盖它们。

二、接口：

接口是引用类型的，类似于类，更和抽象类有所相似，以至于很多人对抽象类和接口的区别比较模糊。和抽象类的相似之处有三点：

1、不能实例化；
2、包含未实现的方法声明；
3、派生类必须实现未实现的方法，抽象类是抽象方法，接口则是所有成员（不仅是方法包括其他成员）；另外，接口有如下特性：

接口除了可以包含方法之外，还可以包含属性、索引器、事件，而且这些成员都被定义为公有的。除此之外，不能包含任何其他的成员，例如：常量、域、构造函数、析构函数、静态成员。
一个类可以直接继承多个接口，但只能直接继承一个类（包括抽象类）。

接口实例

 11 public delegate void Del(); 
 22 public interface ITest 
 33 { 
 4   4 //int ?a = null; 
 5   6 int A 
 6  7  { 
 7  8     get; 
 8  9  } 
 9    10 
10  11 void Test(); 
11  12 event Del OnDel; 
12  13 int this[int index] 
13  14 { 
14    15 get; 
15    16 set; 
16  17 } 
1718 } 

注意！还有另外一种类不能被实例化：
所有构造函数都被标记为private，这种类也是不能被实例化的，严格的说是不能在类外被实例化，可以在此类的内部实例化（这种方式可以用于实现单件设计模式）。注意一点，这样的类也不能够作为基类来继承。

三、抽象类和接口的使用

抽象类用于部分实现一个类，再由用户按需求对其进行不同的扩展和完善；接口只是定义一个行为的规范或规定。
抽象类在组件的所有实现间提供通用的已实现功能；接口创建在大范围全异对象间使用的功能。
抽象类主要用于关系密切的对象；而接口适合为不相关的类提供通用功能。
抽象类主要用于设计大的功能单元；而接口用于设计小而简练的功能块。

例如：

Window窗体可以用抽象类来设计，可以把公有操作和属性放到一个抽象类里，让窗体和对话框继承自这个抽象类，再根据自己的需求进行扩展和完善。
打印操作可以作为一个接口提供给每个需要此功能的窗体，因为窗体的内容不同，就要根据他们自己的要求去实现自己的打印功能。打印时只通过接口来调用，而不用在乎是那个窗体要打印。

-----------------------

四、类和接口有何区别

从书上摘下来的,还是比较好懂的:

1.抽象类是一个不完全的类,需要进一步专业化.接口只是一个行为的规范或规定;
2.接口基本上不具备继承的任何具体特点,它仅仅承诺了能够调用的方法;
3.一个类一次可以实现若干个接口,但是只能扩展一个父类
4.接口可以用于支持回调,而继承并不具备这个特点.
有些直接就是接口与类的区别.第四点我不是很明白......
一个类如果要实现某个接口,除非它实现了该接口中承诺的所有方法,否则(即未实现或者仅仅实现部分方法),该类必须被声明为抽象类.而该类的子类也继承了这一特性.

override和new的区别
new是覆盖override是重载。   
    
“覆盖”并不意味着“删除”   
    
示例：

 1 using   System;   
 2  class   A   
 3  {   
 4        public   void   F()     
 5        {   
 6              Console.WriteLine("A.F");     
 7        }   
 8  }   
 9  class   B:   A   
10  {   
11        new   public   void   F()     
12        {     
13              Console.WriteLine("B.F");     
14        }   
15  }   
16  class   Test   
17  {   
18        static   void   Main()     
19        {   
20              B   b   =   new   B();   
21              b.F();   
22              A   a   =   b;     
23              a.F();   
24        }   
25  }   

输出为  
  B.F  
  A.F   
    
但“重载”意味着“删除”，这就是“覆盖”和“重载”的区别。如下列：

 1using   System;   
 2  class   A   
 3  {   
 4        public   virtual   void   F()     
 5        {   
 6              Console.WriteLine("A.F");     
 7        }   
 8  }   
 9  class   B:   A   
10  {   
11        public   override   void   F()     
12        {     
13              Console.WriteLine("B.F");     
14        }   
15  }   
16  class   Test   
17  {   
18        static   void   Main()     
19        {   
20              B   b   =   new   B();   
21              b.F();   
22              A   a   =   b;     
23              a.F();   
24        }   
25  }   

输出为  
B.F  
B.F

abstract 与 virtual

abstract与virtual: 方法重写时都使用 override 关键字，interface中的方法和abstract方法都要求实现。调用虚方法时，将为重写成员检查该对象的运行时类型。将调用大部分派生类中的该重写成员，如果没有派生类重写该成员，则它可能是原始成员。

virtual标记方法为虚方法

1.可在派生类中以override覆盖此方法
2.不覆盖也可由对象调用
3.无此标记的方法(也无其他标记)，重写时需用new隐藏原方法

virtual 方法

         若一个实例方法的声明中含有 virtual 修饰符，则称该方法为虚拟方法。若其中没有 virtual 修饰符，则称该方法为非虚拟方法。
非虚拟方法的实现是不会变的：无论是在声明它的类的实例上调用该方法还是在派生类的实例上调用，实现都是相同的。与此相反，一个虚拟方法的实现可以由派生类取代。取代所继承的虚拟方法的实现的过程称为重写该方法（第 10.5.4 节）。
在一个虚拟方法调用中，该调用所涉及的那个实例的运行时类型确定了要被调用的究竟是该方法的哪一个实现。在非虚拟方法调用中，相关的实例的编译时类型是决定性因素。准确地说，当在具有编译时类型 C 和运行时类型 R 的实例（其中 R 为 C 或者从 C 派生的类）上用参数列表 A 调用名为 N 的方法时，调用按下述规则处理：
       首先，将重载决策应用于 C、N 和 A，以从在 C 中声明的和由 C 继承的方法集中选择一个特定的方法 M。第 7.5.5.1 节对此进行了描述。

然后，如果 M 为非虚拟方法，则调用 M。否则（M 为虚拟方法），就会调用就 R 而言 M 的派生程度最大的那个实现。对于在一个类中声明的或者由类继承的每个虚拟方法，存在一个就该类而言的派生程度最大的实现。就类 R 而言虚拟方法 M 的派生度最大的实现按下述规则确定：

如果 R 中含有关于 M 的 virtual 声明，则这是 M 的派生程度最大的实现。否则，如果 R 中含有关于 M 的 override 声明，则这是 M 的派生程度最大的实现。否则，就 R 而言 M 的派生程度最大的实现与就 R 的直接基类而言 M 的派生程度最大的实现相同。

下列实例阐释虚拟方法和非虚拟方法之间的区别：

 1using System;
 2class A
 3{
 4   public void F() { Console.WriteLine("A.F"); }
 5   public virtual void G() { Console.WriteLine("A.G"); }
 6}
 7class B: A
 8{
 9   new public void F() { Console.WriteLine("B.F"); }
10   public override void G() { Console.WriteLine("B.G"); }
11}
12class Test
13{
14   static void Main() {
15      B b = new B();
16      A a = b;
17      a.F();
18      b.F();
19      a.G();
20      b.G();
21   }
22}

在该示例中，A 引入一个非虚拟方法 F 和一个虚拟方法 G。类 B 引入一个新的非虚拟方法 F，从而隐藏了继承的 F，并且还重写了继承的方法 G。此例产生输出：
A.F
B.F
B.G
B.G

请注意，语句 a.G() 实际调用的是 B.G 而不是 A.G。这是因为，对调用哪个实际方法实现起决定作用的是该实例的运行时类型（即 B），而不是该实例的编译时类型（即 A）。
由于一个类中声明的方法可以隐藏继承来的方法，因此同一个类中可以包含若干个具有相同签名的虚拟方法。这不会造成多义性问题，因为除派生程度最大的那个方法外，其他方法都被隐藏起来了。在下面的示例中:

 1using System;
 2class A
 3{
 4   public virtual void F() { Console.WriteLine("A.F"); }
 5}
 6class B: A
 7{
 8   public override void F() { Console.WriteLine("B.F"); }
 9}
10class C: B
11{
12   new public virtual void F() { Console.WriteLine("C.F"); }
13}
14class D: C
15{
16   public override void F() { Console.WriteLine("D.F"); }
17}
18class Test
19{
20   static void Main() {
21      D d = new D();
22      A a = d;
23      B b = d;
24      C c = d;
25      a.F();
26      b.F();
27      c.F();
28      d.F();
29   }
30}

C 类和 D 类均含有两个具有相同签名的虚拟方法：A 引入的虚拟方法和 C 引入的虚拟方法。但是，由 C 引入的方法隐藏了从 A 继承的方法。因此，D 中的重写声明所重写的是由 C 引入的方法，D 不可能重写由 A 引入的方法。此例产生输出：
B.F
B.F
D.F
D.F

请注意，通过访问 D 的实例（借助一个派生程度较小的类型，它的方法没有被隐藏起来），可以调用被隐藏的虚拟方法。

五、覆盖与隐藏

覆盖：
覆盖即重写，重写是指重写基类的方法，在基类中的方法必须有修饰符virtual，而在子类的方法中必须指明override。

格式：

基类中：
public virtual void myMethod()
 {
 }
子类中：
public override void myMethod()
 {
 }
重写以后，用基类对象和子类对象访问myMethod()方法，结果都是访问在子类中重新定义的方法，基类的方法相当于被覆盖掉了。

隐藏：

子类重定义父类的方法（函数声明一致），实现重定义只需要加上关键字new；
如果没有添加关键字new,那么编译器将默认添加new；
隐藏的成员是早绑定。