原文地址：https://www.cnblogs.com/hamburger/p/4681681.html

• 接口的定义： 
  接口是指定一组函数成员，而不实现他们的引用类型。 
  接口使用interface 关键字进行定义，可由方法、属性、事件、索引器或这四种成员类型的任意组合构成。

• 接口的特点： 
  1、接口类似于抽象基类，不能直接实例化接口；接口中的方法都是抽象方法，实现接口的任何非抽象类型都必须实现接口的所有成员： 
  2、当显式实现该接口的成员时，实现的成员不能通过类实例访问，只能通过接口实例访问。 
  3、当隐式实现该接口的成员时，实现的成员可以通过类实例访问，也可以通过接口实例访问，但是实现的成员必须是公有的。 
  4、接口不能包含常量、字段、运算符、实例构造函数、析构函数或类型、不能包含静态成员。 
  5、接口成员是自动公开的，且不能包含任何访问修饰符。 
  6、接口自身可从多个接口继承，类和结构可继承多个接口，但接口不能继承类。 
  7、当一个类既继承基类，又继承接口的时候，必须基类写在前面，基类和接口用逗号隔开，一个类只能有一个基类，可以继承许多接口

/// <summary>
/// 定义一个爬树接口
/// </summary>
interface IClimbTree
{
void ClimbTree();
}
/// <summary>
/// 定义一个抓老鼠接口
/// </summary>
interface ICatchMice
{
void CatchMice();
}
/// <summary>
/// 定义一个宠物类
/// </summary>
public class Pet
{
public void Eat()
{
Console.WriteLine("吃着真香");
}
}
/// <summary>
/// 狗狗类，继承于宠物类，又实现了爬树和抓老鼠接口
/// </summary>
public class Cat:Pet,IClimbTree,ICatchMice
{
public void ClimbTree()
{
Console.WriteLine("我会爬树");
}
public void CatchMice()
{
Console.WriteLine("我会抓老鼠");
}
}
class Program
{
static void Main(string[] args)
{
//实例化一个猫咪对象
Cat cat = new Cat();
cat.Eat();
cat.ClimbTree();
cat.CatchMice();
Console.ReadLine();
}
}

输出结果：

• 显示实现接口

public void IClimbTree.ClimbTree()
{
Console.WriteLine("我会爬树");
}
public void ICatchMice.CatchMice()
{
Console.WriteLine("我会抓老鼠");
}

• 隐式实现接口

public void ClimbTree()
{
Console.WriteLine("我会爬树");
}
public void CatchMice()
{
Console.WriteLine("我会抓老鼠");
}

• 一般情况，当类或者结构要实现的是单个接口，可以使用隐式实现。 
  如果类或者结构继承了多个接口且接口中具有相同名称成员时，就要用到显式实现，当显式实现方式存在时，隐式实现方式就失效了。

• 接口和抽象类的区别 
  1、接口用于规范，抽象类用于共性。 
  2、接口中只能声明方法，属性，事件，索引器。而抽象类中可以有方法的实现，也可以定义非静态的类变量。 
  3、抽象类是类，所以只能被单继承，但是接口却可以一次实现多个。 
  4、抽象类可以提供某些方法的部分实现，接口不可以。 
  5、抽象类的实例是它的子类给出的。接口的实例是实现接口的类给出的。 
  6、在抽象类中加入一个方法，那么它的子类就同时有了这个方法。而在接口中加入新的方法，那么实现它的类就要重新编写。 
  7、接口成员被定义为公共的，但抽象类的成员也可以是私有的、受保护的、内部的或受保护的内部成员（其中受保护的内部成员只能在应用程序的代码或派生类中访问）。 
  8、接口不能包含字段、构造函数、析构函数、静态成员或常量。

