unity3d之接口

unity学习笔记，希望对朋友们有所帮助

接口

      1、接口描述的是可属于任何类或结构的一组相关功能，所以实现接口的类或结构必须实现接口定义中指定的接口成员。

      2、接口使用interface 关键字进行定义，可由方法、属性、事件、索引器或这四种成员类型的任意组合构成。

 

接口的特性

 

       1、接口类似于抽象基类，不能直接实例化接口；接口中的方法都是抽象方法，实现接口的任何非抽象类型都必须实现接口的所有成员。

       2、接口不能包含常量、字段、运算符、实例构造函数、析构函数或类型、不能包含静态成员。

       3、接口成员是自动公开的，且不能包含任何访问修饰符。

       4、接口自身可从多个接口继承，类和结构可继承多个接口，但接口不能继承类。

1. interface IProgram
   
2.     {
   
3.         void Fun();
   
4.     }
   
5.     class Program：IProgram
   
6.     {
   
7.          //显式实现接口成员
   
8.         void IProgram。Fun()
   
9.         {
   
10.             Console.WriteLine("I am Fun.");
    
11.         }
    
12.         staticvoid Main(string[] args)
    
13.         {
    
14.             IProgram p =new Program();  //声明一个接口实例，但不是对接口进行实例化
    
15.             p.Fun();
    
16.             Console.Read();
    
17.         }
    
18.     }

 

     5、一般情况，当类或者结构要实现的是单个接口，可以使用隐式实现。

     6、如果类或者结构继承了多个接口且接口中具有相同名称成员时，就要用到显式实现，当显式实现方式存在时，隐式实现方式就失效了。

1. interface IProgram
   
2.     {
   
3.         void Fun();
   
4.     }
   
5. 
   
6.     interface IAProgram
   
7.     {
   
8.         void Fun();
   
9.     }
   
10. 
    
11. class Program : IProgram, IAProgram
    
12.     {
    
13.         void IProgram.Fun()  //显式实现接口IProgram
    
14.         {
    
15.             Console.WriteLine("I am IProgram Fun.");
    
16.         }
    
17. 
    
18.         void IAProgram.Fun()  //显式实现接口IAProgram
    
19.         {
    
20.             Console.WriteLine("I am IAProgram Fun.");
    
21.         }
    
22. //public void Fun()   //隐式实现接口
    
23.         //{
    
24.         //    Console.WriteLine("I am Program Fun.");
    
25.         //}
    
26.         staticvoid Main(string[] args)
    
27.         {
    
28.             //IProgram p = new Program();
    
29.             //p.Fun();
    
30.             //IAProgram ap = new Program();
    
31.             //ap.Fun();
    
32. 
    
33.             Program pro =new Program();
    
34.             ((IProgram)pro).Fun();
    
35.             ((IAProgram)pro).Fun();
    
36.             Console.Read();
    
37.         }
    
38.     }

接口的继承

 

    接口继承和类继承不同：首先，类继承不仅是说明继承，而且也是实现继承；而接口继承只是说明继承。

        也就是说，派生类可以继承基类的方法实现，而派生的接口只继承了父接口的成员方法说明，而没有继承父接口的实现，

        其次，C#中类继承只允许单继承，但是接口继承允许多继承，一个子接口可以有多个父接口。

1. interface IProgram
   
2.     {
   
3.         void Fun();
   
4.     }
   
5. 
   
6.     interface IAProgram:IProgram
   
7.     {
   
8. 
   
9. 
   
10.     }
    
11. class Program :  IAProgram
    
12.     {
    
13.        void IProgram.Fun()
    
14.         {
    
15.             Console.WriteLine("I am IProgram Fun.");
    
16.         }
    
17. 
    
18.        staticvoid Main(string[] args)
    
19.         {
    
20.             Program pro =new Program();
    
21.             ((IAProgram)pro).Fun();
    
22.         }
    
23.     }

接口的覆盖

 

       由于接口的实现没有方法体，抽象方法也没有方法体，那么当我们在接口的实现方法里调用抽象方法时，会如何执行呢？

       结果是：抽象类子类的实现方法功能

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

接口的作用

         1、接口的定义方面来说,接口其实就是类和类之间的一种协定,一种约束

         2、目的是方便统一管理.另一个是方便调用.当然了,不使用接口一样可以达到目的.只不过这样的话,这种约束就不那么明显,如果这样类还有Duck类等等,比较多的时候难免         有人会漏掉这样方法.所以说还是通过接口更可靠一些,约束力更强一些.

接口和抽象类的区别

 

       1、接口用于规范，抽象类用于共性。 

       2、接口中只能声明方法，属性，事件，索引器。而抽象类中可以有方法的实现，也可以定义非静态的类变量。

       3、抽象类是类，所以只能被单继承，但是接口却可以一次实现多个。

       4、抽象类可以提供某些方法的部分实现，接口不可以。

       5、抽象类的实例是它的子类给出的。接口的实例是实现接口的类给出的

       6、在抽象类中加入一个方法，那么它的子类就同时有了这个方法。而在接口中加入新的方法，那么实现它的类就要重新编写（这就是为什么说接                 口是一个类的规                范了）。

       7、接口成员被定义为公共的，但抽象类的成员也可以是私有的、受保护的、内部的或受保护的内部成员（其中受保护的内部成员只能在应用程序                的代码或派生类                 中访问）。

       8、此外接口不能包含字段、构造函数、析构函数、静态成员或常量。

更多精彩请点击 http://www.gopedu.com/article