我看了C#接口的概念，可是我无法理解？请用通俗的语言解释并用代码表示，他有什么作用？

我觉得在COM编程中，接口很重要也很有用，但在.net中总感觉接口是多余的，理由有二点：一、在.net中引用一个类很方便
二、在.net中反射很方便当然，由于实现与接口的分离，更改实现不影响接口，除了这个优点，在.net中感觉是多余的。

准确回答的话，通俗不了，因为它是OO的全部秘诀！接口类似于虚拟继承，但是有两点区别：它不能继承代码流程，它不支持定义继承。对象（类）需要多态，并且往往需要多重继承以便于放入不同父类的多态流程中。但是c#不支持多重继承，只能用接口来实现。

当然，由于实现与接口的分离，更改实现不影响接口，除了这个优点，在.net中感觉是多余的。
-----------------------------------------------------------------------------------
别忘记.NET中大部分语言是单根继承的。

接口是用来通信的，不同的对象/模块通过接口来通信例如下面这个函数要使用某个对象A，可以这样做
void f(A a);
也可以这样做
void f(IA a);
显然第二种的好处是，它不依赖于A的具体实现，而且对函数f也屏蔽了A中的一些其它的东西，这样也有得于安全编程

接口就是对一个类的一些行为和职责的申明.
如果有两个接口分别是"球员"和"教练"
当有一个类是"人"类,这个类实现了"球员"和"教练"这两个接口
那么这个类就要有这两个接口的行为和职责当在调用"俱乐部"一个方法"入会"时,这个方法要传入一个"球员",那么传入"人"类的一个实例就行了.
在这个方法里面的代码只知道传入的是一个"球员"的实例,它可以调用"球员"中申明的方法.但如果"人"类没有实现"球员"接口,就不能传给"入会"方法了.在设计时,可用接口把一个类给分成几个部分了,也可以用接口把类的依赖关系倒过来(倒置原则).
可以看一些设计类的书,看多了就会了解到一些接口的使用.
如果:<设计模式>,<敏捷软件开发>

to sp1234(SmartNavigation变为obsolete，asp.net进取心气数尽了) 不好意思,我要说的重点不是说,每个人就是球员,就是教练,这只是个例子.
我想说的是接口的作用.也许是我的例子没有举好吧.也许你有更好的例子.无论是什么东西用好了就是好的,如果烂用了也不能怪东西不好.
同样一把菜刀可以用来切菜也可以用来杀人.
OO是个好东西,但也会被人烂用.-----------------------------------------------------------------------
我觉得楼主不只要理解,多一些实践,多看一些高手写的代码也会有很大的帮助的.
我真正学OOD也只是一年多,以前只是学了OO的语言和知道OO中有些什么东西.
希望大家多多交流.我的理解是:
就像演戏一样,如果一个类实现某个接口,那么就像是这个类扮演了某一个角色.
如果"人"类有实现"球员"这个接口,那么它就可以扮演"球员"这个角色.当然这只是个例子.对了,更正一下,鸭嘴兽只是哺乳动物(当然这个不是讨论的主题啦,不好意思)

针对接口编程能帮助达到面向对象开发和设计中"低耦合"的要求.
举个例子:某公司有一台特殊打印机,还可以使用一年,一年后可能换为另一种打印机,这两种打印机都特殊而贵.所以现在的程序希望换了打印机后也少量修改就可用.
方法:
1,定义一个打印机接口.
2,定义打印机类A,B,分别实现此接口.
3,定义一个工厂类,在类中可选择返回由A实现的接口,或者由B实现的接口.
4,在程序中使用打印机时,就可以使用工厂类来调用打印机,而不需要知道具体的是什么打印机.
如果打印机换了,只需要修改工厂类就行了.如果有一千个地方都调用过打印机,就不需要一个一个修改.修改一个地方就行了.接口充当一个隔离层的作用.在面向对象的设计中,接口的作用非常重要,不是没用.