思考一： C#中接口和抽象类的使用上的区别：              

  ---------------YYC

                1、抽象类不能被实例化，但能拥有自己的成员字段和非抽象的方法，但接口比抽象类更加抽象，其成员只能是
                    一般的方法、属性和索引函数而不能拥有自己的成员字段和构造函数。
                2、用abstract声明的抽象类中的方法必须有访问修饰符如public等关键字进行修饰，其次抽象类里面的方
                   法须用abstract声明为抽象方法或则用virtual声明为虚拟方法（非抽象方法除外，虚拟方法有简单执
                   行代码，派生类中可以选择不重载，抽象方法没有任何执行代码，派生类中必须重载）。在其派生类
                   中重载抽象方法或虚拟方法时时必须用override修饰。而在用interface声明的接口类中的接口方法第
                   一不允许是静态的，其次除了无执行代码外
                   不能加任何访问限制修饰符，且不能用virtual或abstract进行修饰。同时在直接支持其接口的类型中不能用
                   override修饰符来表示重载方法，且必须支持即实现该接口中的所有方法。但可以用new关键字来隐藏父接口中的方法。

                 3、接口、抽象类、非抽象类都可以继承接口

                 4、继承接口后对其接口方法的实现：

                                 实现可以分为“显示实现”和”隐式实现“

 interface Interface1

    {
        int GetInt();
        //派生类必须实现接口类里面的每一个方法
    }

class cl1 :Interface1
        { 
          public int GetInt()  //隐式实现
          {
              return 1;
          }
        }

 class cl2 : Interface1
        {
            public int GetInt()//隐式实现
            {
                return 2;
            }
            int Interface1.GetInt()//显示实现
            {
                return 4;
            }
        }

其中两者的区别是：隐式实现的方法既可以同接口对象调用，也可以通过派生类的实例来调用。

而对于显示实现的方法只可以通过接口对象来调用。而且显示实现时该方法前不能加任何的访问

修饰符，其实默认的为隐式的，所以派生类的对象不能调用该方法。

思考二：接口在C#中出现的意义。

 一、解决了多态和动态隐藏不能统一的问题。

a、动态隐藏：在没有接口机制的动态隐藏是通过new关键字来隐藏基类的方法，从而

实现了基类对象和派生类对象通过使用相同方法名分别调用不同的方法；而在有接口的机制中是通过对于接口中的接

口方法的隐式实现和显示实现同时共存的方法来实现接口对象和派生类对象通过使用相同方法名分别调用不同的方法。

For example：//接口的动态隐藏

cl2 c2 = new cl2();

 Interface1 iter = c2;

 MessageBox.Show(c2.GetInt());//输出2  ------会调用隐式方法

 MessageBox.Show(iter.GetInt());//输出4  -------会调用显示方法

b、多态的实现：在没有接口的机制中，多态的实现是通过使用关键字abstract/virtual--override的重载来实现

的；而在接口机制中的多态直接通过显示实现多隐式实现都可以完成。

For example：//接口的多态

cl1 c1 = new cl1();

cl2 c2 = new cl2();

 Interface1 iter = c1;

MessageBox.Show(iter.GetInt());//输出1

Interface1 iter = c2;

MessageBox.Show(iter.GetInt());//输出4  --------会调用显示方法，如果没有显示实现则会调用隐式实现方法。

                c：问题：关键问题就是在没有接口的机制中new机制和abstract/virtual--override不能同时出现，但是

在接口机制中通过同时显示实现和隐式实现方法共存，就可以很轻松的解决该问题了。在C#接口机制下的动态

隐藏和多态同时实现有至少三种模式：

For example：

/*模式一：*/

cl1 c1 = new cl1();

cl2 c2 = new cl2();

 Interface1 iter = c1;

MessageBox.Show(iter.GetInt());//输出1

Interface1 iter = c2;

MessageBox.Show(iter.GetInt());//输出4  --------会调用显示方法，如果没有显示实现则会调用隐式实现方法。

MessageBox.Show(c2.GetInt());//输出2

//输出2和4实现了1和4实现了多态，输出2和4实现动态隐藏

/*模式二：*/

从新写cl1类

 class cl1 :Interface1
        { 
          public virtual int GetInt()//隐式实现
          {
              return 1;
          }
          int Interface1.GetInt()//显示实现
          {
              return 3;
          }


        }


        class cc : cl1 

{
            public override int GetInt()
            {
                return 5;
            }
  }

        class cd : cl1
        {

            public override int GetInt()
            {
                return 6;
            }
        }

