[attributes] [modifiers] interface identifier [:base-list] {interface-body}[;] |
interface IShape { void Draw ( ) ;} |
interface INewInterface: IParent1, IParent2 { } |
interface IShape { public void Draw( ) ; } |
interface IControl {void Paint( ) ;} |
interface IInterface: IBase1, IBase2 { void Method1( ) ; void Method2( ) ;} |
class Class1: Iface1, Iface2 { // class 成员。} |
class ClassA: BaseClass, Iface1, Iface2 { // class成员。} |
interface IFace { void ShowMyFace( ) ;} |
class CFace:IFace{ public void ShowMyFace( ) { Console.WriteLine(" implementation " ) ; } } |
interface IControl { void Paint( ) ;}interface ITextBox: IControl { void SetText(string text) ;}interface IListBox: IControl { void SetItems(string[] items) ;}interface IComboBox: ITextBox, IListBox { } |
interface-body:{ interface-member-declarationsopt } |
interface IMyTest{ string this[int index] { get; set; } event EventHandler E ; void F(int value) ; string P { get; set; }}public delegate void EventHandler(object sender, EventArgs e) ; |
public delegate void StringListEvent(IStringList sender);public interface IStringList{ void Add(string s); int Count { get; } event StringListEvent Changed; string this[int index] { get; set; }} |
interface IControl { void Paint( ) ;}interface ITextBox: IControl { void GetText(string text) ;} |
namespace System{ public interface IDataTable { object Clone( ) ; }} |
声明接口
声明接口在语法上和声明抽象类完全相同,例如这里有一个银行账户的接口:
{
void PayIn( decimal amount);
bool Withdraw( decimal amount);
decimal Balance
{
get ;
}
}
注意:接口中只能包含方法、属性、索引器和事件的声明。不允许声明成员上的修饰符,即使是pubilc都不行,因为接口成员总是公有的,也不能声明为虚拟和静态的。如果需要修饰符,最好让实现类来声明。
使用接口的例子
这是书上的一个简单的例子,但足以说明接口的使用方法。
一个银行账户的接口,两个不同银行账户的实现类,都继承于这个接口。接口声明如上。下面是两个账户类:
{
private decimal balance;
public decimal Balance
{
get
{
return balance;
}
}
public void PayIn( decimal amount)
{
balance += amount;
}
public bool Withdraw( decimal amount)
{
if (balance >= amount)
{
balance -= amount;
return true ;
}
Console.WriteLine( " Withdraw failed. " );
return false ;
}
public override string ToString()
{
return String.Format( " Venus Bank Saver:Balance={0,6:C} " , balance);
}
}
{
private decimal balance;
public decimal Balance
{
get
{
return balance;
}
}
public void PayIn( decimal amount)
{
balance += amount;
}
public bool Withdraw( decimal amount)
{
if (balance >= amount)
{
balance -= amount;
return true ;
}
Console.WriteLine( " Withdraw failed. " );
return false ;
}
public override string ToString()
{
return String.Format( " Jupiter Bank Saver:Balance={0,6:C} " , balance);
}
}
可见,这两个实现类多继承了IBankAccount接口,因此它们必须要实现接口中的所有声明的方法。要不然,编译就会出错。让我们来测试一下,下面是测试代码:
{
IBankAccount venusAccount = new SaverAccount();
IBankAccount jupiterAccount = new CurrentAccount();
venusAccount.PayIn( 200 );
jupiterAccount.PayIn( 500 );
Console.WriteLine(venusAccount.ToString());
jupiterAccount.PayIn( 400 );
jupiterAccount.Withdraw( 500 );
jupiterAccount.Withdraw( 100 );
Console.WriteLine(jupiterAccount.ToString());
}
请注意开头两句,我们把它们声明为IBankAccount引用的方式,而没有声明为类的引用,为什么呢?因为,这样我们就可以让它指向执行这个接口的任何类的实例了,比较灵活。但这也有个缺点,如果我们要执行不属于接口的方法,比如这里重载的ToString()方法,就要先把接口的引用强制转换成合适的类型了。
接口的继承
接口也可以彼此继承,就象类的继承一样。比如我们又声明一个接口ITransferBankAccount,它继承于IBankAccount接口。
{
bool TransferTo(IBankAccount destination, decimal amount);
}
在这个接口中,又新增加了一个方法TransferTo(),所以如果我们要写一个类从ITransferBankAccount继承的话,就必须要实现IBankAccount和ITransferBankAccount两个接口所有的方法声明。即:
{
private decimal balance;
public decimal Balance
{
get
{
return balance;
}
}
public void PayIn(decimal amount)
{
balance += amount;
}
public bool Withdraw(decimal amount)
{
if (balance >= amount)
{
balance -= amount;
return true;
}
Console.WriteLine("Withdraw failed.");
return false;
}
public override string ToString()
{
return String.Format("Jupiter Bank Saver:Balance={0,6:C}", balance);
}
public bool TransferTo(IBankAccount destination, decimal amount)
{
if (Withdraw(amount))
{
destination.PayIn(amount);
return true;
}
else
{
return false;
}
}
}
总结起来说,使用C#接口应注意几个问题:
接口(interface)用来定义一种程序的协定。实现接口的类或者结构要与接口的定义严格一致。有了这个协定,就可以抛开编程语言的限制(理论上)。接口可以从多个基接口继承,而类或结构可以实现多个接口。接口可以包含方法、属性、事件和索引器。接口本身不提供它所定义的成员的实现。接口只指定实现该接口的类或接口必须提供的成员。
接口好比一种模版,这种模版定义了对象必须实现的方法,其目的就是让这些方法可以作为接口实例被引用。接口不能被实例化。类可以实现多个接口并且通过这些实现的接口被索引。接口变量只能索引实现该接口的类的实例。例子:
interface IMyExample {
string this[int index] { get ; set ; }
event EventHandler Even ;
void Find(int value) ;
string Point { get ; set ; }
}
public delegate void EventHandler(object sender, Event e) ;
上面例子中的接口包含一个索引this、一个事件Even、一个方法Find和一个属性Point。
接口可以支持多重继承。就像在下例中,接口"IComboBox"同时从"ITextBox"和"IListBox"继承。
interface IControl {
void Paint( ) ;
}
interface ITextBox: IControl {
void SetText(string text) ;
}
interface IListBox: IControl {
void SetItems(string[] items) ;
}
interface IComboBox: ITextBox, IListBox { }
类和结构可以多重实例化接口。就像在下例中,类"EditBox"继承了类"Control",同时从"IDataBound"和"IControl"继承。
interface IDataBound {
void Bind(Binder b) ;
}
public class EditBox: Control, IControl, IDataBound {
public void Paint( ) ;
public void Bind(Binder b) {...}
}
在上面的代码中,"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#语言进行组件编程将会给我们带来更大的方便。
知道了什么是接口,接下来就是怎样定义接口,请看下一节--定义接口。
这个道理在 OO 中也是适用的。
在接口使用的时候,空接口有2种情况:
1.类似于ObjectBuilder中的 IBuilderPolicy , 他们往往是做一个标记,表示需要某个功能.当然你也可以这么用,来表示你的类具有某个功能,实现了你的某个接口.
这下大家都明白了,其实属性 Name 对应于 Get_Name(),Set_Name() 这两个方法,事件 OnDraw 对应于 add_OnDraw(),remove_OnDraw() 这两个方法,索引器对应于 get_Item(),set_Item() 这两个方法。在看下面的委托和类的定义:
看到了吧,定义一个委托和定义一个类是没有什么区别的,都是定义了个新的类型。所以 C# 接口是不能有委托的,除非微软告诉我们 C# 接口中是可以定义类的。
全面剖析C#接口编程之示例
假设我们公司有两种程序员:VB程序员,指的是用VB写程序的程序员,用clsVBProgramer这个类表示;Delphi程序员指的是用Delphi写程序的程序员,用clsDelphiProgramer这个类来表示。 每个类都有一个WriteCode()方法。定义如下:
class clsVBProgramer()
{
....
WriteCode()
{
//用VB语言写代码;
}
....
}
class clsDelphiProgramer()
{
....
WriteCode()
{
//用Delphi语言写代码;
}
....
}
现在公司来了一个项目,要求派某个程序员写一个程序。
class clsProject()
{
....
WritePrograme(clsVBProgramer programer)//用VB写代码
{
programer.WriteCode();
}
WritePrograme(clsDelphiProgramer programer)//重载方法,用Delphi写代码
{
programer.WriteCode();
}
......
}
在主程序中我们可以这样写:
main()
{
clsProject proj=new clsProject;
//如果需要用VB写代码
clsVBProgramer programer1=new clsVBProgramer;
proj.WritePrograme(programer1);
//如果需要用Delphi写代码
clsDelphiProgramer programer2=new clsDelphiProgramer;
proj.WritePrograme(programer2);
}
但是如果这时公司又来了一个C#程序员,我们怎么改这段程序,使它能够实现用C#写程序的功能呢?我们需要增加一个新类clsCSharpProgramer,同时在此clsProject这个类中要再次重载WritePrograme(clsCSharpProgramer programer)方法。这下麻烦多了。如果还有C程序员,C++程序员,JAVA程序员呢。麻烦大了!
但是如果改用接口,就完全不一样了:
首先声明一个程序员接口:
interface IProgramer()
{
WriteCode();
}
然后声明两个类,并实现IProgramer接口:
class clsVBProgramer():IProgramer
{
....
WriteCode()
{
//用VB语言写代码;
}
....
}
class clsDelphiProgramer():IProgramer
{
....
WriteCode()
{
//用Delphi语言写代码;
}
....
}
对clsProject这个类进行一下修改:
class clsProject()
{
....
WritePrograme(IProgramer programer)
{
programer.WriteCode();//写代码
}
......
}
main()
{
clsProject proj=new clsProject;
IProgramer programer;
//如果需要用VB写代码
programer=new clsVBProgramer;
proj.WritePrograme(programer);
//如果需要用Delphi写代码
programer=new clsDelphiProgramer;
proj.WritePrograme(programer);
}
如果再有C#,C,C++,JAVA这样的程序员添加进来的话,我们只需把它们相关的类加进来,然后在main()中稍做修改就OK了。扩充性特别好!