接口

最新推荐文章于 2021-03-02 12:29:28 发布

雪天飞山狐狸

最新推荐文章于 2021-03-02 12:29:28 发布

阅读量335

点赞数

分类专栏： C# 一些核心的东东

C# 一些核心的东东专栏收录该内容

19 篇文章 0 订阅

订阅专栏

点击打开链接

学习过C++的童鞋都应该知道，在C++中允许将一个类的成员函数定义为virtual（虚拟函数），定义为虚拟的函数，例如：

[cpp]view plaincopy 
   
 class CTest  
 {  
 public:  
     virtual void TestA();  
     virtual void TestB() = 0;  
 };  
     
 void CTest::TestA()  
 {  
     cout<<"Hello"<<endl;  
 }  
     
 class CTestChild : public CTest  
 {  
 public:  
     virtual void TestB();  
 };  
     
 void CTestChild::TestB()  
 {  
     cout<<"Hello World"<<endl;  
 }  
     
 int main(int argc, char* argv[])  
 {  
     CTest* pTest = new CTestChild();  
     pTest->TestA();  
     pTest->TestB();  
 }  

　　形如第4行的函数声明称为“虚拟函数”，可以被子类的同名函数（返回值类型，参数也必须完全相同）覆盖；形如第5行的函数声明称为“纯虚拟函数”，这个函数没有函数体，必须被子类的同名函数（返回值类型，参数也必须完全相同）覆盖。

　　C#中也具有虚拟方法（使用virtual修饰的方法）和抽象方法（使用abstract修饰的方法），相当于C++中的虚拟函数和纯虚拟函数。

　　可以在C++中设计这样的一种类，这个类中的所有成员函数都为纯虚拟函数，即都没有方法体。这种类型的类非常有用。在C#中，语言设计者为它起了一个新的名字——接口。

　　接口在现实生活中非常常见，例如我们连接DVD影碟机和电视机，只要我们有这样的两个设备，使用电缆将它们连接在一起就可以了，无须考虑这两个设备是否可以相互兼容。这其中的道理非常简单，影碟机可以输出AV信号，电视机可以接受AV信号，所以可以连接。

　　所以接口并不是一个实际存在的插口，而是双方都共同遵守的一种行为准则。因为双方都遵守这样的规范，所以双方可以毫无障碍的联系在一起。

　　接口是面向对象中的最高抽象，接口只定义了要执行的方法，而没有”类属“信息，比如有一个Runnable接口，其中包含了一个run方法，那看到这个接口的人会知道这是一个”会跑的东西“，但具体是什么就不得而知了。但如果有一个Horse类来实现这个接口，那就很明确它的类型是”马“。

　　我们来看一个例子：

[csharp]view plaincopy 
   
 public abstract class Runnable {   
     public abstract void Run();   
 }   
     
 public class Mechanical{   
 }   
     
 public class Car : Mechanical{   
 }   
     
 public class Animal {   
 }   
     
 public class Cat : Animal {   
 }  

　　代码中，我试图确立一种行为规范称之为“会跑的”（Runnable），有两个类需要遵循此规范，Car类和Cat类，显然汽车和猫都是会跑的东西，都可以实现抽象方法Run。

　　但问题出现了，Car类显然需要从机械类（Mechanical）继承，因为汽车是机械的一种，但显然并不是所有的机械都会跑（例如电动刮胡刀）；而Cat类显然是从动物类（Animal）继承，但也不是所有的动物都会跑（例如鱼）。Car和Cat完全找不到相同的超类，但它们又可以遵循同样的行为规范，一个类不可能既继承自Animal类又继承自Runnable类。

　　再看代码：

[csharp]view plaincopy 
   
 public interface Runnable {  
     void Run();  
 }  
     
 public class Mechanical {  
 }  
     
 public class Car : Mechanical, Runnable {  
     public void Run() {  
         Console.WriteLine("汽车开走了！");  
     }  
 }  
     
 public class Animal {  
 }  
     
 public class Cat : Animal, Runnable {  
     public void Run() {  
         Console.WriteLine("猫跑掉了！");  
     }  
 }  

　　我们使用了一个新的关键字interface，很容易就解决了上面的问题，用interface声明的我们称为接口。我们发现，接口中可以包含方法的声明，而所有的类除了可以继承一个超类外，还可以继承多个接口。当然，习惯上把对接口的继承不叫做继承，而叫做“实现”，即一个类实现了某些接口。