cl1 c1 = new cl1();

Interface1 iter = c1;

//动态隐藏

MessageBox.Show(iter.GetInt());//输出3  ---显示实现

MessageBox.Show(c1.GetInt());//输出1--------显示实现

cc cc1= new  cc();

cd cd1 =  new cd();

//多态

c1 = cc1;

MessageBox.Show(c1.GetInt());//输出5

c2= cd1;

MessageBox.Show(c1.GetInt());//输出6

所以运用接口就可以轻松地解决多态和动态隐藏的统一问题了。

      二、实现多继承问题

实现多继承也是接口在C#中很独特和很重要的功能之一，

现在接着上篇博客写，上次是写到了关于C#中接口出现的意义的第二点：实现多继承。

在C#语言中本身就有规定一个类只能有一个直接基类，也就是不允许出现多继承，这个主要

是基于两个方面原因的考虑： 

（上一部分的连接是http://blog.csdn.net/yyc1023/article/details/17270951）

--------------------YYC

一、多继承很容易出现“二义性”，也就是在两个或以上的基类中出现了相同名字的方法时，

在其派生类中通过base关键字调用父类中该方法时就会引发歧义。

二、多继承会严重的影响程序的性能，例如：首先：在存储空间方面派生类的对象所占的

空间将会是其所以的基类对象的内存空间之和；其次：派生类的对象在创建时会依次调用其所

有的基类的构造函数，所以其效率肯定会有所下降，特别是当一个类有过多的基类时这个问题

将会变得很明显的。

但是多继承又是面向对象的程序设计中非常重要的一个特性，所以C#在考虑这个问题时就提出

了基于接口的多继承，也就是说在C#语言中允许一个类或接口同时继承多个接口，在声明时分

别用逗号隔开即可。

For example：

  public interface IA 
        {
            int GetInt();
        }

        public interface IB
        {
            int GetInt();
        }

        class CA : IA, IB
        {

            int IA.GetInt()
            {
                return 1;
            }

            int IB.GetInt()
            {
                return 2;
            }

        }

由上可以看出用基于接口实现的多继承的优点是：首先：这个更本不会引起程序性能的问题，因为

接口中是不能出现成员字段和实体方法和构造函数的。其次：关于“二义性”的问题在接口的多继承中

只要多显示实现不同接口的相同名字的接口方法即可很容易消除了二义性了，因为在通过不同接口对

象在调用该方法时都只会调用自己的显示实现的方法。

接口

为什么要用接口？好处在哪里？

如果你的工作是一个修水管的，一天客户找上你让你帮装水管，但是有个要求，就是客户喜欢管子是三角形的。

你立马买了三角形的水管回来，在墙上弄个三角形的口子，客户付了钱，你很开心今天有了收入，如下图，很好：

但是好景不长，客户过了一个星期又来找，因为他觉得三角形不好看，要让你换成正方形的水管，你不得不换，因为顾客就是上帝。好吧，继续在墙上弄个正方形的口子，然后又换成正方形的管子来接上。好了，如下图：（但是可能觉得为什么一开始不说要正方形的？因为需求总在变化。。。）

你累得满头大汗，但是还是完成了。可惜不久，客户又来找你，因为他想换成椭圆形的管子了。虽然你很无奈，但是你还是不得不花了几个小时完成。如下图：

安装完成，这时你可能在考虑，为什么换不同形状的水管，我都要大动干戈一番呢？于是你想到一个好方法，那就是墙上设计一个固定的水管并且是圆形的，当客户喜欢什么形状的水管，那么我只需要把客户喜欢的水管的一头做成圆形的，这样，以后都不需要去动墙上的水管了。这是一个好办法。就先在墙上弄个圆形的口，这个口就叫做接口。如下图：

如你所见，墙上有个圆形的口，但是按照原本的：

三角形水管两端是三角形
正方形水管两端是正方形
椭圆形水管两端是椭圆形

那是肯定接不上的，因为三角形、正方形、椭圆形的口怎么和墙壁上圆形的口对接呢？

所以先要实现接口，把：

