c#接口

接口描述的是类或结构所描述的一组相关功能。

所以继承此接口的类或结构必须实现接口中定义的所有成员。

接口使用interface关键字进行声明，成员可以为属性，方法，索引，事件。

接口的特性：

1）、接口类似与抽象类，不能实例化，实现接口的任何非抽象类都必须实现接口的所有成员：

当显示实现成员时，实现成员不能通过类的对象访问，只能通过接口实例访问。

当隐示实现成员时，可以通过类和接口的实例访问，但是实现成员须是public。

2）、接口不能包含字段，常量，构造函数，析构函数和静态成员等。

3）、接口成员是公开的，且不需要任何的访问修饰符。

4）、接口，类和结构都可以继承多个接口。

 1 interface IProgram
 2     {
 3         void Fun();
 4     }
 5 
 6     class Program : IProgram
 7     {
 8         //显示接口实现
 9         void IProgram.Fun()
10         {
11             Console.WriteLine("i am fun.");
12         }
13         static void Main(string[] args)
14         {
15             IProgram i = new Program();//声明一个接口，但不是对接口实例化
16             i.Fun();
17             Console.ReadKey();
18         }
19     }

隐式接口与显示接口实现的区别：

一般当类和结构实现单个接口时使用隐式接口。

而当要实现多个接口时，且接口中含有同名函数时就需要使用显示接口。且使用了显示接口隐式接口就失效了。

 1  interface IProgram
 2     {
 3         void Fun();
 4     }
 5     interface IAPrograme{
 6      void Fun();
 7     }
 8     class Program : IProgram,IAPrograme
 9     {
10         //显示接口实现
11         void IProgram.Fun()
12         {
13             Console.WriteLine("i am IProgram fun.");
14         }
15          void IAPrograme.Fun(){
16              Console.WriteLine("i am IAPrograme fun.");
17         } 
18         //实现隐式接口
19          //void Fun() { 
20           
21          //}
22         static void Main(string[] args)
23         {
24             Program p = new Program();
25             ((IProgram)p).Fun();
26             ((IAPrograme)p).Fun();
27             Console.ReadKey();
28         }
29     }

接口的继承：

接口的继承指的是继承的父接口的所有成员，但是还是没有实现。且允许多继承。

 1 interface IProgram
 2     {
 3         void Fun();
 4     }
 5     interface IAPrograme : IProgram
 6     {
 7 
 8     }
 9     class Program : IProgram, IAPrograme
10     {
11         //显示接口实现
12         void IProgram.Fun()
13         {
14             Console.WriteLine("i am IProgram fun.");
15         }
16         //void IAPrograme.Fun()
17         //{
18         //    Console.WriteLine("i am IAPrograme fun.");
19         //}
20         //实现隐式接口
21         //void Fun() { 
22 
23         //}
24         static void Main(string[] args)
25         {
26             Program p = new Program();
27             //((IProgram)p).Fun();
28             ((IAPrograme)p).Fun();
29 
30             Console.ReadKey();
31         }
32     }

接口的覆盖：

 1  interface IProgram
 2     {
 3         void Fun();
 4     }
 5     abstract class IAProgram : IProgram
 6     {
 7         abstract public void AFun();
 8         void IProgram.Fun()
 9         {
10             AFun();
11         }
12     }
13     class Program : IAProgram
14     {
15      
16         public override void AFun()
17         {
18             Console.WriteLine("i am AProgram fun.");
19         }
20         static void Main(string[] args)
21         {
22             IProgram p = new Program();
23             //((IProgram)p).Fun();
24             p.Fun();
25 
26             Console.ReadKey();
27         }
28     }

先进行接口的实现，然后再调用抽象函数。

异：
不能直接实例化接口。
接口不包含方法的实现。
接口可以实现多继承，而类只能是单继承。
类定义可在不同的源文件之间进行拆分。
同：
接口、类和结构可从多个接口继承。
接口类似于抽象基类：继承接口的任何非抽象类型都必须实现接口的所有成员。
接口可以包含事件、索引器、方法和属性。
一个类可以实现多个接口。

相关推荐