Delphi 的接口(1) - 接口的简单解释
简单地说接口就是定义了方法和属性的空架子(术语为方法签名,包括函数和过程),属性本身也是存过程和取函数,即也是方法,在接口定义中所有成员都是默认的PUBLIC,没有数据成员。这些方法由继承它的子类来实现,这个子类只能有一个而且必须有一个父类,却可以有多个父接口。
接口可以连接完全不同的类对某一共同操作的桥梁,比如,“跑”这个操作,如果要用类继承,可以在子类中去重载,但是“TPig”、“TMan”、“TMouse”、 “TMachine”、“TCar”这些类都有“跑”的功能,单纯类继承是无法实现的,但用接口可以,首先定义一个接口“TRUN”,然后再继承这个接口形成上述的类,在 类中实现这个接口。
算了,边给代码解释:
type
TRUN=interface
procedure 跑;
end;
TPig=class(TInterfacedObject,TRUN)
//TInterfacedObject是实现了接口三个方法的Object类,其中一个是QueryInterface
procedure 跑;
//..........
end;
TMan=class(TInterfacedObject,TRUN)
procedure 跑;
//..........
end;
implementation
......
//应用:
procedure test;
var
pig:TPig;
man:TMan;
run:TRUN;
begin
pig:=TPig.create;
man:=TMan.create;
man.QueryInterface(TRUN,run);
run.跑;//TMan类的跑
pig.QueryInterface(TRUN,run);
run.跑;//TPig类的跑
end;
本文来自CSDN博客:http://blog.csdn.net/peirenlei/archive/2007/08/13/1741027.aspx
Delphi 的接口(1) - 接口的介绍
"接口" 的概念和 "类" 特别是 "抽象类" 近似, Delphi 之初并没有接口, 后来(Delphi 3)为了支持 COM 引入了接口, 再后来发展成为 Delphi 重要的语言特性.
微软在开发 OLE 时, 有一种需求: 使用其他程序中的对象, 这种需求导致了 COM 的诞生并发扬光大, 而 OLE 却在慢慢地销声匿迹.
从 COM 到 COM+, 之后好像微软并没有再大力发展(可能是把精力都放到 Net 上去了, 但 Net 也没离开 COM), 它现在仍有着非常广泛的应用, 这应该得益于它先进的思想.
慢慢道来:
1、一个二进制的 1 或 0, 这是任何语言都可以识别的;
2、一个字符, 也是任何语言都可以识别的;
3、一个整形变量, 也是任何语言都可以识别的;
4、一个结构体, 也是任何语言都可以识别的;
5、一个函数也没有问题, 譬如 Delphi 调用 API;
6、但一个 "对象" 或着 "类" 呢? 这在跨程序、跨语言时就不好识别了.
COM 解决了这个问题! 并进而应用于网络.
COM 规定了一个二进制的标准, 这个标准主要针对 "对象方法的声明"(也就是接口), 同时把声明(接口)和实现分开.
不同的语言都可以来实现这个接口、同时不同的语言(在遵循标准的情况下)也都能识别这个接口, 从而实现的跨语言的对象的交互.
现在看看这个过程其实是水到渠成、挺自然的; 但好像当初微软的 COM 之路也并不平坦.
微软通过 COM 组件的方式提供了很多功能, 它们很可能是用 C++ 实现的, 我们用 Delphi 可以很好的使用, 本质上说就是 Delphi 遵循了那个二进制的标准; 相反, Delphi 按这个标准声明、并用自己的语言实现的 COM 组件也能供其他语言使用.
一个 COM 组件里有什么呢?
主要是一堆接口(也就是声明)和接口的实现, 每个接口对应一个计数器, 另包含一个叫 "类厂" 的东西.
使用 COM 步骤可能是这样的:
1、程序在使用组件之初, 先联系 "接口"; 这应该是从注册表中查询.
2、找到后, 如果此接口还没有被实现, 马上调用 "类厂" 建立起对象, 并同时给接口计数器加 1.
3、可能会不止一个程序在使用同一个接口, 但每有使用则 "计数器+1", 每次用完则 "计数器-1".
4、当接口的使用计数为 0 时, 系统自动释放类厂为该接口建立的对象(垃圾回收机制).
我们 Delphi 中的接口当然也是这样, 用完会自动释放, 无需手动 free.
接口在 Delphi 中继续支持着 COM 并继续完善着, 接下来要讨论的是作为语言特性的 "接口" 概念与使用.
我曾经被 "接口" 置于云雾之中, 一些书也让人越看越糊涂; 明白了以后发现其实挺简单的, 相比 "类" 的规则要简单许多.
代码:
unit Unit1;
interface
uses
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
Dialogs, StdCtrls;
type
TForm1 = class(TForm)
Button1: TButton;
Button2: TButton;
Button3: TButton;
Button4: TButton;
procedure Button1Click(Sender: TObject);
procedure Button2Click(Sender: TObject);
procedure Button3Click(Sender: TObject);
procedure Button4Click(Sender: TObject);
end;
IMyInterface1 = interface
function Func1: Integer;
function Func2: Integer;
end;
IMyInterface2 = interface
procedure Proc1;
procedure Proc2;
end;
TMyClass1 = class(TInterfacedObject, IMyInterface1, IMyInterface2)
public
procedure Proc1;
procedure Proc2;
function Func1: Integer;
function Func2: Integer;
end;
var
Form1: TForm1;
implementation
{$R *.dfm}
{ TMyClass1 }
function TMyClass1.Func1: Integer;
begin
ShowMessage('IMyInterface1.Func1');
Result := 0;
end;
function TMyClass1.Func2: Integer;
begin
ShowMessage('IMyInterface1.Func2');
Result := 0;
end;
procedure TMyClass1.Proc1;
begin
ShowMessage('IMyInterface2.Proc1');
end;
procedure TMyClass1.Proc2;
begin
ShowMessage('IMyInterface2.Proc2');
end;
procedure TForm1.Button1Click(Sender: TObject);
var
c: TMyClass1;
begin
c := TMyClass1.Create;
c.Func1;
c.Func2;
c.Proc1;
c.Proc2;
c.Free;
end;
procedure TForm1.Button2Click(Sender: TObject);
var
i1: IMyInterface1;
begin
i1 := TMyClass1.Create;
i1.Func1;
i1.Func2;
end;
procedure TForm1.Button3Click(Sender: TObject);
var
i2: IMyInterface2;
begin
i2 := TMyClass1.Create;
i2.Proc1;
i2.Proc2;
end;
procedure TForm1.Button4Click(Sender: TObject);
var
c: TMyClass1;
i1: IMyInterface1;
i2: IMyInterface2;
begin
c := TMyClass1.Create;
i1 := c;
i1.Func1;
i1.Func2;
i2 := c;
i2.Proc1;
i2.Proc2;
// c.Free; {}
end;
end.
示例注释(现在应该知道的):
{
1、接口命名约定 I 起头, 就像类从 T 打头一样.
2、接口都是从 IInterface 继承而来; 若是从根接口继承, 可省略.
3、接口成员只能是方法、属性, 没有字段.
4、接口成员都是公开的, 不需要 private、protected、public、published 等任何访问限制.
5、因为接口只声明、无实现, 也用不到继承与覆盖相关的修饰(virtual、dynamic、abstract、override).
6、一个接口可以从另一个接口继承, 但不能从多个接口继承; 不过 Delphi.Net 已支持接口的多继承了.
7、一个类可以实现多个接口: TMyClass = class(父类, 接口1, 接口2, ...) end;
8、不过实现接口的类有多么丰富, 接口只拥有自己声明的成员.
9、实现接口的类一般继承于 TInterfacedObject, 直接从 TObject 继承会增加一些麻烦而重复的工作.
10、接口在用完后会自释放, 并同时释放拥有它的类; 这很方便, 但同时带来很多问题.
}
Delphi 的接口(3) - 关于接口的释放
代码文件:
unit Unit1;
interface
uses
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
Dialogs, StdCtrls;
type
TForm1 = class(TForm)
Button1: TButton;
Button2: TButton;
Button3: TButton;
Button4: TButton;
procedure Button1Click(Sender: TObject);
procedure Button2Click(Sender: TObject);
procedure Button3Click(Sender: TObject);
procedure Button4Click(Sender: TObject);
end;
IMyInterface = interface
procedure Proc;
end;
TMyClass = class(TInterfacedObject, IMyInterface)
public
constructor Create;
destructor Destroy; override;
procedure Proc;
end;
var
Form1: TForm1;
implementation
{$R *.dfm}
constructor TMyClass.Create;
begin
inherited;
ShowMessage('TMyClass.Create');
end;
destructor TMyClass.Destroy;
begin
ShowMessage('TMyClass.Destroy');
inherited;
end;
procedure TMyClass.Proc;
begin
ShowMessage('IMyInterface.Proc');
end;
procedure TForm1.Button1Click(Sender: TObject);
var
c: TMyClass;
begin
c := TMyClass.Create;
c.Proc;
c.Free;
ShowMessage('**********');
{将依次显示:
TMyClass.Create
IMyInterface.Proc
TMyClass.Destroy
**********
}
end;
procedure TForm1.Button2Click(Sender: TObject);
var
i: IMyInterface;
begin
i := TMyClass.Create;
i.Proc;
ShowMessage('**********');
//在本段程序的最后, 编译器能判断出接口不再有用, 会释放掉拥有它的类
{将依次显示:
TMyClass.Create
IMyInterface.Proc
**********
TMyClass.Destroy
}
end;
procedure TForm1.Button3Click(Sender: TObject);
var
c: TMyClass;
i: IMyInterface;
begin
c := TMyClass.Create;
i := c;
//i := IMyInterface(c); {也可以这样转换}
//i := c as IMyInterface; {暂时不能使用 as, 接口拥有 GUID 后才可以使用 as 转换}
i.Proc;
ShowMessage('**********');
{将依次显示:
TMyClass.Create
IMyInterface.Proc
**********
TMyClass.Destroy
}
end;
procedure TForm1.Button4Click(Sender: TObject);
var
i: IMyInterface;
begin
i := TMyClass.Create;
i.Proc;
i := nil; //可以这样主动释放接口; 同时拥有它的类也会释放
ShowMessage('**********');
{将依次显示:
TMyClass.Create
IMyInterface.Proc
TMyClass.Destroy
**********
}
end;
end.
Delphi 的接口(4) - 接口的属性
代码文件:
unit Unit1;
interface
uses
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
Dialogs, StdCtrls;
type
TForm1 = class(TForm)
Button1: TButton;
procedure Button1Click(Sender: TObject);
end;
{此接口声明了一个 Name 属性; 因为接口没有字段, read/write 都只能从方法}
IMyInterface = interface
function GetName : string;
procedure SetName(val : string);
property Name : string read GetName write SetName;
end;
{类实现的是接口的读写方法, 属性还是属于接口的; 类可以提供一个储存属性的字段}
TMyClass = class(TInterfacedObject, IMyInterface)
private
FName: string;
public
function GetName: string;
procedure SetName(val: string);
end;
var
Form1: TForm1;
implementation
{$R *.dfm}
{ TMyClass }
function TMyClass.GetName: string;
begin
Result := FName;
end;
procedure TMyClass.SetName(val: string);
begin
FName := val;
end;
{ TForm1 }
procedure TForm1.Button1Click(Sender: TObject);
var
c: TMyClass;
i: IMyInterface;
begin
c := TMyClass.Create;
i := c;
i.Name := 'ABC';
ShowMessage(i.Name); {ABC}
//没有一个 c.Name 存在, 这个属性只属于接口
end;
end.
Delphi 的接口(5) - 一样的接口、不一样的实现
代码文件:
unit Unit1;
interface
uses
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
Dialogs, StdCtrls;
type
TForm1 = class(TForm)
Button1: TButton;
procedure Button1Click(Sender: TObject);
end;
IMyInterface1 = interface
function Func(a,b: Integer): Integer;
end;
TAdd = class(TInterfacedObject, IMyInterface1)
public
function Func(a: Integer; b: Integer): Integer;
destructor Destroy; override;
end;
TMul = class(TInterfacedObject, IMyInterface1)
public
function Func(a: Integer; b: Integer): Integer;
destructor Destroy; override;
end;
var
Form1: TForm1;
implementation
{$R *.dfm}
{ TAdd }
destructor TAdd.Destroy;
begin
ShowMessage('TAdd.Destroy');
inherited;
end;
function TAdd.Func(a, b: Integer): Integer;
begin
Result := a + b;
end;
{ TMul }
destructor TMul.Destroy;
begin
ShowMessage('TMul.Destroy');
inherited;
end;
function TMul.Func(a, b: Integer): Integer;
begin
Result := a * b;
end;
{ TForm1 }
procedure TForm1.Button1Click(Sender: TObject);
var
I: IMyInterface1;
begin
I := TAdd.Create;
ShowMessage(IntToStr(I.Func(9, 9))); {18}
I := TMul.Create; {I 在指向新的目标前会先释放前面所属的类}
ShowMessage(IntToStr(I.Func(9, 9))); {81}
end;
end.
Delphi 的接口(1) - 接口的简单解释
简单地说接口就是定义了方法和属性的空架子(术语为方法签名,包括函数和过程),属性本身也是存过程和取函数,即也是方法,在接口定义中所有成员都是默认的PUBLIC,没有数据成员。这些方法由继承它的子类来实现,这个子类只能有一个而且必须有一个父类,却可以有多个父接口。
接口可以连接完全不同的类对某一共同操作的桥梁,比如,“跑”这个操作,如果要用类继承,可以在子类中去重载,但是“TPig”、“TMan”、“TMouse”、 “TMachine”、“TCar”这些类都有“跑”的功能,单纯类继承是无法实现的,但用接口可以,首先定义一个接口“TRUN”,然后再继承这个接口形成上述的类,在 类中实现这个接口。
算了,边给代码解释:
type
TRUN=interface
procedure 跑;
end;
TPig=class(TInterfacedObject,TRUN)
//TInterfacedObject是实现了接口三个方法的Object类,其中一个是QueryInterface
procedure 跑;
//..........
end;
TMan=class(TInterfacedObject,TRUN)
procedure 跑;
//..........
end;
implementation
......
//应用:
procedure test;
var
pig:TPig;
man:TMan;
run:TRUN;
begin
pig:=TPig.create;
man:=TMan.create;
man.QueryInterface(TRUN,run);
run.跑;//TMan类的跑
pig.QueryInterface(TRUN,run);
run.跑;//TPig类的跑
end;
本文来自CSDN博客:http://blog.csdn.net/peirenlei/archive/2007/08/13/1741027.aspx
Delphi 的接口(1) - 接口的介绍
"接口" 的概念和 "类" 特别是 "抽象类" 近似, Delphi 之初并没有接口, 后来(Delphi 3)为了支持 COM 引入了接口, 再后来发展成为 Delphi 重要的语言特性.
微软在开发 OLE 时, 有一种需求: 使用其他程序中的对象, 这种需求导致了 COM 的诞生并发扬光大, 而 OLE 却在慢慢地销声匿迹.
从 COM 到 COM+, 之后好像微软并没有再大力发展(可能是把精力都放到 Net 上去了, 但 Net 也没离开 COM), 它现在仍有着非常广泛的应用, 这应该得益于它先进的思想.
慢慢道来:
1、一个二进制的 1 或 0, 这是任何语言都可以识别的;
2、一个字符, 也是任何语言都可以识别的;
3、一个整形变量, 也是任何语言都可以识别的;
4、一个结构体, 也是任何语言都可以识别的;
5、一个函数也没有问题, 譬如 Delphi 调用 API;
6、但一个 "对象" 或着 "类" 呢? 这在跨程序、跨语言时就不好识别了.
COM 解决了这个问题! 并进而应用于网络.
COM 规定了一个二进制的标准, 这个标准主要针对 "对象方法的声明"(也就是接口), 同时把声明(接口)和实现分开.
不同的语言都可以来实现这个接口、同时不同的语言(在遵循标准的情况下)也都能识别这个接口, 从而实现的跨语言的对象的交互.
现在看看这个过程其实是水到渠成、挺自然的; 但好像当初微软的 COM 之路也并不平坦.
微软通过 COM 组件的方式提供了很多功能, 它们很可能是用 C++ 实现的, 我们用 Delphi 可以很好的使用, 本质上说就是 Delphi 遵循了那个二进制的标准; 相反, Delphi 按这个标准声明、并用自己的语言实现的 COM 组件也能供其他语言使用.
一个 COM 组件里有什么呢?
主要是一堆接口(也就是声明)和接口的实现, 每个接口对应一个计数器, 另包含一个叫 "类厂" 的东西.
使用 COM 步骤可能是这样的:
1、程序在使用组件之初, 先联系 "接口"; 这应该是从注册表中查询.
2、找到后, 如果此接口还没有被实现, 马上调用 "类厂" 建立起对象, 并同时给接口计数器加 1.
3、可能会不止一个程序在使用同一个接口, 但每有使用则 "计数器+1", 每次用完则 "计数器-1".
4、当接口的使用计数为 0 时, 系统自动释放类厂为该接口建立的对象(垃圾回收机制).
我们 Delphi 中的接口当然也是这样, 用完会自动释放, 无需手动 free.
接口在 Delphi 中继续支持着 COM 并继续完善着, 接下来要讨论的是作为语言特性的 "接口" 概念与使用.
我曾经被 "接口" 置于云雾之中, 一些书也让人越看越糊涂; 明白了以后发现其实挺简单的, 相比 "类" 的规则要简单许多.
代码:
unit Unit1;
interface
uses
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
Dialogs, StdCtrls;
type
TForm1 = class(TForm)
Button1: TButton;
Button2: TButton;
Button3: TButton;
Button4: TButton;
procedure Button1Click(Sender: TObject);
procedure Button2Click(Sender: TObject);
procedure Button3Click(Sender: TObject);
procedure Button4Click(Sender: TObject);
end;
IMyInterface1 = interface
function Func1: Integer;
function Func2: Integer;
end;
IMyInterface2 = interface
procedure Proc1;
procedure Proc2;
end;
TMyClass1 = class(TInterfacedObject, IMyInterface1, IMyInterface2)
public
procedure Proc1;
procedure Proc2;
function Func1: Integer;
function Func2: Integer;
end;
var
Form1: TForm1;
implementation
{$R *.dfm}
{ TMyClass1 }
function TMyClass1.Func1: Integer;
begin
ShowMessage('IMyInterface1.Func1');
Result := 0;
end;
function TMyClass1.Func2: Integer;
begin
ShowMessage('IMyInterface1.Func2');
Result := 0;
end;
procedure TMyClass1.Proc1;
begin
ShowMessage('IMyInterface2.Proc1');
end;
procedure TMyClass1.Proc2;
begin
ShowMessage('IMyInterface2.Proc2');
end;
procedure TForm1.Button1Click(Sender: TObject);
var
c: TMyClass1;
begin
c := TMyClass1.Create;
c.Func1;
c.Func2;
c.Proc1;
c.Proc2;
c.Free;
end;
procedure TForm1.Button2Click(Sender: TObject);
var
i1: IMyInterface1;
begin
i1 := TMyClass1.Create;
i1.Func1;
i1.Func2;
end;
procedure TForm1.Button3Click(Sender: TObject);
var
i2: IMyInterface2;
begin
i2 := TMyClass1.Create;
i2.Proc1;
i2.Proc2;
end;
procedure TForm1.Button4Click(Sender: TObject);
var
c: TMyClass1;
i1: IMyInterface1;
i2: IMyInterface2;
begin
c := TMyClass1.Create;
i1 := c;
i1.Func1;
i1.Func2;
i2 := c;
i2.Proc1;
i2.Proc2;
// c.Free; {}
end;
end.
示例注释(现在应该知道的):
{
1、接口命名约定 I 起头, 就像类从 T 打头一样.
2、接口都是从 IInterface 继承而来; 若是从根接口继承, 可省略.
3、接口成员只能是方法、属性, 没有字段.
4、接口成员都是公开的, 不需要 private、protected、public、published 等任何访问限制.
5、因为接口只声明、无实现, 也用不到继承与覆盖相关的修饰(virtual、dynamic、abstract、override).
6、一个接口可以从另一个接口继承, 但不能从多个接口继承; 不过 Delphi.Net 已支持接口的多继承了.
7、一个类可以实现多个接口: TMyClass = class(父类, 接口1, 接口2, ...) end;
8、不过实现接口的类有多么丰富, 接口只拥有自己声明的成员.
9、实现接口的类一般继承于 TInterfacedObject, 直接从 TObject 继承会增加一些麻烦而重复的工作.
10、接口在用完后会自释放, 并同时释放拥有它的类; 这很方便, 但同时带来很多问题.
}
Delphi 的接口(3) - 关于接口的释放
代码文件:
unit Unit1;
interface
uses
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
Dialogs, StdCtrls;
type
TForm1 = class(TForm)
Button1: TButton;
Button2: TButton;
Button3: TButton;
Button4: TButton;
procedure Button1Click(Sender: TObject);
procedure Button2Click(Sender: TObject);
procedure Button3Click(Sender: TObject);
procedure Button4Click(Sender: TObject);
end;
IMyInterface = interface
procedure Proc;
end;
TMyClass = class(TInterfacedObject, IMyInterface)
public
constructor Create;
destructor Destroy; override;
procedure Proc;
end;
var
Form1: TForm1;
implementation
{$R *.dfm}
constructor TMyClass.Create;
begin
inherited;
ShowMessage('TMyClass.Create');
end;
destructor TMyClass.Destroy;
begin
ShowMessage('TMyClass.Destroy');
inherited;
end;
procedure TMyClass.Proc;
begin
ShowMessage('IMyInterface.Proc');
end;
procedure TForm1.Button1Click(Sender: TObject);
var
c: TMyClass;
begin
c := TMyClass.Create;
c.Proc;
c.Free;
ShowMessage('**********');
{将依次显示:
TMyClass.Create
IMyInterface.Proc
TMyClass.Destroy
**********
}
end;
procedure TForm1.Button2Click(Sender: TObject);
var
i: IMyInterface;
begin
i := TMyClass.Create;
i.Proc;
ShowMessage('**********');
//在本段程序的最后, 编译器能判断出接口不再有用, 会释放掉拥有它的类
{将依次显示:
TMyClass.Create
IMyInterface.Proc
**********
TMyClass.Destroy
}
end;
procedure TForm1.Button3Click(Sender: TObject);
var
c: TMyClass;
i: IMyInterface;
begin
c := TMyClass.Create;
i := c;
//i := IMyInterface(c); {也可以这样转换}
//i := c as IMyInterface; {暂时不能使用 as, 接口拥有 GUID 后才可以使用 as 转换}
i.Proc;
ShowMessage('**********');
{将依次显示:
TMyClass.Create
IMyInterface.Proc
**********
TMyClass.Destroy
}
end;
procedure TForm1.Button4Click(Sender: TObject);
var
i: IMyInterface;
begin
i := TMyClass.Create;
i.Proc;
i := nil; //可以这样主动释放接口; 同时拥有它的类也会释放
ShowMessage('**********');
{将依次显示:
TMyClass.Create
IMyInterface.Proc
TMyClass.Destroy
**********
}
end;
end.
Delphi 的接口(4) - 接口的属性
代码文件:
unit Unit1;
interface
uses
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
Dialogs, StdCtrls;
type
TForm1 = class(TForm)
Button1: TButton;
procedure Button1Click(Sender: TObject);
end;
{此接口声明了一个 Name 属性; 因为接口没有字段, read/write 都只能从方法}
IMyInterface = interface
function GetName : string;
procedure SetName(val : string);
property Name : string read GetName write SetName;
end;
{类实现的是接口的读写方法, 属性还是属于接口的; 类可以提供一个储存属性的字段}
TMyClass = class(TInterfacedObject, IMyInterface)
private
FName: string;
public
function GetName: string;
procedure SetName(val: string);
end;
var
Form1: TForm1;
implementation
{$R *.dfm}
{ TMyClass }
function TMyClass.GetName: string;
begin
Result := FName;
end;
procedure TMyClass.SetName(val: string);
begin
FName := val;
end;
{ TForm1 }
procedure TForm1.Button1Click(Sender: TObject);
var
c: TMyClass;
i: IMyInterface;
begin
c := TMyClass.Create;
i := c;
i.Name := 'ABC';
ShowMessage(i.Name); {ABC}
//没有一个 c.Name 存在, 这个属性只属于接口
end;
end.
Delphi 的接口(5) - 一样的接口、不一样的实现
代码文件:
unit Unit1;
interface
uses
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
Dialogs, StdCtrls;
type
TForm1 = class(TForm)
Button1: TButton;
procedure Button1Click(Sender: TObject);
end;
IMyInterface1 = interface
function Func(a,b: Integer): Integer;
end;
TAdd = class(TInterfacedObject, IMyInterface1)
public
function Func(a: Integer; b: Integer): Integer;
destructor Destroy; override;
end;
TMul = class(TInterfacedObject, IMyInterface1)
public
function Func(a: Integer; b: Integer): Integer;
destructor Destroy; override;
end;
var
Form1: TForm1;
implementation
{$R *.dfm}
{ TAdd }
destructor TAdd.Destroy;
begin
ShowMessage('TAdd.Destroy');
inherited;
end;
function TAdd.Func(a, b: Integer): Integer;
begin
Result := a + b;
end;
{ TMul }
destructor TMul.Destroy;
begin
ShowMessage('TMul.Destroy');
inherited;
end;
function TMul.Func(a, b: Integer): Integer;
begin
Result := a * b;
end;
{ TForm1 }
procedure TForm1.Button1Click(Sender: TObject);
var
I: IMyInterface1;
begin
I := TAdd.Create;
ShowMessage(IntToStr(I.Func(9, 9))); {18}
I := TMul.Create; {I 在指向新的目标前会先释放前面所属的类}
ShowMessage(IntToStr(I.Func(9, 9))); {81}
end;
end.