三角形水管一端做成圆形
正方形水管一端做成圆形
椭圆形水管一端做成圆形

如图所以，圆形接口做出来了，具体实现是客户去安装，接口本身并不会安装其他形状的水管，换句话说就是接口没有具体实现，只是告诉你，你的水管要接入，必须有一端是圆形的（接口的约束），因为我只留这个圆形的接口，你要装别的形状的管子，先把一个弄成圆形的就好了（子类去实现接口的方法），不管什么形状，都要一个必须做成圆形才能对接得上，它必须要你按照我的规范来做。这就是为什么新手会觉得接口什么都不做，只定义接口，没有任何实现，那不是多此一举吗？因为它的实现是子类去完成。这样只要客户喜欢什么形状的水管，只要实现了我的接口（圆形），都能对接得上，而且改变起来也很方便，只要把水管扭上去就行了，不用在去给墙壁挖洞了

下面我们在代码里体现接口的作用，以下例子的场景不讨论是否合理，由于以下代码是在txt编写，不保证运行无误。

需求：公司有两个人分别写了2个动物类，让你写一个类来输出它们各自喜欢的食物。

//A写的Dog类，里面有个likeFood方法，如下：
class Dog
{
public void likeFood()
{
Console.WriteLine("我是小狗，我喜欢吃肉");
}
}
//B写的Cat类，里面有个likeFood方法，如下：
class Cat
{
public void likeFood()
{
Console.WriteLine("我是小猫，我喜欢吃鱼");
}
}

你写的Zoo类如下：

//动物园类
class Zoo {
public void show(Dog dog){
dog.likeFood();
}
public void show(Cat cat){
cat.likeFood();
}
}

在输出的时候使用如下：

public static void Main(string[] args)
{
Zoo zoo = new Zoo();
zoo.show(new Dog()); //"我是小狗，我喜欢吃肉"
zoo.show(new Cat()); //"我是小猫，我喜欢吃鱼"
}

这一切工作良好，但好景不长，公司又需要给动物园增加一个猴子，让C去写这个Monkey类，并能输出它喜欢的食物。

class Dog
{
public void likeFood()
{
Console.WriteLine("我是小狗，我喜欢吃肉");
}
}
//B写的Cat类，里面有个likeFood方法，如下：
class Cat
{
public void likeFood()
{
Console.WriteLine("我是小猫，我喜欢吃鱼");
}
}
//C写的Monkey类，里面有个likeFood方法，如下：
class Monkey
{
public void likeFood()
{
Console.WriteLine("我是猴子，我喜欢吃桃子");
}
}

于是你的Zoo类就变成了这样，仅仅多了一个重载方法：

class Zoo
{
public void show(Dog dog)
{
dog.likeFood();
}
public void show(Cat cat)
{
cat.likeFood();
}
public void show(Monkey money)
{
money.likeFood();
}
}

public static void Main(string[] args)
{
Zoo zoo = new Zoo();
zoo.show(new Dog()); //"我是小狗，我喜欢吃肉"
zoo.show(new Cat()); //"我是小猫，我喜欢吃鱼"
zoo.show(new Monkey()); //"我是猴子，我喜欢吃桃子"
}

输出结果也良好，你不禁暗暗得意，一个变化而已，我只需要再Zoo类里增加一个重载方法就好了。
但你仔细一想：“如果后面还有更多动物要输出它们喜欢的食物，我的Zoo类都要修改，这对我来说不是一件好事。”
然后你再仔细观察Zoo类，发现不变的是show方法，变化的是show方法是参数。因为每个动物都不一样，所以参数也就不一样。所以原来就需要重载多个方法。
如果有一个类，能接收所有动物，那不就解决了？没错，于是你想到了定义一个父类叫Animal，里面有个likeFood方法，让所有动物类去继承Animal。
最后你的Zoo类和Animal类代码如下：

class Zoo
{
public void show(Animal animal)
{
animal.likeFood();
}
}
class Animal
{
public void likeFood()
{
Console.WriteLine("我是Animal类");
}
}

