3、重新实现接口

　　 我们已经介绍过，派生类可以对基类中已经定义的成员方法进行重载。类似的概念引入到类对接口的实现中来，叫做接口的重实现（re-implementation）。继承了接口实现的类可以对接口进行重实现。这个接口要求是在类定义的基类列表中出现过的。对接口的重实现也必须严格地遵守首次实现接口的规则，派生的接口映射不会对为接口的重实现所建立的接口映射产生任何影响。

　　 下面的代码给出了接口重实现的例子：

interface IControl {
　 void Paint( ) ;
　 class Control: IControl
　 void IControl.Paint( ) {…}
　 class MyControl: Control, IControl
　 public void Paint( ) {}
}

　　 实际上就是：Control把IControl.Paint映射到了Control.IControl.Paint上，但这并不影响在MyControl中的重实现。在MyControl中的重实现中，IControl.Paint被映射到MyControl.Paint 之上。

　　 在接口的重实现时，继承而来的公有成员定义和继承而来的显式接口成员的定义参与到接口映射的过程。

using System ;
interface IMethods {
　 void F( ) ;
　 void G( ) ;
　 void H( ) ;
　 void I( ) ;
}
class Base: IMethods {
　 void IMethods.F( ) { }
　 void IMethods.G( ) { }
　 public void H( ) { }
　 public void I( ) { }
}
class Derived: Base, IMethods {
　 public void F( ) { }
　 void IMethods.H( ) { }
}

　　 这里，接口IMethods在Derived中的实现把接口方法映射到了Derived.F,Base.IMethods.G, Derived.IMethods.H, 还有Base.I。前面我们说过，类在实现一个接口时，同时隐式地实现了该接口的所有父接口。同样，类在重实现一个接口时同时，隐式地重实现了该接口的所有父接口。

using System ;
interface IBase {
　 void F( ) ;
}
interface IDerived: IBase {
　 void G( ) ;
}
class C: IDerived {
　 void IBase.F( ) {
　 //对F 进行实现的代码…
}
void IDerived.G( ) {
　 //对G 进行实现的代码…
}
}
class D: C, IDerived {
　 public void F( ) {
　 //对F 进行实现的代码…
}
public void G( ) {
　 //对G 进行实现的代码…
}
}

　　 这里，对IDerived的重实现也同样实现了对IBase的重实现，把IBase.F 映射到了D.F。
4、映射接口

　　 类必须为在基类表中列出的所有接口的成员提供具体的实现。在类中定位接口成员的实现称之为接口映射（interface mapping ）。

　　 映射，数学上表示一一对应的函数关系。接口映射的含义也是一样，接口通过类来实现，那么对于在接口中定义的每一个成员，都应该对应着类的一个成员来为它提供具体的实现。

　　 类的成员及其所映射的接口成员之间必须满足下列条件：

　　 1、如果A和B都是成员方法，那么A和B的名称、类型、形参表（包括参数个数和每一个参数的类型）都应该是一致的。

　　 2、如果A和B都是属性，那么A和B的名称、类型应当一致，而且A和B的访问器也是类似的。但如果A不是显式接口成员执行体，A允许增加自己的访问器。

　　 3、如果A和B都是时间那么A和B的名称、类型应当一致。

　　 4、如果A和B都是索引指示器，那么A和B的类型、形参表（包括参数个数和每一个参数的类型）应当一致。而且A和B的访问器也是类似的。但如果A不是显式接口成员执行体，A允许增加自己的访问器。

　　 那么，对于一个接口成员，怎样确定由哪一个类的成员来实现呢？即一个接口成员映射的是哪一个类的成员？在这里，我们叙述一下接口映射的过程。假设类C实现了一个接口IInterface，Member是接口IInterface中的一个成员，在定位由谁来实现接口成员Member，即Member的映射过程是这样的：

　　 1、如果C中存在着一个显式接口成员执行体，该执行体与接口IInterface 及其成员Member相对应，则由它来实现Member 成员。

　　 2、如果条件（1）不满足，且C中存在着一个非静态的公有成员，该成员与接口成员Member相对应，则由它来实现Member 成员。

　　 3、如果上述条件仍不满足，则在类C定义的基类列表中寻找一个C 的基类D，用D来代替C。

　　 4、重复步骤1-- 3 ，遍历C的所有直接基类和非直接基类，直到找到一个满足条件的类的成员。

　　 5、如果仍然没有找到，则报告错误。

　　 下面是一个调用基类方法来实现接口成员的例子。类Class2 实现了接口Interface1，类Class2 的基类Class1 的成员也参与了接口的映射，也就是说类Class2 在对接口Interface1进行实现时，使用了类Class1提供的成员方法F来实现接口Interface1的成员方法F：