　　接口定义的特点：接口中定义的方法上，自动为public abstract，即公共抽象方法。接口本身也为抽象。接口中不允许以任何方式包含具有方法体的方法。

　　接口完美的解决了所有的问题：

接口中只允许包含方法声明，所以即便接口被多继承，也不会产生任何父子悖论问题；
接口不是实体类，不带有类别的含义，只是一种行为的规范，所以可以被不同含义的多个类同时继承；
接口可以赋予不同的类相同的行为准则（接口中定义的方法声明），所以接口类型变量可以引用到所有实现此接口类的实例上。

　　属性是一对方法，所以接口中也可以包含属性的定义。接口中不允许出现字段的定义。

　　看一段完整的代码，从中体会接口的特点。

[csharp]view plaincopy 
   
 public interface Runnable {  
     // 定义抽象属性  
     double Speed {  
         get;  
     }  
     void Run();  
 }  
     
     
 public class Mechanical {  
 }  
     
     
 public class Car : Mechanical, Runnable {  
     private double speed = 60.0;  
       
     public void Run() {  
         Console.WriteLine("汽车开走了！");  
     }  
     /// <summary>  
     /// 实现接口中定义的抽象属性并添加set访问器  
     /// </summary>  
     public double Speed {  
         get {  
             return this.speed;  
         }  
         set {  
             this.speed = value;  
         }  
     }  
 }  
     
     
 public class Animal {  
 }  
     
     
 public class Cat : Animal, Runnable {  
     public void Run() {  
         Console.WriteLine("猫跑掉了！");  
     }  
       
     /// <summary>  
     /// 实现接口中定义的抽象属性  
     /// </summary>  
     public double Speed {  
         get {  
             return 5.0;  
         }  
     }  
 }  

　　除了上面讲的接口概念，C#还有一个非常有趣的特性，即接口的显式实现，接口显式实现体现了这样一种效果：一个类同时实现多个接口中的多个同名方法。例如接口IA中有个方法void Test();，接口IB也有一个方法void Test();，类C实现IA和IB接口。如下:

[csharp]view plaincopy 
   
 /// <summary>  
 /// 接口IA  
 /// </summary>  
 public interface IA {  
     /// <summary>  
     /// 在接口IA中定义Test方法  
     /// </summary>  
     void Test();  
 }  
     
     
 /// <summary>  
 /// 接口IB  
 /// </summary>  
 public interface IB {  
     /// <summary>  
     /// 在接口IB中定义Test方法(和IA中定义的Test方法一致)  
     /// </summary>  
     void Test();  
 }  
     
     
 /// <summary>  
 /// 定义类C，同时实现IA接口和IB接口  
 /// 这时候可以有三种选择：  
 /// 1、实现IA和IB接口定义的Test方法  
 /// 2、针对接口IA实现其定义的Test方法  
 /// 3、针对接口IB实现其定义的Test方法  
 /// </summary>  
 public class C : IA, IB {  
     /// <summary>  
     /// 实现IA和IB接口定义的Test方法  
     /// 以public关键字修饰，表示该方法公共  
     /// </summary>  
     public void Test() {  
         Console.WriteLine("OK");  
     }  
           
     /// <summary>  
     /// 指明实现IA接口中定义的Test方法，  
     /// 使用 接口名.方法 来指定要实现的方法是由哪一个接口定义的。  
     /// 显式实现的方法前无访问修饰符，表示其至少不是public的，所以无法使用C类对象直接访问  
     /// </summary>  
     void IA.Test() {  
         Console.WriteLine("Hello");  
     }  
       
     /// <summary>  
     /// 指明实现IB接口中定义的Test方法  
     /// </summary>  
     void IB.Test() {  
         Console.WriteLine("World");  
     }  
 }  
     
     
 /// <summary>  
 /// 主方法  
 /// </summary>  
 static void Main(string[] args) {  
     // 实例化C类的对象  
     C c = new C();  
       
     // 通过C类对象调用Test方法，这时调用的是以public修饰符修饰的Test实现  
     c.Test();  
       
     // 将C类的引用类型提升为IA类的引用类型，此时，调用的是C类中显式实现的IA.Test方法  
     IA a = c;  
     a.Test();  
       
     // 将C类的引用类型提升为IB类的引用类型，此时，调用的是C类中显式实现的IB.Test方法  
     IB b = c;  
     b.Test();  
 }  
 
   
 