C#中接口和抽象类的区别

Posted 2020-06-17

什么是接口？

    用来定义一种程序的协定。实现接口的类或者结构要与接口的定义严格一致。有了这个协定，就可以抛开编程语言的限制（理论上）。C#接口可以从多个基接口继承，而类或结构可以实现多个接口。C#接口可以包含方法、属性、事件和索引器。接口本身不提供它所定义的成员的实现。接口只指定实现该接口的类或接口必须提供的成员。

 如何使用接口？

例如：

 

1. <span style="font-family:KaiTi_GB2312;">using System;  
2. using System.Collections.Generic;  
3. using System.Linq;  
4. using System.Text;  
5.   
6. namespace 用了抽象模式的数据访问程序  
7. {  
8.     class Program  
9.     {  
10.         static void Main(string[] args)  
11.         {  
12.             User user = new User();  
13.             Department dept = new Department();  
14.   
15.             //Ifactory factory =new SqlserverFactory();  
16.             IFactory factory = new AccessFactory();  
17.               
18.             //此时已经与具体的数据库访问解除了依赖  
19.             IUser iu = factory.CreateUser();  
20.   
21.             iu.Insert(user);  
22.             iu.GetUser(1);  
23.   
24.             IDepartment id = factory.CreateDepartment();  
25.   
26.             id.Insert(dept);  
27.             id.GetDepartment(1);  
28.   
29.             Console.Read();  
30.   
31.         }  
32.     }  
33.   
34.   
35.     class User  
36.     {  
37.         private int id;  
38.         public int ID  
39.         {  
40.             get { return id; }  
41.             set { id = value; }  
42.         }  
43.   
44.     }  
45.   
46.     class Department  
47.     {  
48.         private int id;  
49.         public int ID  
50.         {  
51.             get { return id; }  
52.             set { id = value; }  
53.         }  
54.   
55.           
56.     }  
57.     //IDepartment接口，用于客户端访问，解除与具体数据库访问的耦合。  
58.     interface IDepartment  
59.     {  
60.         void Insert(Department department);  
61.   
62.         Department GetDepartment(int id);  
63.     }  
64.   
65.     //SqlserverDepartment类，用于访问SQL Server的Department  
66.     class SqlserverDepartment : IDepartment  
67.     {  
68.         public void Insert(Department department)  
69.         {  
70.             Console.WriteLine("在SQL Server 中给Department表增加一条记录");  
71.         }  
72.   
73.         public Department GetDepartment(int id)  
74.         {  
75.             Console.WriteLine("在SQL Server 中根据ID得到Department表一条记录");  
76.             return null;  
77.         }  
78.       
79.     }  
80.   
81.     //Access类，用于访问Access的Department  
82.     class AccessDepartment : IDepartment  
83.     {  
84.         public void Insert(Department department)  
85.         {  
86.             Console.WriteLine("在Access 中给Department表增加一条记录");  
87.         }  
88.   
89.         public Department GetDepartment(int id)  
90.         {  
91.             Console.WriteLine("在Access中根据ID得到Department表一条记录");  
92.             return null;  
93.         }  
94.   
95.     }  
96.   
97.     //IUser接口,用于客户端访问,解除与具体数据库访问的耦合  
98.     interface IUser  
99.     {  
100.         void Insert(User user);  
101.         User GetUser(int id);  
102.     }  
103.   
104.     //SqlserverUser类，用于访问SQL Server的User  
105.     class SqlserverUser : IUser  
106.    {  
107.         public void Insert(User user)  
108.         {  
109.             Console.WriteLine("在SQL Server 中给User表增加一条记录");  
110.         }  
111.   
112.         public User GetUser(int id)  
113.         {  
114.             Console.WriteLine("在SQL Server中根据ID得到User表一条记录");  
115.             return null;  
116.         }  
117.   
118.     }  
119.   
120.     //Access类，用于访问Access的User  
121.     class AccessUser : IUser  
122.     {  
123.         public void Insert(User user)  
124.         {  
125.             Console.WriteLine("在Access中给User表增加一条记录");  
126.   
127.         }  
128.         public User GetUser(int id)  
129.         {  
130.             Console.WriteLine("在Access中根据得到User表一条记录");  
131.             return null;  
132.         }  
133.     }  
134.   
135.     //IFactory 接口，定义一个创建访问Department表对象的抽象的工厂接口  
136.   
137.     interface IFactory  
138.     {  
139.         IUser CreateUser();  
140.   
141.         //增加的接口方法  
142.         IDepartment CreateDepartment();  
143.     }  
144.   
145.     //SqlServerFactory类，实现IFactory接口，实例化SqlserverUser和SqlserverDepartment  
146.   
147.     class SqlserverFactory : IFactory  
148.     {  
149.         public IUser CreateUser()  
150.         {  
151.             return new SqlserverUser();  
152.   
153.         }  
154.   
155.         public IDepartment CreateDepartment()  
156.         {  
157.             return new SqlserverDepartment();  
158.         }  
159.     }  
160.   
161.     //AccessFactory类，实现IFactory接口，实例化AccessUser和AccessDepartment  
162.   
163.     class AccessFactory : IFactory  
164.     {  
165.         public IUser CreateUser()  
166.         {  
167.             return new AccessUser();  
168.   
169.         }  
170.   
171.         public IDepartment CreateDepartment()  
172.         {  
173.             return new AccessDepartment();  
174.         }  
175.     }  
176. }  
177. </span>  

 什么是抽象类？

     抽象类是包含抽象方法的类。那么什么又是抽象方法呢？抽象方法是没有方法内容的，只有一个方法名和参数列表的方法。并以；结尾。为了标注他的与众不同，在他的返回类型前加abstract。并在class前加abstract。