(续上)例程:
//定义打印机接口
interface Iprint{
  bool PrintData(string data);
}//定义打印机类A,实现接口
class PrintA:Iprint{
  public virtual bool PrintData(string data){
    //具体业务逻辑略
  }
}定义打印机类B,实现接口
class PrintB:Iprint{
  public virtual bool PrintData(string data){
    //具体业务逻辑略
  }
}//定义工厂类
class PrintFactory{
  public Iprint CreatePrint(){
   //返回一个由打机类A,或B实现的接口,比如
    return new PrintA();
  }
}//通过工厂类,调用打印机
private void button1_Click(object sender,EventArgs e){
  PrintFactory myFactory=new PrintFactory();
  Iprint myPrint=myFactory.CreatePrint();
  myPrint.PrintData("这样做很方便啊");
}

呵呵，大家讨论得挺热烈的
偶的想法
如果说类是对象间的抽象共有特征的话，那接口就是类间的抽象共有特征了，声明了这个特征就可以表示数个类而不必知道它是那个类的对象了,而一个类可以有几个特征。
按照.net类库中接口的用法给出这个例子：接口Iflyable，几个类如Plane,Bird,SuperMan继承了它，你就可以用以下方法调用它而不管它是那一个类
void Act(Iflyable obj)
{
obj.BeginFly();
}
这样这个方法的使用适应性就强了很多了，符合OO模块化的要求，扩展起来很容易。这种东西在OO的高级设计里面比比皆是，楼主学过了用过了就会领悟的了。可能是c#1.0太单薄了，所以接口的用途还不是很多，不如abstract class 好用，像在.net类库里接口都是扩展功能为主，可能要到c#3.0才会有改善。
以上是我的个人想法，如有不对欢迎指正。

对了，abstract class 不支持多重继承，所以说interface 跟abtract class是各有千秋.

http://blog.csdn.net/Peak915/archive/2005/07/19/428806.aspx这里有一篇关于用C#发短信的文章，也要调用接口
我不懂，但觉得对楼主有帮助

偶对C#接口的理解过程:
看书 ->不懂,学C++->虚类->COM接口->C#接口->终于懂了....

呵呵，我也是通过 VC 学的 oo 然后实现在 C# 中的

不过，面向对象编程已经过时了。面向对象设计尚没有过时，但是需要修正。下面这个是我在网上看到范型的文章之后几个小时之内写的一个测试程序片断，我知道过去的OOPL的东西在这些新语言特征面前肯定要让位了：        public static void QuickSort<T>(ref T[] items) where T : IComparable<T>
        {
            QuickSort(ref items, 0, items.Length - 1);
        }        private static void QuickSort<T>(ref T[] items,int fromIndex,int toIndex)
          where T:IComparable<T>
        {
            if (fromIndex >= toIndex)
                return;
            else
            {
                int p = Partition(ref items, fromIndex, fromIndex+1, toIndex);
                QuickSort(ref items, fromIndex, p - 1);
                QuickSort(ref items, p + 1, toIndex);
            }
        }        private static void swap<T>(ref T[] items,int index1,int index2)
        {
            if (index1 != index2)
            {
                T m = items[index1];
                items[index1] = items[index2];
                items[index2] = m;
            }
        }        //使用T[]的第一个元素作为划分元素，重新排列T[]。返回划分元素的最终位置。
        private static int Partition<T>(ref T[] items, int partIndex,
             int fromIndex, int toIndex) where T : IComparable<T>
        {
            if (fromIndex > toIndex)
            {
                swap(ref items, partIndex, toIndex);
                return toIndex;
            }
            else if (items[fromIndex].CompareTo(items[partIndex]) > 0)
              //判断是否应当放在右边区域
            {
                swap(ref items, fromIndex, toIndex);
                return Partition(ref items, partIndex, fromIndex, toIndex - 1);
            }
            else
                return Partition(ref items, partIndex, fromIndex + 1, toIndex);
        }        //当要查找数组中按顺序第m位置的元素时，并不需要对数组排序。
        public static T SelectMinM<T>(T[] items, int m) where T : IComparable<T>
        {
            return SelectMinM(ref items, m-1, 0, items.Length - 1);
        }        private static T SelectMinM<T>(ref T[] items, int m,int fromIndex,
            int toIndex) where T : IComparable<T>
        {
            int p = Partition(ref items, fromIndex, fromIndex + 1, toIndex);
            if (p == m)
                return items[p];
            else if (p < m)
                return SelectMinM(ref items, m, p + 1, toIndex);
            else
                return SelectMinM(ref items, m, fromIndex, p - 1);
        }
    }

