全面剖析C#接口编程之定义接口

从技术上讲，接口是一组包含了函数型方法的数据结构。通过这组数据结构，客户代码可以调用组件对象的功能。
定义接口的一般形式为：

[attributes][modifiers]interfaceidentifier[:base-list]{interface-body}[;]

说明：
·attributes（可选）：附加的定义性信息。
·modifiers（可选）：允许使用的修饰符有new和四个访问修饰符。分别是：new、public、protected、internal、private。在一个接口定义中同一修饰符不允许出现多次，new修饰符只能出现在嵌套接口中，表示覆盖了继承而来的同名成员。Thepublic,protected,internal,andprivate修饰符定义了对接口的访问权限。
·指示器和事件。
·identifier：接口名称。
·base-list（可选）:包含一个或多个显式基接口的列表，接口间由逗号分隔。
·interface-body：对接口成员的定义。
·接口可以是命名空间或类的成员，并且可以包含下列成员的签名：方法、属性、索引器。
·一个接口可从一个或多个基接口继承。
接口这个概念在C#和Java中非常相似。接口的关键词是interface，一个接口可以扩展一个或者多个其他接口。按照惯例，接口的名字以大写字母"I"开头。下面的代码是C#接口的一个例子，它与Java中的接口完全一样：

interfaceIShape{ voidDraw(); }

如果你从两个或者两个以上的接口派生，父接口的名字列表用逗号分隔，如下面的代码所示：

interfaceINewInterface:IParent1,IParent2{}

然而，与Java不同，C#中的接口不能包含域（Field）。另外还要注意，在C#中，接口内的所有方法默认都是公用方法。在Java中，方法定义可以带有public修饰符（即使这并非必要），但在C#中，显式为接口的方法指定public修饰符是非法的。例如，下面的C#接口将产生一个编译错误。

interfaceIShape{publicvoidDraw();}

下面的例子定义了一个名为IControl的接口，接口中包含一个成员方法Paint：

interfaceIControl{ voidPaint(); }

在下例中，接口IInterface从两个基接口IBase1和IBase2继承：

interfaceIInterface:IBase1,IBase2{ voidMethod1(); voidMethod2(); }

接口可由类实现。实现的接口的标识符出现在类的基列表中。例如：

