Interface 在DELPHI里的用法示例(转贴)

任务描述：
我们有4个类，分别生成4个对象：A、B、C、D

A需要调用B的方法，把数据送给B；
然后，B调用C的方法，把A送来的数据送给C；
然后，C调用D的方法，把B送来的数据送给D；

然后，当D使用完这个数据后，D要调用C的方法将处理结果通知C；
C再把处理结果通知B；
B再把处理结果通知A；

要求：
写A、B、C、D四个类的时候，要避免对象之间的紧密偶合。按传统做法，大概是让A、B、C、D四个类从同一个实现了发送数据和通知这两个方法的父类继承下来。如果因为某种原因，假设B类必须从其它父类继承，就没办法了。
要做到：1. 每个类都不用考虑从哪个父类继承；2. 每个类都不知道别的类。在写B类的时候，不知道有A类或有C类的存在，不引用定义A类或B类的单元。

在Delphi里，我们可以使用Interface来达到这个目的。

首先，单独采用一个单元来定义Interface:



unit Unit2;

interface

uses Classes;

type
  IMySend2=interface
    procedure SendData(AData:string; AEventList:TInterfaceList);
  end;

  IMyEvent2=interface
    procedure SendDataSuccess(AData:string;  AEventList:TInterfaceList);
  end;

implementation

end.


所有的A、B、C、D几个类，都只需要知道Unit2这个单元就行了。它们之间互相不用知道。

每个实现上述接口方法的类，都把自己的通知接口加到AEventList:TInterfaceList里去。最后，每个类在被通知到的时候，都可以根据传来的这个通知接口List，取得发数据给自己的类的通知接口，来通知到应该被通知的类。

下面的代码是实现接口的类。需要注意的是，每个类完全可以写在不同的单元里，单元之间不用互相引用，每个类不用知道其它类。



unit Unit5;
{---------------------------------------------------------
  实验：A类调用B类实现的接口方法，把数据和A类自己实现的通知接口方法发送给B；
  B类再将数据和B类自己的通知接口方法发送给C；C类再发送给D
  最后，D类再通知回C，C通知回B，B通知回A
  数据流经过的每个类，都把自己的通知接口方法指针加入到一个LIST中去，传给下一级
--------------------------------------------------------------------------}
interface

uses Unit2,Dialogs, SysUtils,Classes;

type
  TClassD=class(TInterfacedObject,IMySend2) //最后一个接收数据的类
  public
    procedure SendData(AData:string; AEvenTInterfaceList:TInterfaceList);
  end;

  TClassC=class(TInterfacedObject,IMySend2,IMyEvent2)
  public
    FMySend2:IMySend2;
    procedure SendData(AData:string; AEvenTInterfaceList:TInterfaceList);
    procedure SendDataSuccess(AData:string; AEvenTInterfaceList:TInterfaceList);//IMYEvent2
  end;

  TClassB=class(TInterfacedObject,IMySend2,IMyEvent2)
  public
    FMySend2:IMySend2;
    procedure SendData(AData:string; AEvenTInterfaceList:TInterfaceList);
    procedure SendDataSuccess(AData:string; AEvenTInterfaceList:TInterfaceList);//IMYEvent2
  end;

  TClassA=class(TInterfacedObject,IMyEvent2) //第一个发数据的类
  public
    FMySend:IMySend2; //这是C实现的接口

    procedure SendDataSuccess(AData:string; AEvenTInterfaceList:TInterfaceList);//IMYEvent2
    procedure DoSend(AData:string); //由程序调用，主动发出数据给C
  end;

implementation

{ TClassA }



{ TClassD }

procedure TClassD.SendData(AData: string; AEvenTInterfaceList: TInterfaceList);
var
  AEvent:IMyEvent2;
begin
  if AEvenTInterfaceList.Count>0 then
  begin
    AEvent:=IMyEvent2(AEvenTInterfaceList[AEvenTInterfaceList.Count-1]);   //取出最近的一条接口
    AEvenTInterfaceList.Delete(AEvenTInterfaceList.Count-1);  //将此接口从LIST里删除
    AEvent.SendDataSuccess(AData,AEvenTInterfaceList); //调用此接口通知前一个对象，并将List传给那个对象
    AEvent:=nil;
  end;
end;

{ TClassC }

procedure TClassC.SendData(AData: string; AEvenTInterfaceList: TInterfaceList);
var
  MyEvenTInterfaceList:TInterfaceList;
begin
  //此方法被B调用来输入数据，并在这里调用D类的接口将数据送给D
  //FMySend2 由程序来将D的接口放进来。
  if Assigned(AEvenTInterfaceList) then
  begin
    MyEvenTInterfaceList:=AEvenTInterfaceList;
  end
  else
  begin
    MyEvenTInterfaceList:=TInterfaceList.Create;
  end;
  MyEvenTInterfaceList.Add(IMyEvent2(self));   //把自己的通知接口加到列表里去，送给下一级。

  FMySend2.SendData(AData+'C',MyEvenTInterfaceList);
end;

procedure TClassC.SendDataSuccess(AData: string;
  AEvenTInterfaceList: TInterfaceList);