你告诉原来的A和B两人，让它们写的动物类都去继承Animal，并且里面有个输出动物喜欢食物的方法。
A、B、C写的类修改后如下：

class Dog : Animal
{
public void likeFood()
{
Console.WriteLine("我是小狗，我喜欢吃肉");
}
}
class Cat : Animal
{
public void likeFood()
{
Console.WriteLine("我是小猫，我喜欢吃鱼");
}
}
class Monkey : Animal
{
public void likeFood()
{
Console.WriteLine("我是猴子，我喜欢吃桃子");
}
}

Zoo也需要修改，最后代码如下：

class Zoo
{
public void show(Animal animal)
{
animal.likeFood();
}
}
public static void Main(string[] args)
{
Zoo zoo = new Zoo();
zoo.show(new Dog()); //"我是小狗，我喜欢吃肉"
zoo.show(new Cat()); //"我是小狗，我喜欢吃肉"
zoo.show(new Monkey()); //"我是猴子，我喜欢吃桃子"
}

运行也一切良好，不管你以后还有什么类，只要让需要添加的动物类，继承Animal，并有个likeFood方法，那么你无需修改Zoo，只需要再main方法里传入动物类的实例就能正常工作。
你大赞你聪明绝顶，这样一来，你的Zoo根本不需要改变了。
有一天，公司新来一个人，暂时叫D吧，公司让D写个兔子类，你告诉D，你写的Rabbit类必须继承Animal，并且有一个它喜欢的食物的方法，。
D写的兔子类如下：

class Rabbit : Animal
{
public void favoriteFood()
{
Console.WriteLine("我是兔子，我喜欢吃萝卜");
}
}

public static void Main(string[] args)
{
Zoo zoo = new Zoo();
zoo.show(new Dog()); //"我是小狗，我喜欢吃肉"
zoo.show(new Cat()); //"我是小猫，我喜欢吃鱼"
zoo.show(new Monkey()); //"我是猴子，我喜欢吃桃子"
zoo.show(new Rabbit()); //"我是Animal类"
}

Raabit并没有输出预想的结果，你不得不花了点时间去排查原因，最后你发现这不是什么大问题，因为新来的D虽然写了Rabbit类，但是他并不知道你们之前约定的动物喜欢的食物命名为：likeFood()
D写的Rabbit类，里面的方法叫：favoriteFood()
虽然最后D修改他的Rabbit类的方法为likeFood()，但你还是对这个问题做了一番思考，为什么会导致这个问题？
那是因为没有一种约束，使得子类继承父类的时候必须实现父类的方法。有没有一个类，能让它的子类必须实现它定义的方法？有，那就是接口。
于是你修改Animal为接口，代码如下：

interface Animal {
public void likeFood();
}

由于Animal接口有个likeFood()方法，那么Rabbit子类去实现Animal接口必须实现likeFood()，否则程序不能通过。

代码正常工作，因为Animal是接口，里面有个likeFood()方法，以后再添加各种动物进来，只需要实现Animal接口，并且也不会出现有的人会因为子类的方法命名问题而导致出错了。
这时你再想，虽然用继承一个普通父类也可以满足要求，但是一个普通父类根本没有约束力
而用了接口就不一样了，子类必须实现父类的所有方法，因为Zoo类里调用的是likeFood()，由于子类必须实现父类，那么所有子类都会有likeFood()，你根本不用担心子类有没有这个方法。
所以接口能在多人协作下，定义一系列方法，让子类必须存在接口定义的类，防止在另外的类里调用一个人写的接口的子类时，找不到方法的问题。

开放闭关原则：

对扩展开放，意味着有新的需求或变化时，可以对现有代码进行扩展，以适应新的情况。

对修改封闭，意味着类一旦设计完成，就可以独立完成其工作，而不要对类进行任何修改。

这两句话是概念性的东西。通俗的意思就是：

对于上面的图片来说，墙上的接口做好了，不能去改变了，但是可以扩展，你要什么形状的水管就去实现它的接口。

最后

以上就是魁梧水壶为你收集整理的C# 接口《通俗解释》  接口的全部内容，希望文章能够帮你解决C# 接口《通俗解释》  接口所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。