简言之，由abstract修饰的方法和类就是抽象的方法和类。

 如何使用抽象类，抽象方法，和怎样实现抽象方法？

 例如：

[html] view plain copy

 

1. <span style="font-size:18px;"><span style="font-family:KaiTi_GB2312;">using System;  
2. using System.Collections.Generic;  
3. using System.Linq;  
4. using System.Text;  
5.   
6. namespace 状态模式结构图  
7. {  
8.     class Program  
9.     {  
10.         static void Main(string[] args)  
11.         {  
12.             //设置Context的初始状态为ConcreteStateA  
13.             Context c = new Context(new ConcreteStateA());  
14.   
15.             //不断的请求，同时更新状态  
16.             c.Request();  
17.             c.Request();  
18.             c.Request();  
19.             c.Request();  
20.   
21.             Console.Read();  
22.         }  
23.     }  
24.   
25.     //Context类，维护一个COncreteState子类的实例，这个实例定义当前的状态  
26.     class Context  
27.     {  
28.         private State state;  
29.           
30.         //定义Context的初始状态  
31.         public Context(State state)  
32.         {  
33.             this.state = state;  
34.   
35.         }  
36.   
37.         //可读写的状态属性，用于读取当前状态和设置新状态  
38.         public State State  
39.         {  
40.             get { return state; }  
41.             set  
42.             {  
43.                 state = value;  
44.                 Console.WriteLine("当前状态：" + state.GetType().Name);  
45.             }  
46.         }  
47.   
48.         //对请求做处理，并设置下一状态  
49.         public void Request()  
50.         {  
51.             state.Handle(this);  
52.         }  
53.   
54.     }  
55.     //抽象状态类State，定义一个接口以封装与Context的一个特定状态相关的行为  
56.     abstract class State  
57.     {  
58.         public abstract void Handle(Context context);  
59.     }  
60.   
61.     //ConcreteState类，具体状态，每一个子类实现一个与Context的一个状态相关的行为  
62.     class ConcreteStateA : State  
63.     {  
64.         public override void Handle(Context context)  
65.         {  
66.             //设置ConcreteStateA的下一个状态是ConcreteStateB  
67.             context.State = new ConcreteStateB();  
68.         }  
69.     }  
70.   
71.     class ConcreteStateB : State  
72.     {  
73.         public override void Handle(Context context)  
74.         {  
75.             //设置ConcreteStateB的下一个状态是ConcreteStateA  
76.             context.State = new ConcreteStateA();  
77.         }  
78.           
79.     }  
80.   
81. }  
82. </span></span>  

  接口和抽象类混淆了其实也不能全怪我，因为它们确实有相似之处：