var
  AEvent:IMyEvent2;
begin
  ShowMessage('C类被通知= '+AData);
  if AEvenTInterfaceList.Count>0 then
  begin
    AEvent:=IMyEvent2(AEvenTInterfaceList.Items[AEvenTInterfaceList.Count-1]);
    AEvenTInterfaceList.Delete(AEvenTInterfaceList.Count-1);
    AEvent.SendDataSuccess(AData,AEvenTInterfaceList);
    AEvent:=nil;
  end;
end;

{ TClassB }

procedure TClassB.SendData(AData: string; AEvenTInterfaceList: TInterfaceList);
var
  MyEvenTInterfaceList:TInterfaceList;
begin
  //此方法被B调用来输入数据，并在这里调用D类的接口将数据送给D
  //FMySend2 由程序来将D的接口放进来。
  if Assigned(AEvenTInterfaceList) then
  begin
    MyEvenTInterfaceList:=AEvenTInterfaceList;
  end
  else
  begin
    MyEvenTInterfaceList:=TInterfaceList.Create;
  end;
  MyEvenTInterfaceList.Add(IMyEvent2(self));   //把自己的通知接口加到列表里去，送给下一级。

  FMySend2.SendData(AData+'B',MyEvenTInterfaceList);
end;

procedure TClassB.SendDataSuccess(AData: string;
  AEvenTInterfaceList: TInterfaceList);
var
  AEvent:IMyEvent2;
begin
  ShowMessage('B类被通知= '+AData);
  if AEvenTInterfaceList.Count>0 then
  begin
    AEvent:=IMyEvent2(AEvenTInterfaceList.Items[AEvenTInterfaceList.Count-1]);
    AEvenTInterfaceList.Delete(AEvenTInterfaceList.Count-1);
    AEvent.SendDataSuccess(AData,AEvenTInterfaceList);
    AEvent:=nil;
  end;
end;

{ TClassA }

procedure TClassA.DoSend(AData:string);
var
  MyEvenTInterfaceList:TInterfaceList;
begin
  MyEvenTInterfaceList:=TInterfaceList.Create;
  MyEvenTInterfaceList.Add(IMyEvent2(self)); //一定要加强制类型转换！
  FMySend.SendData(AData,MyEvenTInterfaceList);
end;

procedure TClassA.SendDataSuccess(AData: string;
  AEvenTInterfaceList: TInterfaceList);
var
  AEvent:IMyEvent2;
  i:Integer;
begin
  ShowMessage('A类被通知'+AData);
  if AEvenTInterfaceList.Count>0 then
  begin
    ShowMessage('接口列表里还有接口指针，奇怪！');
    for i:=AEvenTInterfaceList.Count-1 downto 0 do
    begin
      AEvent:=IMyEvent2(AEvenTInterfaceList.Items[i]);
      AEvent:=nil;
      AEvenTInterfaceList.Delete(i);
    end;
  end
  else
  begin
    ShowMessage('接口列表里没有接口指针了。');
  end;
  AEvenTInterfaceList.Free;
end;

end.


最后，写一个程序来测试结果，会看到，的确符合程序里给的调用顺序：



procedure TForm1.Button5Click(Sender: TObject);
var
  AClassA:TClassA;
  AClassB:TClassB;
  AClassC:TClassC;
  AClassD:TClassD;
begin
  AClassA:=TClassA.Create;
  AClassB:=TClassB.Create;
  AClassC:=TClassC.Create;
  AClassD:=TClassD.Create;

  AClassA.FMySend:=IMySend2(AClassB);
  AClassB.FMySend2:=IMySend2(AClassC);
  AClassC.FMySend2:=IMySend2(AClassD);

  AClassA.DoSend('你好吗？');
end;


顺便提一下，使用接口还有一个好处，是当增加一个F类，而且把F类插到数据传递的中间，比如A->B->F->C->D，然后D处理完后通知顺序是D->C->F->B->A，完全不用更改其它类。仅仅需要增加一个实现了上述两个接口的F类，然后在程序里把F类插进去就可以了。这样做应该是对程序的改动最小的一种方法了。

这里值得注意的一个语法问题：
上面有这样的语句：AClassA.FMySend:=IMySend2(AClassB); 在语法上来看，可以写成这样：AClassA.FMySend:=AClassB;完全没问题。一样可以在ClassA里调用到ClassB里的接口方法。

但是，如果把接口加到TInterfaceList里去，就好象上面的这句：MyEvenTInterfaceList.Add(IMyEvent2(self))，如果写成：
MyEvenTInterfaceList.Add(self)，编译完全没问题，能跑起来。但是，当从TInterfaceList里把接口取出来的时候，也就是执行这一句：AEvent:=IMyEvent2(AEvenTInterfaceList[AEvenTInterfaceList.Count-1])的时候，就会出AV错误。

结论：当把接口加入到TInterfaceList里的时候，一定要做强制类型转换，转换为你要的接口！然后取出来的时候才会正确。但当把接口作为一个类的私有变量的时候，可以直接把实现该接口的类指给它也可以