接口和函数的区别 python 接口是函数吗

前言

今天天气突然降温，走在外面冷的我直发抖，回来继续更新文章吧。

一.接口

　　接口是一组包含有函数型方法的数据结构（只有声明，没有具体实现），即接口中可以含有方法、属性、事件，但接口中不能含有字段。注意这些方法、属性只有声明，没有实现。

接口不能被实例化，其成员一定是公共的，且定义时不用关键字public声明。

通过接口可以派生一个类，可以在派生类中定义这些函数型方法的具体实现，通过派生类的对象来完成对这些函数型方法的调用。 

因此，接口也是一种模板，它为继承自这个接口的类提供了一些必须实现的函数型方法模板。

1  interface IPasstrain    //定义接口
 2     {
 3         int Weight { get; set; }    //定义接口中的属性型
 4         string Plate { get; set; }  //定义接口中的属性型
 5         void Showinfo();    //定义接口中的方法型
 6     }
 7 
 8     class Passtrain : IPasstrain     //定义接口的派生类
 9     {
10         int weight;    //定义字段
11         private int passengers;    
12         public int wheels;
13         public string plate;        //定义字段
14         public int Weight   //实现继承自接口的属性型
15         {
16             get { return weight; }
17             set { weight = value; }
18         }
19         public string Plate     //实现继承自接口的属性型
20         {
21             get { return plate; }
22             set { plate = value; }
23         }
24         public void Showinfo()      //实现继承自接口的方法型
25         {
26             Console.WriteLine("我是客车");
27             Console.WriteLine("我的重量是：" + Weight);
28         }
29     }
30     class Program
31     {
32         static void Main(string[] args)
33         {
34             IPasstrain p = new Passtrain();     //定义一个接口对象，用它派生的类来实例化，定义为IPasstrain类型的对象p只能访问接口中定义的属性和方法，而不能访问Passtrain类中定义的字段
35             //注意不要写成了IPasstrain p = new IPasstrain();
36             p.Weight = 1000;    //访问接口对象的属性
37             p.Showinfo();   //调用接口对象的方法
38             Console.Read();
39         }
40  }

　　二.接口的继承

　　通过接口也可以派生出一个接口，接口的继承也有传递性。　　

1 public interface IPartA //定义接口IPartA
 2     {   void SetDataA(string A);  }
 3     public interface IPartB : IPartA    //定义接口IPartB继承自接口IPartA
 4     {   void SetDataB(string B);  }
 5     public class SharedClase : IPartB   //定义类SharedClase继承自接口IPartB
 6     {
 7         private string DataA;
 8         private string DataB;
 9         public void SetDataA(string dataA)  //实现继承自接口IPartA的方法（继承的传递性）
10         {
11             DataA = dataA;
12             Console.WriteLine("{0}", DataA);
13         }
14         public void SetDataB(string dataB)  //实现继承自接口IPartB的方法
15         {
16             DataB = dataB;
17             Console.WriteLine("{0}", DataB);
18         }
19     }
20     class Program
21     {
22         static void Main(string[] args)
23         {
24             SharedClase a = new SharedClase();  //实例化SharedClase类的对象a
25             a.SetDataA("interface IPartA");     //调用对象a的SetDataA的方法
26             a.SetDataB("interface IPartB");     //调用对象a的SetDataB的方法
27             IPartA b = new SharedClase();  //定义一个接口对象b用SharedClase类的对象进行实例化
28             b.SetDataA("interface IPartA");//调用接口对象的SetDataA方法，此时由于对象b的类型是IPartA，因此不能调用SetDataB方法
29             Console.Read();
30         }
31 }

 三.接口支持多重继承，类不支持多重继承。

1  public interface IPartA //定义接口IPartA
 2     { void SetDataA(string A);  }
 3     public interface IPartB //定义接口IpartB
 4     { void SetDataB(string B);  }
 5     public class SharedClase : IPartA , IPartB   //多重继承自接口IpartA和IPartB
 6     {
 7         private string DataA;
 8         private string DataB;
 9         public void SetDataA(string dataA)  //实现继承自接口IPartA的方法
10         {
11             DataA = dataA;
12             Console.WriteLine("{0}", DataA);
13         }
14         public void SetDataB(string dataB)  //实现继承自接口IpartB的方法
15         {
16             DataB = dataB;
17             Console.WriteLine("{0}", DataB);
18         }
19     }
20     class Program
21     {
22         static void Main(string[] args)
23         {
24             SharedClase a = new SharedClase();  //实例化SharedClase类的对象a
25             a.SetDataA("interface IPartA");     //调用对象a的SetDataA的方法
26             a.SetDataB("interface IPartB");     //调用对象a的SetDataB的方法
27             IPartA b = new SharedClase();  //定义一个接口对象b用SharedClase类的对象进行实例化
28             b.SetDataA("interface IPartA");//调用接口对象的SetDataA方法
29             Console.Read();
30         }
31 }

 四、接口与抽象类的异同 

接口与抽象类的相似性：

　　1)都可以包含有由派生类来实现的成员，且都不能被实例化。 

　　2)接口中为函数型方法，抽象类中为抽象方法。 

接口与抽象类的区别：

　　1）派生类只能有一个父类，但可以有继承多个接口。

　　2）接口中不能包含字段、构造函数、析构函数、静态成员或常量，抽象类中可以。 

抽象方法必须为公有的。