接口与抽象类的相同点：

      1、不能实例化；

      2、包含未实现的方法声明；

      3、派生类必须实现未实现的方法，抽象类是抽象方法，接口则是所有成员（不仅是方法包括其他成员）；

不过它们还是有很大的区别的

 接口与抽象类的区别：

     1.类是对对象的抽象，可以把抽象类理解为把类当作对象，抽象成的类叫做抽象类.而接口只是一个行为的规范或规定

     2.接口基本上不具备继承的任何具体特点,它仅仅承诺了能够调用的方法;     

     3.一个类一次可以实现若干个接口,但是只能扩展一个父类（接口是可以继承接口的，而且一个接口可以继承多个接口
这里与类的继承有所区别，类只能继承一个父类，而接口可以继承多个父类，这些父类必须是接口。） 

     4.接口可以用于支持回调,而继承并不具备这个特点.     

     5.抽象类不能被密封。   

     6.抽象类实现的具体方法默认为虚的，但实现接口的类中的接口方法却默认为非虚的，当然您也可以声明为虚的. 

     7.（接口）与非抽象类类似，抽象类也必须为在该类的基类列表中列出的接口的所有成员提供它自己的实现。但是，允许抽象类将接口方法映射到抽象方法上。   

     8.抽象类实现了oop中的一个原则，把可变的与不可变的分离。抽象类和接口就是定义为不可变的，而把可变的座位子类去实现。   

     9.好的接口定义应该是具有专一功能性的，而不是多功能的，否则造成接口污染。如果一个类只是实现了这个接口的中一个功能，而不得不去实现接口中的其他方法，就叫接口污染。   

    10.尽量避免使用继承来实现组建功能，而是使用黑箱复用，即对象组合。因为继承的层次增多，造成最直接的后果就是当你调用这个类群中某一类，就必须把他们全部加载到栈中！后果可想而知.（结合堆栈原理理解）。同时，有心的朋友可以留意到微软在构建一个类时，很多时候用到了对象组合的方法。比如asp.net中，Page类，有Server Request等属性，但其实他们都是某个类的对象。使用Page类的这个对象来调用另外的类的方法和属性，这个是非常基本的一个设计原则。   

    11.如果抽象类实现接口，则可以把接口中方法映射到抽象类中作为抽象方法而不必实现，而在抽象类的子类中实现接口中方法.

 什么时候使用抽象类和接口

      1. 如果预计要创建组件的多个版本，则创建抽象类。抽象类提供简单的方法来控制组件版本。

      2.如果创建的功能将在大范围的全异对象间使用，则使用接口。如果要设计小而简练的功能块，则使用接口。

      3.如果要设计大的功能单元，则使用抽象类.如果要在组件的所有实现间提供通用的已实现功能，则使用抽象类。   

      4.抽象类主要用于关系密切的对象；而接口适合为不相关的类提供通用功能。

下面有几个比喻说的很贴切，大家从中也许也会领悟很多

      1.飞机会飞，鸟会飞，他们都继承了同一个接口“飞”；但是F22属于飞机抽象类，鸽子属于鸟抽象类。

      2.就像铁门木门都是门（抽象类），你想要个门我给不了（不能实例化），但我可以给你个具体的铁门或木门（多态）；而且只能是门，你不能说它是窗（单继承）；一个门可以有锁（接口）也可以有门铃（多实现）。门（抽象类）定义了你是什么，接口（锁）规定了你能做什么（一个接口最好只能做一件事，你不能要求锁也能发出声音（接口污染））。