我再解释一下，任何一个数组，只要其元素具有IComparable<T>范型，就能进行QuickSort和Partition操作，不论它是什么类型、符合什么接口。这里，这两个方法要比再接口中定义它们强大的多，并且可以完全替代,在算法复用方面给人的思想打开了一个新的窗户，并且也提供了避免拆箱装箱的途径。我的估计，面向对象编程、接口等等现在看起来很高深的知识，将成为很底层的东西，而不是再是程序员的技术水平的指标。

呵呵，又过来看了一下。上面“这两个方法要比再接口中定义它们强大的多”就怕有点误导，我没有把话说清楚！我的意思是说：把处理的对象声明为范型要比声明为接口类型强大的多。注意我是在谈方法的“参数”的多态，而不是在谈方法自身的定义位置。实际上，这个程序是面向过程的风格的。面向对象风格，通常应该把方法中最重要的一个（或者几个）参数类型（或者范型）拿出来，把方法定义到它们内部，变成类型（或者范型）自己的专有功能。实际优化过的代码应该这样的：public static void QuickSort<T>(ref T[] items) where T : IComparable<T>
{
    QuickSort(ref items, 0, items.Length - 1);
}private static void QuickSort<T>(ref T[] items, int fromIndex, int toIndex) where T : IComparable<T>
{
    int p;
    while (fromIndex < toIndex)
    {
        if (fromIndex < toIndex)
            swap(ref items, fromIndex, Rnd.Next(fromIndex + 1, toIndex)); //避免最坏排序，将初始划分元素随机调换
        p = Partition(ref items, fromIndex, fromIndex + 1, toIndex);
        if (p - fromIndex <= toIndex - p)
        {
            QuickSort(ref items, fromIndex, p - 1);
            fromIndex = p + 1;
        }
        else
        {
            QuickSort(ref items, p + 1, toIndex);
            toIndex = p - 1;
        }
    }
}private static void swap<T>(ref T[] items, int index1, int index2)
{
    if (index1 != index2)
    {
        T m = items[index1];
        items[index1] = items[index2];
        items[index2] = m;
    }
}//使用T[]的第一个元素作为划分元素，重新排列T[]。返回划分元素的最终位置。
private static int Partition<T>(ref T[] items, int partIndex, int fromIndex, int toIndex) where T : IComparable<T>
{
    while (true)
        if (fromIndex > toIndex)
        {
            swap(ref items, partIndex, toIndex);
            return toIndex;
        }
        else if (items[fromIndex].CompareTo(items[partIndex]) > 0) //判断是否应当放在右边区域
        {
            swap(ref items, fromIndex, toIndex);
            toIndex -= 1;
        }
        else
            fromIndex += 1;
}//当要查找数组中按顺序第m位置的元素时，并不需要对数组排序。
public static T SelectMinM<T>(T[] items, int m) where T : IComparable<T>
{
    return SelectMinM(ref items, m - 1, 0, items.Length - 1);
}static Random Rnd = new Random();private static T SelectMinM<T>(ref T[] items, int m, int fromIndex, int toIndex) where T : IComparable<T>
{
    int p;
    while (true)
    {
        if (fromIndex < toIndex)
            swap(ref items, fromIndex, Rnd.Next(fromIndex + 1, toIndex)); //避免最坏排序，将初始划分元素随机调换
        p = Partition(ref items, fromIndex, fromIndex + 1, toIndex);
        if (p == m)
            return items[p];
        else if (p < m)
            fromIndex = p + 1;
        else
            toIndex = p - 1;
    }
}

不使用com组件的时候接口没什么太大作用
但使用com组件的时候就不能没有接口

非得这样吗，接口以前在JAVA中接触过，没有深究，C++中有但没仔细研究。那要花上多久时间才弄懂啊。

请楼主理解一下面这个类就是了class 刘著：男,I伪娘接口
{
}

想当然了吧？c++中不用interface这种东西，因为它支持多重继承，于是用不着浪费心情在class之外再搞interface。

调试易

我看了C#接口的概念，可是我无法理解？请用通俗的语言解释并用代码表示，他有什么作用？

解决方案 »