classClass1:Iface1,Iface2{ //class成员。 }

类的基列表同时包含基类和接口时，列表中首先出现的是基类。例如：

classClassA:BaseClass,Iface1,Iface2{ //class成员。 }

以下的代码段定义接口IFace，它只有一个方法：

interfaceIFace{ voidShowMyFace(); }

不能从这个定义实例化一个对象，但可以从它派生一个类。因此，该类必须实现ShowMyFace抽象方法：

classCFace:IFace { publicvoidShowMyFace(){ Console.WriteLine("implementation"); } }

基接口
一个接口可以从零或多个接口继承，那些被称为这个接口的显式基接口。当一个接口有比零多的显式基接口时，那么在接口的定义中的形式为，接口标识符后面跟着由一个冒号":"和一个用逗号","分开的基接口标识符列表。
接口基：
接口类型列表说明：
·一个接口的显式基接口必须至少同接口本身一样可访问。例如，在一个公共接口的基接口中指定一个私有或内部的接口是错误的。
·一个接口直接或间接地从它自己继承是错误的。
·接口的基接口都是显式基接口，并且是它们的基接口。换句话说，基接口的集合完全由显式基接口和它们的显式基接口等等组成。在下面的例子中

interfaceIControl{ voidPaint(); } interfaceITextBox:IControl{ voidSetText(stringtext); } interfaceIListBox:IControl{ voidSetItems(string[]items); } interfaceIComboBox:ITextBox,IListBox{}

IComboBox的基接口是IControl,ITextBox,和IlistBox。
·一个接口继承它的基接口的所有成员。换句话说，上面的接口IComboBox就像Paint一样继承成员SetText和SetItems。
·一个实现了接口的类或结构也隐含地实现了所有接口的基接口。
接口主体
一个接口的接口主体定义接口的成员。

interface-body: {interface-member-declarationsopt}

接口可以包含一个和多个成员，这些成员可以是方法、属性、索引指示器和事件，但不能是常量、域、操作符、构造函数或析构函数，而且不能包含任何静态成员。接口定义创建新的定义空间，并且接口定义直接包含的接口成员定义将新成员引入该定义空间。
说明：
·接口的成员是从基接口继承的成员和由接口本身定义的成员。
·接口定义可以定义零个或多个成员。接口的成员必须是方法、属性、事件或索引器。接口不能包含常数、字段、运算符、实例构造函数、析构函数或类型，也不能包含任何种类的静态成员。
·定义一个接口，该接口对于每种可能种类的成员都包含一个：方法、属性、事件和索引器。
·接口成员默认访问方式是public。接口成员定义不能包含任何修饰符，比如成员定义前不能加abstract，public，protected，internal，private，virtual，override或static修饰符。
·接口的成员之间不能相互同名。继承而来的成员不用再定义，但接口可以定义与继承而来的成员同名的成员，这时我们说接口成员覆盖了继承而来的成员，这不会导致错误，但编译器会给出一个警告。关闭警告提示的方式是在成员定义前加上一个new关键字。但如果没有覆盖父接口中的成员，使用new关键字会导致编译器发出警告。
·方法的名称必须与同一接口中定义的所有属性和事件的名称不同。此外，方法的签名必须与同一接口中定义的所有其他方法的签名不同。
·属性或事件的名称必须与同一接口中定义的所有其他成员的名称不同。
·一个索引器的签名必须区别于在同一接口中定义的其他所有索引器的签名。
·接口方法声明中的属性（attributes）,返回类型（return-type）,标识符（identifier）和形式参数列表（formal-parameter-lis）与一个类的方法声明中的那些有相同的意义。一个接口方法声明不允许指定一个方法主体，而声明通常用一个分号结束。
·接口属性声明的访问符与类属性声明的访问符相对应，除了访问符主体通常必须用分号。因此，无论属性是读写、只读或只写，访问符都完全确定。
·接口索引声明中的属性（attributes），类型（type）和形式参数列表（formal-parameter-list）与类的索引声明的那些有相同的意义。
下面例子中接口IMyTest包含了索引指示器、事件E、方法F、属性P这些成员：

interfaceIMyTest{ stringthis[intindex]{get;set;} eventEventHandlerE; voidF(intvalue); stringP{get;set;} } publicdelegatevoidEventHandler(objectsender,EventArgse);

下面例子中接口IStringList包含每个可能类型成员的接口：一个方法，一个属性，一个事件和一个索引。

publicdelegatevoidStringListEvent(IStringListsender); publicinterfaceIStringList { voidAdd(strings); intCount{get;} eventStringListEventChanged; stringthis[intindex]{get;set;} }

接口成员的全权名
使用接口成员也可采用全权名（fullyqualifiedname）。接口的全权名称是这样构成的。接口名加小圆点"."再跟成员名比如对于下面两个接口：

interfaceIControl{ voidPaint(); } interfaceITextBox:IControl{ voidGetText(stringtext); }

其中Paint的全权名是IControl.Paint，GetText的全权名是ITextBox.GetText。当然，全权名中的成员名称必须是在接口中已经定义过的，比如使用ITextBox.Paint.就是不合理的。
如果接口是名字空间的成员，全权名还必须包含名字空间的名称。

namespaceSystem { publicinterfaceIDataTable{ objectClone(); } }

那么Clone方法的全权名是System.IDataTable.Clone。
定义好了接口，接下来我们关心的就是怎样实现对接口的访问。这部分内容，我将在下一篇文章中和您进一步探讨。

什么是接口？其实，接口简单理解就是一种约定，使得实现接口的类或结构在形式上保持一致。个人觉得，使用接口可以使程序更加清晰和条理化，这就是接口的好处，但并不是所有的编程语言都支持接口，C#是支持接口的。注意，虽然在概念上，C#接口类似于COM接口，但他们的底层结构是不同的。那么，我们来看一下如何声明和使用接口。

　　声明接口

　　声明接口在语法上和声明抽象类完全相同，例如这里有一个银行账户的接口：
　　

[align=left]publicinterfaceIBankAccount
{
voidPayIn(decimalamount);
boolWithdraw(decimalamount);

decimalBalance
{
get;
}
}[/align]

　　注意：接口中只能包含方法、属性、索引器和事件的声明。不允许声明成员上的修饰符，即使是pubilc都不行，因为接口成员总是公有的，也不能声明为虚拟和静态的。如果需要修饰符，最好让实现类来声明。

　　使用接口的例子

　　这是书上的一个简单的例子，但足以说明接口的使用方法。
　　一个银行账户的接口，两个不同银行账户的实现类，都继承于这个接口。接口声明如上。下面是两个账户类：

[align=left]classSaverAccount:IBankAccount
{
privatedecimalbalance;

publicdecimalBalance
{
get
{
returnbalance;
}
}

publicvoidPayIn(decimalamount)
{
balance+=amount;
}

publicboolWithdraw(decimalamount)
{
if(balance>=amount)
{
balance-=amount;
returntrue;
}
Console.WriteLine("Withdrawfailed.");
returnfalse;
}

publicoverridestringToString()
{
returnString.Format("VenusBankSaver:Balance={0,6:C}",balance);
}
}[/align]

[align=left]classGoldAccount:IBankAccount
{
privatedecimalbalance;

publicdecimalBalance
{
get
{
returnbalance;
}
}

publicvoidPayIn(decimalamount)
{
balance+=amount;
}

publicboolWithdraw(decimalamount)
{
if(balance>=amount)
{
balance-=amount;
returntrue;
}
Console.WriteLine("Withdrawfailed.");
returnfalse;
}

publicoverridestringToString()
{
returnString.Format("JupiterBankSaver:Balance={0,6:C}",balance);
}
}[/align]

　　可见，这两个实现类多继承了IBankAccount接口，因此它们必须要实现接口中的所有声明的方法。要不然，编译就会出错。让我们来测试一下，下面是测试代码：

[align=left]staticvoidMain(string[]args)
{
IBankAccountvenusAccount=newSaverAccount();
IBankAccountjupiterAccount=newCurrentAccount();
venusAccount.PayIn(200);
jupiterAccount.PayIn(500);
Console.WriteLine(venusAccount.ToString());
jupiterAccount.PayIn(400);
jupiterAccount.Withdraw(500);
jupiterAccount.Withdraw(100);
Console.WriteLine(jupiterAccount.ToString());

}[/align]

　　请注意开头两句，我们把它们声明为IBankAccount引用的方式，而没有声明为类的引用，为什么呢？因为，这样我们就可以让它指向执行这个接口的任何类的实例了，比较灵活。但这也有个缺点，如果我们要执行不属于接口的方法，比如这里重载的ToString()方法，就要先把接口的引用强制转换成合适的类型了。

　　接口的继承

　　接口也可以彼此继承，就象类的继承一样。比如我们又声明一个接口ITransferBankAccount，它继承于IBankAccount接口。

[align=left]interfaceITransferBankAccount:IBankAccount
{
boolTransferTo(IBankAccountdestination,decimalamount);
}[/align]

　　在这个接口中，又新增加了一个方法TransferTo()，所以如果我们要写一个类从ITransferBankAccount继承的话，就必须要实现IBankAccount和ITransferBankAccount两个接口所有的方法声明。即：


classCurrentAccount:ITransferBankAccount






{


privatedecimalbalance;




publicdecimalBalance






{


get






{


returnbalance;


}


}




publicvoidPayIn(decimalamount)






{


balance+=amount;


}




publicboolWithdraw(decimalamount)






{


if(balance>=amount)






{


balance-=amount;


returntrue;


}


Console.WriteLine("Withdrawfailed.");


returnfalse;


}




publicoverridestringToString()






{


returnString.Format("JupiterBankSaver:Balance={0,6:C}",balance);


}




publicboolTransferTo(IBankAccountdestination,decimalamount)






{


if(Withdraw(amount))






{


destination.PayIn(amount);


returntrue;


}


else






{


returnfalse;


}


}


}

　　总结起来说，使用C#接口应注意几个问题：

　　1、C#中的接口是独立于类来定义的。这与C++模型是对立的，在C++中接口实际上就是抽象基类。
　　2、接口和类都可以继承多个接口。
　　3、类可以继承一个基类，接口根本不能继承类。这种模型避免了C++的多继承问题，C++中不同基类中的实现可能出现冲突。因此也不再需要诸如虚拟继承和显式作用域这类复杂机制。C#的简化接口模型有助于加快应用程序的开发。
　　4、一个接口定义一个只有抽象成员的引用类型。C#中一个接口实际所做的，仅仅只存在着方法标志，但根本就没有执行代码。这就暗示了不能实例化一个接口，只能实例化一个派生自该接口的对象。
　　5、接口可以定义方法、属性和索引。所以，对比一个类，接口的特殊性是：当定义一个类时，可以派生自多重接口，而你只能可以从仅有的一个类派生。

第一节接口慨述

　　接口（interface）用来定义一种程序的协定。实现接口的类或者结构要与接口的定义严格一致。有了这个协定，就可以抛开编程语言的限制（理论上）。接口可以从多个基接口继承，而类或结构可以实现多个接口。接口可以包含方法、属性、事件和索引器。接口本身不提供它所定义的成员的实现。接口只指定实现该接口的类或接口必须提供的成员。

　　接口好比一种模版，这种模版定义了对象必须实现的方法，其目的就是让这些方法可以作为接口实例被引用。接口不能被实例化。类可以实现多个接口并且通过这些实现的接口被索引。接口变量只能索引实现该接口的类的实例。例子：

interfaceIMyExample{
　stringthis[intindex]{get;set;}
　eventEventHandlerEven;
　voidFind(intvalue);
　stringPoint{get;set;}
}
publicdelegatevoidEventHandler(objectsender,Evente);

　　上面例子中的接口包含一个索引this、一个事件Even、一个方法Find和一个属性Point。

　　接口可以支持多重继承。就像在下例中，接口"IComboBox"同时从"ITextBox"和"IListBox"继承。

interfaceIControl{
voidPaint();
}
interfaceITextBox:IControl{
voidSetText(stringtext);
}
interfaceIListBox:IControl{
voidSetItems(string[]items);
}
interfaceIComboBox:ITextBox,IListBox{}

　　类和结构可以多重实例化接口。就像在下例中，类"EditBox"继承了类"Control"，同时从"IDataBound"和"IControl"继承。

interfaceIDataBound{
　voidBind(Binderb);
}
publicclassEditBox:Control,IControl,IDataBound{
　publicvoidPaint();
　publicvoidBind(Binderb){...}
}

　　在上面的代码中，"Paint"方法从"IControl"接口而来；"Bind"方法从"IDataBound"接口而来，都以"public"的身份在"EditBox"类中实现。

　　说明：

　　1、C#中的接口是独立于类来定义的。这与C++模型是对立的，在C++中接口实际上就是抽象基类。

　　2、接口和类都可以继承多个接口。

　　3、而类可以继承一个基类，接口根本不能继承类。这种模型避免了C++的多继承问题，C++中不同基类中的实现可能出现冲突。因此也不再需要诸如虚拟继承和显式作用域这类复杂机制。C#的简化接口模型有助于加快应用程序的开发。

　　4、一个接口定义一个只有抽象成员的引用类型。C#中一个接口实际所做的，仅仅只存在着方法标志，但根本就没有执行代码。这就暗示了不能实例化一个接口，只能实例化一个派生自该接口的对象。

　　5、接口可以定义方法、属性和索引。所以，对比一个类，接口的特殊性是：当定义一个类时，可以派生自多重接口，而你只能可以从仅有的一个类派生。

接口与组件

　　接口描述了组件对外提供的服务。在组件和组件之间、组件和客户之间都通过接口进行交互。因此组件一旦发布，它只能通过预先定义的接口来提供合理的、一致的服务。这种接口定义之间的稳定性使客户应用开发者能够构造出坚固的应用。一个组件可以实现多个组件接口，而一个特定的组件接口也可以被多个组件来实现。

　　组件接口必须是能够自我描述的。这意味着组件接口应该不依赖于具体的实现，将实现和接口分离彻底消除了接口的使用者和接口的实现者之间的耦合关系，增强了信息的封装程度。同时这也要求组件接口必须使用一种与组件实现无关的语言。目前组件接口的描述标准是IDL语言。

　　由于接口是组件之间的协议，因此组件的接口一旦被发布，组件生产者就应该尽可能地保持接口不变，任何对接口语法或语义上的改变，都有可能造成现有组件与客户之间的联系遭到破坏。

　　每个组件都是自主的，有其独特的功能，只能通过接口与外界通信。当一个组件需要提供新的服务时，可以通过增加新的接口来实现。不会影响原接口已存在的客户。而新的客户可以重新选择新的接口来获得服务。

　　组件化程序设计

　　组件化程序设计方法继承并发展了面向对象的程序设计方法。它把对象技术应用于系统设计，对面向对象的程序设计的实现过程作了进一步的抽象。我们可以把组件化程序设计方法用作构造系统的体系结构层次的方法，并且可以使用面向对象的方法很方便地实现组件。

　　组件化程序设计强调真正的软件可重用性和高度的互操作性。它侧重于组件的产生和装配，这两方面一起构成了组件化程序设计的核心。组件的产生过程不仅仅是应用系统的需求，组件市场本身也推动了组件的发展，促进了软件厂商的交流与合作。组件的装配使得软件产品可以采用类似于搭积木的方法快速地建立起来，不仅可以缩短软件产品的开发周期，同时也提高了系统的稳定性和可靠性。

　　组件程序设计的方法有以下几个方面的特点：

　　1、编程语言和开发环境的独立性；

　　2、组件位置的透明性；

　　3、组件的进程透明性；

　　4、可扩充性；

　　5、可重用性；

　　6、具有强有力的基础设施；

　　7、系统一级的公共服务；

　　C#语言由于其许多优点，十分适用于组件编程。但这并不是说C#是一门组件编程语言，也不是说C#提供了组件编程的工具。我们已经多次指出，组件应该具有与编程语言无关的特性。请读者记住这一点：组件模型是一种规范，不管采用何种程序语言设计组件，都必须遵守这一规范。比如组装计算机的例子，只要各个厂商为我们提供的配件规格、接口符合统一的标准，这些配件组合起来就能协同工作，组件编程也是一样。我们只是说，利用C#语言进行组件编程将会给我们带来更大的方便。

　　知道了什么是接口，接下来就是怎样定义接口,请看下一节--定义接口。

接口的相关陈述
１．一个接口定义了一个契约。
２．接口可以包容方法、C#属性、事件、以及索引器。
３．在一个接口声明中，我们可以声明零个或者多个成员。
４．所有接口成员的默认访问类型都是public。
５．如果在接口成员声明中包括了任何修饰符，那么会产生一个编译器错误。
６．与一个非抽象类类似，一个抽象类必须提供接口中所有成员的实现，只要这些成员在这个类的基类中出现过。

接口的理解
1.面向接口编程利用OO的一个基本性质——多态，相同方法不同表现。可以这样想一下，client编写自己程序的时候，如果直接面向一个具体类写程序，那这个程序有个风吹草动的，那client就要受到影响，但如果面向一个接口就不同了，某个具体类变了，只知接口，不知具体类的client就可以完全不动。都说上层领导比较好当，因为可以干的事通常对老百姓来说是虚的，越虚就越不容易错。
这个道理在OO中也是适用的。
2.换个视角看，面向接口编程反映OO的另一个方面——封装，接口将具体实现封装了起来，可以不影响客户的情况下切换实现
3.接口的作用，一言以蔽之，就是标志类的类别（typeofclass）。把不同类型的类归于不同的接口，可以更好的管理他们。OO的精髓，我以为，是对对象的抽象，最能体现这一点的就是接口。为什么我们讨论设计模式都只针对具备了抽象能力的语言（比如c++、java、c#等），就是因为设计模式所研究的，实际上就是如何合理的去抽象。（cowboy的名言是“抽象就是抽去像的部分”，看似调侃，实乃至理）。

空接口的使用
在接口使用的时候,空接口有2种情况:
1.类似于ObjectBuilder中的IBuilderPolicy,他们往往是做一个标记,表示需要某个功能.当然你也可以这么用,来表示你的类具有某个功能,实现了你的某个接口.
[align=left]namespaceMicrosoft.Practices.ObjectBuilder[/align]
[align=left]{[/align]
[align=left]///[/align]
[align=left]///Representsabuilderpolicyinterface.Sincetherearenofixedrequirements[/align]
[align=left]///forpolicies,itactsasamarkerinterfacefromwhichtoderiveallother[/align]
[align=left]///policyinterfaces.[/align]
[align=left]///[/align]
[align=left]publicinterfaceIBuilderPolicy[/align]
[align=left]{[/align]
[align=left]}[/align]
[align=left]}[/align]

[align=left]2.你的接口继承了别的接口(非空),你的接口本身没有声明函数.这种情况一般是你不希望用户使用父接口作为参数类型,因为他们的用途可能不同,此时就可以用空接口来实现.[/align]
[align=left][/align]
[align=left]interfaceText[/align]
[align=left]{[/align]
[align=left]stringgetText();[/align]
[align=left]}[/align]
[align=left][/align]
[align=left]interfaceSqlText:Text[/align]
[align=left]{[/align]
[align=left][/align]
[align=left]}[/align]
[align=left]可以看到,Text接口是用于返回一个字符串.而SqlText是一个空接口,它继承了Text接口.也就是说SqlText也是一种Text.但是我们可以知道,任何一个字符串不一定是Sql字符串,所以此时声明了一个SqlText接口来用于表名当前的字符串是一个Sql字符串.你的函数可以这样声明:[/align]
[align=left]publicvoiddoQuery(SqlTextsqlText)[/align]
[align=left]而不是这样：[/align]
[align=left]publicvoiddoQuery(Texttext)[/align]
[align=left]避免用户产生歧义的想法,一眼看去,就明白应该传入一个Sql字符串.[/align]
接口的成员为什么没有委托
我们都知道C#的接口是可以包含事件的，其实当我们看到事件的时候，很容易就会想到委托，委托是事件的基础，如果对委托和事件不是特别清楚的程序员就一定不会明白，为什么C#接口中可以包含事件而不能有委托呢。其实简单的说法就是委托也是类型，delegate关键字引入的是一个新的类型，所以一个C#接口无法包容一个委托并把它当作成员；而event关键字引入的是一个新的成员，因此事件可以归人接口。理解这点，我们要从C#接口的使命说起，C#接口是一个契约，规范了接口实现者的行为，而不是要有些什么。很简单，例如“党员”是个接口，它肯定有个动作是“为人民服务”，“某某党员”实现了“党员”这个接口，那么“某某党员”肯定也要“为人民服务”，至于你“某某党员”是否必须拥用“电脑”、“小孩”。那么“党员”这个接口中肯定不会有规定。这也就是接口的目的，规范了实现者的一些行为。所以C#接口的成员都是方法，不会有其它了。稍有c#常识的程序员都明白，c#中的属性，其实就是两个方法，一个Set方法，一个Get方法，同样事件和索引器也都是方法，请看下面的接口：
[align=left]publicinterfaceIDrawingObject[/align]
[align=left]{[/align]
[align=left]eventEventHandlerOnDraw;[/align]
[align=left]stringName[/align]
[align=left]{[/align]
[align=left]get;[/align]
[align=left]set;[/align]
[align=left]}[/align]
[align=left]intthis[intindex][/align]
[align=left]{[/align]
[align=left]get;[/align]
[align=left]set;[/align]
[align=left]}[/align]
[align=left]voidSetValue();[/align]
[align=left]}[/align]
该接口包含了c#接口所能接纳的所有成员，事件，属性，索引器，方法。把该接口编译后，我们用MSILDisassembler工具查看一下：



这下大家都明白了，其实属性Name对应于Get_Name(),Set_Name()这两个方法，事件OnDraw对应于add_OnDraw(),remove_OnDraw()这两个方法，索引器对应于get_Item(),set_Item()这两个方法。在看下面的委托和类的定义：
[align=left]publicdelegatevoidTestEventDelegate(objectsender,System.EventArgse);[/align]
[align=left]classTestClass[/align]
[align=left]{[/align]
[align=left]publicvoidSetValue()[/align]
[align=left]{}[/align]
[align=left]}[/align]



看到了吧，定义一个委托和定义一个类是没有什么区别的，都是定义了个新的类型。所以C#接口是不能有委托的，除非微软告诉我们C#接口中是可以定义类的。

通过学习对C#中接口的作用有了更进一步的理解，拿出来跟大家分享一下，有说的不对的地方请大家指教。
我在上一篇帖子（http://www.programfan.com/club/showbbs.asp?id=150228）中只是简单的谈了一下接口的作用，有兴趣的朋友可以去看一下。
言归正传：
假设我们公司有两种程序员：VB程序员，指的是用VB写程序的程序员，用clsVBProgramer这个类表示；Delphi程序员指的是用Delphi写程序的程序员，用clsDelphiProgramer这个类来表示。每个类都有一个WriteCode()方法。定义如下：

classclsVBProgramer()
{
....
WriteCode()
{
//用VB语言写代码；
}
....
}

classclsDelphiProgramer()
{
....
WriteCode()
{
//用Delphi语言写代码；
}
....
}

现在公司来了一个项目，要求派某个程序员写一个程序。
classclsProject()
{
....
WritePrograme(clsVBProgramerprogramer)//用VB写代码
{
programer.WriteCode();
}
WritePrograme(clsDelphiProgramerprogramer)//重载方法，用Delphi写代码
{
programer.WriteCode();
}
......
}
在主程序中我们可以这样写：
main()
{
clsProjectproj=newclsProject;
//如果需要用VB写代码
clsVBProgramerprogramer1=newclsVBProgramer;
proj.WritePrograme(programer1);
//如果需要用Delphi写代码
clsDelphiProgramerprogramer2=newclsDelphiProgramer;
proj.WritePrograme(programer2);
}

但是如果这时公司又来了一个C#程序员，我们怎么改这段程序，使它能够实现用C#写程序的功能呢？我们需要增加一个新类clsCSharpProgramer,同时在此clsProject这个类中要再次重载WritePrograme（clsCSharpProgramerprogramer）方法。这下麻烦多了。如果还有C程序员，C++程序员，JAVA程序员呢。麻烦大了！

但是如果改用接口，就完全不一样了：
首先声明一个程序员接口：
interfaceIProgramer()
{
WriteCode();
}
然后声明两个类，并实现IProgramer接口：
classclsVBProgramer():IProgramer
{
....
WriteCode()
{
//用VB语言写代码；
}
....
}

classclsDelphiProgramer():IProgramer
{
....
WriteCode()
{
//用Delphi语言写代码；
}
....
}
对clsProject这个类进行一下修改：
classclsProject()
{
....
WritePrograme(IProgramerprogramer)
{
programer.WriteCode();//写代码
}
......
}

main()
{
clsProjectproj=newclsProject;
IProgramerprogramer;
//如果需要用VB写代码
programer=newclsVBProgramer;
proj.WritePrograme(programer);
//如果需要用Delphi写代码
programer=newclsDelphiProgramer;
proj.WritePrograme(programer);
}
如果再有C#，C，C++，JAVA这样的程序员添加进来的话，我们只需把它们相关的类加进来，然后在main()中稍做修改就OK了。扩充性特别好！

另外我们如果把clsProject这个类封成一个组件，那么当我们的用户需要要扩充功能的时候，我们只需要在外部做很小的修改就能实现，可以说根本就用不着改动我们已经封好组件！是不是很方便，很强大！

C#中的接口和Java中的接口差不多，但是有更大的弹性。类可以随意地显式实现某个接口：

publicinterfaceITeller

{

voidNext();

}

publicinterfaceIIterator

{

voidNext();

}

publicclassClark:ITeller,IIterator

{

voidITeller.Next(){}

voidIIterator.Next(){}

}

这给实现接口的类带来了两个好处。其一，一个类可以实现若干接口而不必担心命名冲突问题。其二，如果某方法对一般用户来说没有用的话，类能够隐藏该方法。显式实现的方法的调用，需把类【译注：应该是对象】造型转换为接口：

Clarkclark=newClark();

((ITeller)clark).Next();