接口慨述.docx
《接口慨述.docx》由会员分享，可在线阅读，更多相关《接口慨述.docx（36页珍藏版）》请在冰豆网上搜索。
接口慨述
第一节接口慨述
接口（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#语言进行组件编程将会给我们带来更大的方便。
知道第二节定义接口
从技术上讲，接口是一组包含了函数型方法的数据结构。
通过这组数据结构，客户代码可以调用组件对象的功能。
定义接口的一般形式为：
[attributes][modifiers]interfaceidentifier[:
base-list]{interface-body}[;]
说明：
1、attributes（可选）：
附加的定义性信息。
2、modifiers（可选）：
允许使用的修饰符有new和四个访问修饰符。
分别是：
new、public、protected、internal、private。
在一个接口定义中同一修饰符不允许出现多次，new修饰符只能出现在嵌套接口中，表示覆盖了继承而来的同名成员。
Thepublic,protected,internal,andprivate修饰符定义了对接口的访问权限。
3、指示器和事件。
4、identifier：
接口名称。
5、base-list（可选）:
包含一个或多个显式基接口的列表，接口间由逗号分隔。
6、interface-body：
对接口成员的定义。
7、接口可以是命名空间或类的成员，并且可以包含下列成员的签名：
方法、属性、索引器。
8、一个接口可从一个或多个基接口继承。
接口这个概念在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"）;
}
}
基接口
一个接口可以从零或多个接口继承，那些被称为这个接口的显式基接口。
当一个接口有比零多的显式基接口时，那么在接口的定义中的形式为，接口标识符后面跟着由一个冒号":
"和一个用逗号","分开的基接口标识符列表。
接口基：
:
接口类型列表说明：
1、一个接口的显式基接口必须至少同接口本身一样可访问。
例如，在一个公共接口的基接口中指定一个私有或内部的接口是错误的。
2、一个接口直接或间接地从它自己继承是错误的。
3、接口的基接口都是显式基接口，并且是它们的基接口。
换句话说，基接口的集合完全由显式基接口和它们的显式基接口等等组成。
在下面的例子中
interfaceIControl{
voidPaint（）;
}
interfaceITextBox:
IControl{
voidSetText（stringtext）;
}
interfaceIListBox:
IControl{
voidSetItems（string[]items）;
}
interfaceIComboBox:
ITextBox,IListBox{}
IComboBox的基接口是IControl,ITextBox,和IlistBox。
4、一个接口继承它的基接口的所有成员。
换句话说，上面的接口IComboBox就像Paint一样继承成员SetText和SetItems。
5、一个实现了接口的类或结构也隐含地实现了所有接口的基接口。
接口主体
一个接口的接口主体定义接口的成员。
interface-body:
{interface-member-declarationsopt}
定义接口主要是定义接口成员，请看下一节--定义接口成员。
了什么是接口，接下来就是怎样定义接口,请看下一节--定义接口。
第三节定义接口成员
接口可以包含一个和多个成员，这些成员可以是方法、属性、索引指示器和事件，但不能是常量、域、操作符、构造函数或析构函数，而且不能包含任何静态成员。
接口定义创建新的定义空间，并且接口定义直接包含的接口成员定义将新成员引入该定义空间。
说明：
1、接口的成员是从基接口继承的成员和由接口本身定义的成员。
2、接口定义可以定义零个或多个成员。
接口的成员必须是方法、属性、事件或索引器。
接口不能包含常数、字段、运算符、实例构造函数、析构函数或类型，也不能包含任何种类的静态成员。
3、定义一个接口，该接口对于每种可能种类的成员都包含一个：
方法、属性、事件和索引器。
4、接口成员默认访问方式是public。
接口成员定义不能包含任何修饰符，比如成员定义前不能加abstract，public，protected，internal，private，virtual，override或static修饰符。
5、接口的成员之间不能相互同名。
继承而来的成员不用再定义，但接口可以定义与继承而来的成员同名的成员，这时我们说接口成员覆盖了继承而来的成员，这不会导致错误，但编译器会给出一个警告。
关闭警告提示的方式是在成员定义前加上一个new关键字。
但如果没有覆盖父接口中的成员，使用new关键字会导致编译器发出警告。
6、方法的名称必须与同一接口中定义的所有属性和事件的名称不同。
此外，方法的签名必须与同一接口中定义的所有其他方法的签名不同。
7、属性或事件的名称必须与同一接口中定义的所有其他成员的名称不同。
8、一个索引器的签名必须区别于在同一接口中定义的其他所有索引器的签名。
9、接口方法声明中的属性（attributes）,返回类型（return-type）,标识符（identifier）,和形式参数列表（formal-parameter-lis）与一个类的方法声明中的那些有相同的意义。
一个接口方法声明不允许指定一个方法主体，而声明通常用一个分号结束。
10、接口属性声明的访问符与类属性声明的访问符相对应，除了访问符主体通常必须用分号。
因此，无论属性是读写、只读或只写，访问符都完全确定。
11、接口索引声明中的属性（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#中取消了类的多继承机制的原因之一），这时需要进行显式的定义：
usingSystem;
interfaceISequence{
intCount{get;set;}
}
interfaceIRing{
voidCount（inti）;
}
interfaceIRingSequence:
ISequence,IRing{}
classCTest{
voidTest（IRingSequencers）{
//rs.Count
（1）;错误,Count有二义性
//rs.Count=1;错误,Count有二义性
（（ISequence）rs）.Count=1;//正确
（（IRing）rs）.Count
（1）;//正确调用IRing.Count
}
}
上面的例子中，前两条语句rs.Count
（1）和rs.Count=1会产生二义性，从而导致编译时错误，因此必须显式地给rs指派父接口类型，这种指派在运行时不会带来额外的开销。
再看下面的例子：
usingSystem;
interfaceIInteger{
voidAdd（inti）;
}
interfaceIDouble{
voidAdd（doubled）;
}
interfaceINumber:
IInteger,IDouble{}
classCMyTest{
voidTest（INumberNum）{
//Num.Add
（1）;错误
Num.Add（1.0）;//正确
（（IInteger）n）.Add
（1）;//正确
（（IDouble）n）.Add
（1）;//正确
}
}
调用Num.Add
（1）会导致二义性，因为候选的重载方法的参数类型均适用。
但是，调用Num.Add（1.0）是允许的，因为1.0是浮点数参数类型与方法IInteger.Add（）的参数类型不一致，这时只有IDouble.Add才是适用的。
不过只要加入了显式的指派，就决不会产生二义性。
接口的多重继承的问题也会带来成员访问上的问题。
例如：
interfaceIBase{
voidFWay（inti）;
}
interfaceILeft:
IBase{
newvoidFWay（inti）;
}
interfaceIRight:
IBase
{voidG（）;}
interfaceIDerived:
ILeft,IRight{}
classCTest{
voidTest（IDerivedd）{
d.FWay
（1）;//调用ILeft.FWay
（（IBase）d）.FWay
（1）;//调用IBase.FWay
（（ILeft）d）.FWay
（1）;//调用ILeft.FWay
（（IRight）d）.FWay
（1）;//调用IBase.FWay
}
}
上例中，方法IBase.FWay在派生的接口ILeft中被Ileft的成员方法FWay覆盖了。
所以对d.FWay
（1）的调用实际上调用了。
虽然从IBase->IRight->IDerived这条继承路径上来看,ILeft.FWay方法是没有被覆盖的。
我们只要记住这一点：
一旦成员被覆盖以后，所有对其的访问都被覆盖以后的成员"拦截"了。
类对接口的实现
前面我们已经说过，接口定义不包括方法的实现部分。
接口可以通过类或结构来实现。
我们主要讲述通过类来实现接口。
用类来实现接口时，接口的名称必须包含在类定义中的基类列表中。
下面的例子给出了由类来实现接口的例子。
其中ISequence为一个队列接口，提供了向队列尾部添加对象的成员方法Add（），IRing为一个循环表接口，提供了向环中插入对象的方法Insert（objectobj），方法返回插入的位置。
类RingSquence实现了接口ISequence和接口IRing。
usingSystem;
interfaceISequence{
objectAdd（）;
}
interfaceISequence{
objectAdd（）;
}
interfaceIRing{
intInsert（objectobj）;
}
classRingSequence:
ISequence,IRing
{
publicobjectAdd（）{…}
publicintInsert（objectobj）{…}
}
如果类实现了某个接口，类也隐式地继承了该接口的所有父接口，不管这些父接口有没有在类定义的基类表中列出。
看下面的例子：
usingSystem;
interfaceIControl{
voidPaint（）;
}
interfaceITextBox:
IControl{
voidSetText（stringtext）;
}
interfaceIListBox:
IControl{
voidSetItems（string[]items）;
}
interfaceIComboBox:
ITextBox,IListBox{}
这里,接口IcomboBox继承了ItextBox和IlistBox。
类TextBox不仅实现了接口ITextBox，还实现了接口ITextBox的父接口IControl。
前面我们已经看到，一个类可以实现多个接口。
再看下面的例子：
interfaceIDataBound{
voidBind（Binderb）;
}
publicclassEditBox:
Control,IControl,IDa
升级会员 