interface Interface1 {
　 void F( ) ;
}
class Class1 {
　 public void F( ) { }
　 public void G( ) { }
}
class Class2: Class1, Interface1 {
　 new public void G( ) {}
}

　　 注意：接口的成员包括它自己定义的成员，而且包括该接口所有父接口定义的成员。在接口映射时，不仅要对接口定义体中显式定义的所有成员进行映射，而且要对隐式地从父接口那里继承来的所有接口成员进行映射。
在进行接口映射时，还要注意下面两点：

　　 1、在决定由类中的哪个成员来实现接口成员时，类中显式说明的接口成员比其它成员优先实现。

　　 2、使用Private、protected和static修饰符的成员不能参与实现接口映射。例如：

interface ICloneable {
　 object Clone( ) ;
}
class C: ICloneable {
　 object ICloneable.Clone( ) {…}
　 public object Clone( ) {…}
}

　　 例子中成员ICloneable.Clone 称为接口ICloneable 的成员Clone 的实现者，因为它是显式说明的接口成员，比其它成员有着更高的优先权。

　　 如果一个类实现了两个或两个以上名字、类型和参数类型都相同的接口，那么类中的一个成员就可能实现所有这些接口成员：

interface IControl {
　 void Paint( ) ;
}
interface IForm {
　 void Paint( ) ;
}
class Page: IControl, IForm {
　 public void Paint( ) {…}
}

　　 这里，接口IControl和IForm的方法Paint都映射到了类Page中的Paint方法。当然也可以分别用显式的接口成员分别实现这两个方法：

interface IControl {
　 void Paint( ) ;
}
interface IForm {
　 void Paint( ) ;
}
class Page: IControl, IForm {
　 public void IControl.Paint( ) {
　 //具体的接口实现代码
}
public void IForm.Paint( ) {
　 //具体的接口实现代码
}
}

　　 上面的两种写法都是正确的。但是如果接口成员在继承中覆盖了父接口的成员，那么对该接口成员的实现就可能必须映射到显式接口成员执行体。看下面的例子：

interface IBase {
　 int P { get; }
}
interface IDerived: IBase {
　 new int P( ) ;
}

　　 接口IDerived从接口IBase中继承，这时接口IDerived 的成员方法覆盖了父接口的成员方法。因为这时存在着同名的两个接口成员，那么对这两个接口成员的实现如果不采用显式接口成员执行体，编译器将无法分辨接口映射。所以，如果某个类要实现接口IDerived，在类中必须至少定义一个显式接口成员执行体。采用下面这些写法都是合理的：

//一：对两个接口成员都采用显式接口成员执行体来实现
lass C: IDerived {
　 int IBase.P
　 get
　 { //具体的接口实现代码 }
　　 int IDerived.P( ){
　　 //具体的接口实现代码 }
　 }
//二：对Ibase 的接口成员采用显式接口成员执行体来实现
class C: IDerived {
　 int IBase.P
　 get {//具体的接口实现代码}
　　 public int P( ){
　　 //具体的接口实现代码 }
　 }
//三：对IDerived 的接口成员采用显式接口成员执行体来实现
class C: IDerived{
　 public int P
　 get {//具体的接口实现代码}
　 int IDerived.P( ){
　 //具体的接口实现代码}
}

　　 另一种情况是，如果一个类实现了多个接口，这些接口又拥有同一个父接口，这个父接口只允许被实现一次。

using System ;
interface IControl {
　 void Paint( ) ;
　 interface ITextBox: IControl {
　 void SetText(string text) ;
}
interface IListBox: IControl {
　 void SetItems(string[] items) ;
}
class ComboBox: IControl, ITextBox, IListBox {
　 void IControl.Paint( ) {…}
　 void ITextBox.SetText(string text) {…}
　 void IListBox.SetItems(string[] items) {…}
}

　　 上面的例子中，类ComboBox实现了三个接口：IControl，ITextBox和IListBox。如果认为ComboBox不仅实现了IControl接口，而且在实现ITextBox和IListBox的同时，又分别实现了它们的父接口IControl。实际上，对接口ITextBox 和IListBox 的实现，分享了对接口IControl 的实现。

　　 我们对C#的接口有了较全面的认识，基本掌握了怎样应用C#的接口编程，但事实上，C#的不仅仅应用于.NET平台，它同样支持以前的COM，可以实现COM类到.NET类的转换，如C#调用API。欲了解这方面的知识，请看下一节-接口转换。

 2/2   首页 上一页 1 2