接口

1.接口只提供方法规约，不提供方法体；

2.接口中的方法不能用关键字修饰；

3.接口里不能有接口和变量；

4.接口里的方法在子类中必须全部实现；

5.接口可以实现多重继承；

抽象类

1.抽象类可以从接口继承；

2.抽象类中的实体方法在子类中不可以重写，只可以被引用；

3.抽象类中的抽象方法不可以有方法体，抽象类中的抽象方法在子类中必须重写；

4.抽象类中的虚方法在子类中可以选择性的重写；

虚方法

1.可以在子类选择性的重写；

2.不重写也可被子类调用；

接口与抽象类的异同

1.抽象类的抽象方法和接口内的方法，在子类中必须全部被实现；

2.抽象方法和接口中的方法都不可以有方法体；

抽象方法与虚方法的异同

1.抽象方法所在的类必须是抽象类，虚方法可以在任何类里；

2.抽象方法必须被重写，虚方法的重写有选择性；

3.抽象方法不可以被子类调用，虚方法可以被子类调用；

4.抽象方法不可以有方法体，虚方法必须有方法体

C#抽象类和接口孩子间在对于抽象类定义的支持方面具有很大的相似性，甚至可以相互替换，因此很多开发者在进行抽象类定义时对于抽象类和接口的选择显得比较随意。其实，两者之间还是有很大区别的。

首先说一下接口与抽象类的异同：

相同点：

1.他们都不能实例化自己，也就是说都是用来被继承的。

2.抽象类中的抽象方法和接口方法一样，都不能有方法体

不同点：

1.抽象类里可以有字段，接口中不能有字段.

2.抽象类中的普通方法可以有方法体，而接口方法没有方法体。

3.接口中的方法不能有访问修饰符，抽象类中的抽象方法被继承，需要override重写 .

4.接口更像是一种规范，一种约束。

5.一个子类只能继承一个抽象类，但却可以继承多个接口。

接下来是抽象方法和虚方法的异同：

其实可以把抽象方法看做是没有方法体的虚方法。

相同点：

1.抽象方法和虚方法都可以被重写。

不同点：

1.abstract 和virtual的关键字不同

2.抽象方法一定没有方法体，而虚方法可以有方法体。

下面写个例子说明一下：

1. /// <summary>  
2. /// 一个手机的抽象类  
3. /// </summary>  
4. public abstract class Mobilephone   
5. {  
6. private string _logo;  
7. public string Logo  
8. {  
9. get { return _logo; }  
10. set { _logo = value; }  
11. }  
12. public abstract void Call();  
13. public virtual void Callagain()   
14. {  
15. Console.WriteLine("我再打一个电话");  
16. }  
17. }  
18. /// <summary>  
19. /// 定义一个实体类，继承了一个抽象类及多个接口  
20. /// </summary>  
21. public class Nokia :Mobilephone,IClock,Ilistenmusic  
22. {  
23. public override void Call()  
24. {  
25. Console.WriteLine("NOKIA打电话没问题");  
26. }  
27. public void clock()  
28. {  
29. Console.WriteLine("NOKIA的手机也有闹钟功能");  
30. }  
31. public void listenmusic()  
32. {  
33. Console.WriteLine("NOKIA的手机还能听歌");  
34. }  
35. public override void Callagain()   
36. {  
37. Console.WriteLine("算了，还是不打了");  
38. }  
39. }  
40. /// <summary>  
41. /// 下面定义了两个接口，为了说明可以继承多个接口  
42. /// </summary>  
43. public interface Ilistenmusic   
44. {  
45. void listenmusic();  
46. }  
47. public interface IClock   
48. {  
49. void clock();  
50. }  

在补充一个小例子，

这里有到很有意思的面试题，说名了new关键字和override的区别:

1. class Program   
2. {   
3. static void Main(string[] args)   
4. {   
5. B5 b5 = new B5();   
6. b5.MethodB();   
7. }   
8. }   
9. public class A5   
10. {   
11. public virtual void MethodA()   
12. {   
13. Console.WriteLine("A5.MethodA");   
14. Console.Read();   
15. }   
16. public virtual void MethodB()   
17. {   
18. MethodA();   
19. }   
20. }   
21. public class B5 :A5   
22. {   
23. public new void MethodA()   
24. {   
25. Console.WriteLine("B5.MethodA");   
26. Console.ReadLine();   
27. }   
28. }   
29. class Program  
30. {  
31. static void Main(string[] args)  
32. {  
33. B5 b5 = new B5();  
34. b5.MethodB();  
35. }  
36. }  
37. public class A5  
38. {  
39. public virtual void MethodA()  
40. {  
41. Console.WriteLine("A5.MethodA");  
42. Console.Read();  
43. }  
44. public virtual void MethodB()  
45. {  
46. MethodA();  
47. }  
48. }  
49. public class B5 :A5  
50. {  
51. public new void MethodA()   
52. {  
53. Console.WriteLine("B5.MethodA");  
54. Console.ReadLine();  
55. }  
56. }  

最后的答案是:"A5.MethodA"

接口 抽象类 虚方法 三者比较-1