delphi D11编程语言手册学习笔记(P344-392) 接口/类操作

郭姐姐 發表於 2022-12-4 09:58:00

delphi D11编程语言手册学习笔记(P344-392) 接口/类操作

<img src="https://img2022.cnblogs.com/blog/981841/202211/981841-20221121110647192-1287525760.png">
 
 这本书可以在 Delphi研习社②群 256456744 的群文件里找到. 书名: Delphi 11 Alexandria Edition.pdf
置顶: 好烧脑啊!
P344-365 接口
　　"接口" 的概念和 "类" 特别是 "抽象类" 近似, Delphi 之初并没有接口, 后来(Delphi 3)为了支持 COM 引入了接口, 再后来发展成为 Delphi 重要的语言特性.
　　使用 COM 步骤可能是这样的: 
　　　　1.程序在使用组件之初, 先联系 "接口"; 这应该是从注册表中查询. 
　　　　2.找到后, 如果此接口还没有被实现, 马上调用 "类厂" 建立起对象, 并同时给接口计数器加 1. 
　　　　3.可能会不止一个程序在使用同一个接口, 但每有使用则 "计数器+1", 每次用完则 "计数器-1". 
　　　　4.当接口的使用计数为 0 时, 系统自动释放类厂为该接口建立的对象(垃圾回收机制).
下面用代码来理解这段话:
 
<div class="cnblogs_code">
<pre>Type IFace = interface　　//声明一个接口
procedure proc;
end;

TAType = class(TInterfacedObject, IFace)　　//调用接口 　　 constructor Create;　　//构造函数
destructor Destroy; override;　　　　//解析函数 　　procedure proc;　　//在存在构造函数或解析函数时,方法属性一律写在最后,否则出错
end;

var
Form2: TForm2;

implementation

{$R *.dfm}

{ TAType }

constructor TAType.Create;
begin
inherited;
Form2.memo1.lines.add('TATypeConstructor!');
end;

destructor TAType.Destroy;
begin
inherited;
Form2.memo1.lines.add('TATypeDestroy!');
end;

procedure TAType.proc;
begin
Form2.memo1.lines.add('TAType.proc!');
end;

procedure TForm2.Button1Click(Sender: TObject);
var
A: IFace; //注意这里,这里声明的是一个接口
begin
A:= TAType.Create ; //然而这里去是用的类的构造函数,这里是接口的一个妙用.接口变量可以接一个实现了该接口的类 
 A.proc; 　　//A:=nil; //主动释放内存,同样的,拥有它的类也会被释放掉!    Form2.memo1.lines.add('---end---');
end;</pre>
</div>
 
<img alt="" loading="lazy" src="https://img2023.cnblogs.com/blog/981841/202212/981841-20221204164513415-1187741125.png">
 
 
 
 
　　与类相比,接口侧重于封装,并提供与类之间一种比继承更宽松一点的连接.
除了宣告抽象类(拥有抽象方法的类别)，在 Object Pascal 里面我们也可以撰写纯粹的抽象类;也就是只包含虚拟抽象方法的类别。透过使用特别的关键词，interface 来定义一组作为接口(interfaces)的数据型别。
 
从技术面来看,接口不算是类,虽然接口可以重组类.因为类可以建立实体,但是接口不行.接口可以被一个或者多个类调用,所以这些实体就可以算是支持了或者调用了该接口.讲人话就是: 接口是用来给类调用的抽象类.
类与接口的对比:
1.　　接口类型的变量会修改接口计数器,跟类类型的变量不同,接口提供了一系列的自动内存管理机制
2.　　一个类可以继承多个接口(要列在基础类后面): 
<div class="cnblogs_code">
<pre>　　TMyClass = class(父类, 接口1, 接口2, ...) 
　　 //Some Code
　　end;</pre>
</div>
　　但是一个接口只能从另一个接口继承过来,而不能同时继承多个接口,如果继承的对象是根接口Iinterface,则可省略.
<div class="cnblogs_code">
<pre>IMyInterface1 = interface(Iinterface)
function Func1: Integer;
function Func2: Integer;
end;</pre>
</div>
3.　　所有的类都是从TObject中衍生而来,所有的接口都是从IInteface衍生出来的,两都是各自独立正交的架构.
4.　　不成文约定:所有类名,除异常类型外以E开头外,其他都以T开头,而所有接口都以字母I开头.
5.　　接口只有方法与属性没有字段 
6.　　接口成员都是公开的,不需要private/protected/public/published等修饰语
7.　　因为接口只声明、无实现, 所以也用不到继承与覆盖相关的修饰(virtual、dynamic、abstract、override).
8.　　不管实现接口的类有多么丰富, 接口只拥有自己声明的成员.
9.　　实现接口的类一般继承于 TInterfacedObject, 直接从 TObject 继承会增加一些麻烦而重复的工作.
10.　接口在用完后会自动释放, 并同时释放拥有它的类; 这很方便, 但同时带来很多问题.
11.　每个接口具有唯一的标识符,称为GUID,在接口内按下Ctrl+Shift+G,IDE会自动产生一组GUID　　
<div class="cnblogs_code">
<pre> IFace = interface 　　//GUID,平常是由系统分配的,所以基本不用理会.这里只是演示
['{E5AC8E60-2DBE-43C5-B679-27731A56F3D4}']　　
procedure proc;
end;</pre>
</div>
 
 
 
接口的声明与调用:
　　和类的声明一样,接口也是在interface区域下用关键字type进行声明:
 
<div class="cnblogs_code">
<pre>unit Unit1;

interface

uses
Winapi.Windows, Winapi.Messages, System.SysUtils, System.Variants,
System.Classes, Vcl.Graphics, Vcl.Controls, Vcl.Forms, Vcl.Dialogs,
Vcl.StdCtrls;

type
TForm1 = class(TForm)
Memo1: TMemo;
Button1: TButton;
procedure Button1Click(Sender: TObject);
private
{ Private declarations }
public
{ Public declarations }
end;
//接口只有属性和方法,没有字段!并且只能继承一个祖先,如果是根接口,可以省略不写
//接口1 
IFace1 = interface
function Fn1(Str: string): string; //抽象方法,只有声明没有实体,按Ctrl+Shift+c无响应
end;
//接口2
IFace2 = interface
procedure Proc2; //抽象方法,只有声明没有实体,按Ctrl+Shift+c无响应
end;

//类调用上面的两个接口,注意先后顺序,先类,后接口,不然报错. //接口里有什么方法,调用的类里面就要定义什么方法,说白了就是抄一份下来 //否则会提示接口方法 IFace1.test 没有实现部分
TAType = class(TInterfacedObject, IFace1, IFace2)　　//先类后接口
function Fn1(Str: string): string;//这里要按Ctrl+Shift+c来完成方法实体
procedure Proc2;
end;

var
Form1: TForm1;

implementation

{$R *.dfm}

{ TAType }
//方法实体
function TAType.Fn1(str: string): string;
begin
Result := ('Fn1:' + str);
end;
//方法实体
procedure TAType.Proc2;
begin
ShowMessage('Fn2');
end;

procedure TForm1.Button1Click(Sender: TObject);
var
TA: TAType;
begin
Memo1.Clear;
Memo1.Lines.Add(TA.Fn1('哈哈哈'));//接口调用
TA.Proc2;//接口调用
end;

end.</pre>
</div>
 
<img src="https://img2023.cnblogs.com/blog/981841/202212/981841-20221204145409937-1677648729.png">
 
 
 接口属性:
<div class="cnblogs_code">
<pre>{此接口声明了一个 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;</pre>
</div>
 接口可以被多次调用.因为接口的方法是抽象的,实体部分要到调用接口的类里面才具现,所以类调用接口的方法时,方法能执行什么功能,还不是你说的算?
<div class="cnblogs_code">
<pre>type 　　//接口
IMyInterface1 = interface
function Func(a,b: Integer): Integer;
end;
//调用接口的类1,这里的方法执行的是加法
TAdd = class(TInterfacedObject, IMyInterface1)
public
function Func(a: Integer; b: Integer): Integer;　　//Result:= a+b;
destructor Destroy; override;
end;
//调用接口的类2,这里的方法执行的是乘法
TMul = class(TInterfacedObject, IMyInterface1)
public
function Func(a: Integer; b: Integer): Integer;　　//Result:= a*b;
destructor Destroy; override;
end;</pre>
</div>
  弱化引用使变量的接口计数器不被修改.
<div class="cnblogs_code">
<pre>type
TForm1 = class(TForm)
Memo1: TMemo;
Button1: TButton;
procedure Button1Click(Sender: TObject);
private
{ Private declarations }
public
{ Public declarations }
end;

IFace = interface
procedure test;
end;

Ttype = class(TInterfacedObject, IFace)
destructor Destroy; override;
procedure test;
end;

var
Form1: TForm1;

implementation

{$R *.dfm}

{ Ttype }

destructor Ttype.Destroy;
begin
Form1.Memo1.Lines.Add('Destroy');　　//在实体中调用控件的话,要加上完整的对象位置.
inherited;
end;

procedure Ttype.test;
begin
Form1.Memo1.Lines.Add('test');
end;</pre>
</div>
调用:
<div class="cnblogs_code">
<pre>procedure TForm1.Button1Click(Sender: TObject);
var
//
a: IFace;
begin
a:=Ttype.Create ;
a.test ;
Form1.Memo1.Lines.Add('---')
end;</pre>
</div>
 可以看到,在不使用 weak 弱化引用时,程序正常执行. 
<img src="https://img2023.cnblogs.com/blog/981841/202212/981841-20221205131221503-152656714.png"> 
 如果把 解除注释,则会出现内存错误.因为当a被创建时,因为weak的原因,a的接口计数器没有被加1,仍然等于0,所以系统就自动执行了destroy解析函数,把a给翻译掉了.当再执行a.test时,因为对象已经不存在,所以就会内存报错

<img src="https://img2023.cnblogs.com/blog/981841/202212/981841-20221205131453234-539900176.png">
 和不同,它不会主动去清除接口计数器,它是憜性的,下面的例子还是延用上面的代码,可以看到Destroy程序并没有被执行
<img src="https://img2023.cnblogs.com/blog/981841/202212/981841-20221205134408131-1061969747.png">
 
 
 
 
再看一个网上的例子:
<div class="cnblogs_code">
<pre>type
TA=class(TInterfacedObject)

end;

procedure TForm1.Button1Click(Sender: TObject);
var
a:IInterface;
aweak:IInterface;
begin
a:=TA.Create; //创建对象，复制给a，执行完成后引用计数器=1
aweak:=a; //由于aweak定义有属性，所以赋值给aweak后，引用计数器依旧为1，但aweak变量的地址被保存到一个weak关联列表中
Memo1.Lines.Add(Format('Ptr:%d', ));
a:=nil; //由于引用计数器=1，执行此句后，计数器清0，对象被释放，同时与此对weak关联列表中所有变量也被赋值为nil，包括aweak变量.
Memo1.Lines.Add(Format('Ptr:%d', ));
end;</pre>
</div>
 运行结果: Ptr:16360080 Ptr:0 weak引用非常适合用于两个对象需要互相引用的情况下，如果以往的引用，将无法让引用计数器清0.
 方法别名:
 
<div class="cnblogs_code">
<pre>IFace = interface
['{3BA60C4E-CA74-489C-B74B-3FA791BC2843}']
procedure Ptest;
function Ftest: string;
end;

IFace2 = interface
['{324AB107-95F1-4145-B392-2E6F555822E3}']
function Ftest: string;
end;

Ttype = class(TInterfacedObject, IFace, IFace2)
destructor Destroy; override;
procedure Ptest;
function F1: string;
function F2: string;
function IFace.Ftest = F1;
function IFace2.Ftest = F2;
end;</pre>
</div>
 
但是我在调用时,调不出F1和F2,不知道问题在哪里,在两个群问了半天,也没有等来答案,如果有大佬知道答案,麻烦指点一下,谢谢啦 
 
 <img src="https://img2023.cnblogs.com/blog/981841/202212/981841-20221205163243907-1654476776.png">
 
 
 P366-392 类操作
　　1.类方法与类函数.
　　　　在类里面声明的过程或者函数,只要在前面加上关键字class,就会变成类方法或者类函数. 　　　　
 　　　　类方法不能在 private 和 protected 区;
  
　　　　类方法不能是虚方法; 

　　　　类方法只能使用类中的、在对象实例化以前的数据.
　　　　类方法中包含一个隐藏参数self,它是指向类本身的一个参数 
　　　　字段不能定义在published区域.在没有任何修饰符的情况下,默认就是published.
<div class="cnblogs_code">
<pre>Ttest = class
private
class var
 i: Integer;
 var
 n: Integer;
public
var
 j: Integer;
class var
 k: Integer;
class procedure Ptest;
class function Ftest(o: integer): Integer;
end; --------------------------------- { Ttest }

class function Ttest.Ftest(o: integer): Integer;
begin
Result := o * 5;
end;

class procedure Ttest.Ptest;
begin
i := k * 2;
ShowMessage(i.ToString); 　ShowMessage(Self.ClassName);
end; //调用
procedure TForm1.Button1Click(Sender: TObject);
begin
Ttest.i := 100; //i=100
//Ttest.n := 100;//ERROR,需要create
//Ttest.j := 100; // ERROR,需要create
Ttest.k := 100; //k=100
Ttest.Ptest; //show 200(K*2) show Ttest
ShowMessage(ttest.Ftest(10).ToString);//show 50(10*5) 
end;</pre>
</div>
上面的代码中,从头到尾都没有对TTest进行create过,但是对于在定义阶段有加class的方法和字段,跟全局变量一样都是可以直接拿来使用的.相反,没加class的字段,在直接使用时全部都出现了异常.因为他们都需要创建实例后才能正常使用.
警告:使用没有经过初始化(赋值)的字段会抛出异常错误!
 
 
类方法就是通过类名就可以访问的方法.或者你可以把它理解为命名空间也行.因为全局变量不被提倡,放到类里面就很好处理了,因为类里面有private,  strict private ,public ,published ,protected等各种保护限制.当你要调用这些类方法或者类函数时,你得这么写: 类名.类方法,或者类名 .类函数,这样就达到命名空间的效果.
调用时,这个类可以完全不用create而直接使用它内部的类方法与类函数:
<div class="cnblogs_code">
<pre>procedure TForm1.Button1Click(Sender: TObject);
var
MyType: TMyType;
str: string;
begin
MyType.Ptest;
str := MyType.F1; MyType.Destroy;
end;</pre>
</div>
　　2.类的静态方法
<div class="cnblogs_code">
<pre>{现在的 Delphi 不仅仅有类方法, 同时有:
类变量: class var
类常量: class const
类类型: class type
类属性: class property

静态类方法就是给类属性来调用的, 它可以存在于私有区(private),
譬如下面的 SetName 就是一个静态类方法:
}
TMyClass = class(TObject)
private
class var FName: string;
class procedure SetName(const Value: string); static; {静态类方法又多了一个 static 指示字}
published
　class property Name: string read FName write SetName;
end;</pre>
</div>
 静态类方法相比类方法
　　1.静态方法多了一个关键字,就是在定义的末尾加上了Static.
　　2.静态方法没有隐藏的self参数,可以被当作callBack函数传给Windows API函数.
静态方法的调用约定: 
　　只要记住Windows API参数调用是从右往左,D的调用方式跟他是想反的.
　　凡是在D里面调用Windows API函数的,肯定要加 static;stdcall ; 进行转化 
　　
　　下面这一段转自https://blog.csdn.net/aaa000830/article/details/79986275　
-----------------------------------------------------------------------------------------------------------------------
注：使用错误，或者在该加的地方没有加，可能会出现"privileged instruction"错误，或者地址访问错误。
常见的调用惯例有register, pascal, cdecl, stdcall, safecall。函数的调用管理决定了参数如何传递给子过程，并从堆栈中退出，以及寄存器在参数传递中的使用，错误和异常的处理。Delphi中默认的调用惯例是register。 　　1) register和pascal：参数从左向右传递，也就是说最左边的参数最先求值并传入，最右边的参数最后求值和传入。cdecl，stdcall和safecall则按从右向左方向。 　　2) 对于除cdecl之外的所有调用惯例，函数/过程在返回的时候要把堆栈中的参数退栈。对cdecl惯例，调用者在被调用的过程返回后执行参数退栈操作 　　3) register调用惯例最多能用3个CPU寄存器来传递参数，而其它调用惯例只能通过堆栈来传递参数 　　4) safecall调用惯例实现了异常的防火墙。在Windows上实现了跨进程的COM错误通知机制。 　　5) register调用效率最高，因为它避免了堆栈的创建。Delphi中published属性必须是register。 　　6) cdecl常用于调用C/C++编写的共享库中的函数；但是，如果要调用外部代码，那么一般要用stdcall和safecall 　　7) 在Windows上，系统的API都是stdcall和safecall；在其它操作系统上通常用cdecl（注意：stdcall比cdecl效率要高） 　　8) 在dual-interface（双接口）方法中必须用safecall惯例。 　　9) pascal惯例是为了向后兼容；near/far/export用于16位Window编程中的函数调用，在32位的应用程序中不发挥作用，仅仅是为了向后兼容。
　　10)即使静态方法只有一个参数,也要标明调用约定,因为不同的方式,汇编会最后给你弄不同的返回方式. 下表进行了总结： Calling conventions Parameter order Clean-up Passes parameters in registers？ register Left-to-right Routine Yes pascal Left-to-right Routine No cdecl Right-to-left Caller No stdcall Right-to-left Routine No safecall Right-to-left Routine No
--------------------转载结束-----------------------------------------
 静态类的属性(class property):
<div class="cnblogs_code">
<pre>Ttest = class
private
class var
 FMyName: string;
public
class function GetMyName: string; static;
class procedure SetMyName(Value: string); static; 　　//下面这两种方法是等价的,二选一
class property MyName: string read GetMyName write SetMyName;
class property DirectName: string read FMyName write FMyName;
end;

var
Form1: TForm1;

implementation

{$R *.dfm}

procedure TForm1.Button1Click(Sender: TObject);
begin
Ttest.SetMyName('张飞');
ShowMessage(Ttest.FMyName);　　//show 张飞
ShowMessage(Ttest.GetMyName);　　//show 张飞
end; 
{ Ttest }
class function Ttest.GetMyName: string;
begin
Result := fmyname;
end;

class procedure Ttest.SetMyName(Value: string);
begin
fmyname := Value;
end;</pre>
</div>
这是说一下class var 与 var的区别.var是用来与class var做区分的,算了,我文笔不太好,还是用代码来说明吧
<img src="https://img2023.cnblogs.com/blog/981841/202212/981841-20221208095837959-1767355557.png">
 
 
<img src="https://img2023.cnblogs.com/blog/981841/202212/981841-20221208100018086-835397049.png">
 还有一种方法,就是把calss var变量写在限制区域的最后面,这样就不会影响到其他字段了,比如
<img src="https://img2023.cnblogs.com/blog/981841/202212/981841-20221208090637019-1560172955.png">
类的构建函数与解析函数.
　　构建/解析函数优先级大于单元文件初始区(iniialization)与单元结束区(finalization).
　　我们可以通过constructor和destructor关键字创建多个构建/解析函数,却不能使用class创建第二个类构建/类解析函数
<img src="https://img2023.cnblogs.com/blog/981841/202212/981841-20221208101651020-1510675830.png">
 
　　单例模式  (Singleton Pattern)
Singleton Pattern模式的设计意图是：保证一个类仅有一个实例，并提供一个访问他的全局访问点。单例模式在应用开发中比较常见，如 Application 或 Logger。在面试考试中出现率很高,别看书上一面带过,实际上还是有点复杂的,可以在B站上面搜索看看.
在 Delphi 的以前版本中，实现单例模式比较“另类”，自从 Delphi 后期加入一些新的语法元素后，单例模式的实现显得更为标准，和 C++、Java 中的实现方法几乎一致，最主要原因就是 Delphi 加入了类变量的支持，关键字为”class var”。 Delphi 同时支持类属性，可以让单例的访问更为友好；同时需要注意，在实现单例模式时，一定不要忘记把类本身的 Create 构建函数隐藏，否则的话，单例的实现将没有意义。 下面的代码实现了单例模式的 TLogger：
<div class="cnblogs_code">
<pre>type
TLogger = class ( TObject )
private
class var
 FInstance: TLogger;
class function GetInstance: TLogger; static;
protected
constructor Create;
public
procedure Login;
procedure Logout;
class procedure ReleaseInstance;
class property Instance: TLogger read GetInstance;
end; </pre>
</div>
Delphi Class of 类引用
以下内容转自http://t.zoukankan.com/yzryc-p-6396164.html
Delphi Class of 类引用也就是类的类型，也可说是指向类的指针
<div class="cnblogs_code">
<pre>Type
TControlCls = Class of TControl;
function CreateComponent(ControlCls: TControlCls): TControl;
begin
 result:=ControlCls.Create(Form1);
 ...
end;</pre>
</div>
前者要求传入一个类, 而后者要求传入一个对象(类的实例)
<div class="cnblogs_code">
<pre>type
MyClassRef=calss of CMyClass //表示MyClassRef为指向CMyClass或其父类的指针</pre>
</div>
类的引用就像指向类的指针一样 类引用就是类的类型，可以声明一个类引用变量赋给它一个类，可以通过这个变量创建对象的实例。
类的类,当你不确定调用的类模型时候用到类的类。也可以说是类指针~
System单元的TObject有如下方法： function ClassType: TClass;
它就是获取对象的类类型，它的返回类型TClass就是class of TObject。
因为所有类都派生自TObject，所以所有对象都可以调用ClassType。比如：
<div class="cnblogs_code">
<pre>procedure TForm1.Button1Click(Sender: TObject);
var
S: TStringList;
C: TClass;
begin
S := TStringList.Create;
C := S.ClassType;
ShowMessage(C.ClassName);//对话框会显示出来TStringList，相当于TStringList.ClassName
S.Free
end;</pre>
</div>
而C.ClassName调用的是TObject的类方法ClassName，
原型：class function ClassName: ShortString;
就是说不需要用实例化的对象去调用，直接用类去调用就行了；不过用对象调用也是可以的，因为对象空间也保存了类的VMT地址。 
用类调用形如：TStringList.ClassName 用对象调用形如：S.ClassName
 
一个有意思的语法 :
<h3>class help for  类助手(我不知道该叫什么,书上译为类别助手), 对现有的类进行扩展，如果把类理解为一个容器，那么这条语法的作用是对现有的类的容器的成员进行扩展或者修改。</h3>
<div class="cnblogs_code">
<pre>TTest = class　　　　//主类,正常定义
private
Fnumber: Integer;
FText: string;
public
FText2: string;
procedure increase;
constructor Create;
end;

TTestHelp = class helper for TTest　　　　//类助手,关键字为class Helper for后面跟主类名
private
procedure Show;　　//可以扩充主类的属性和方法
public
procedure increase; //将会覆盖掉原有的属性
function test(): string;　　//可以扩充主类的属性和方法
constructor Create(); //将会覆盖掉原有的方法
end;

var
Form1: TForm1;

implementation

{$R *.dfm}

{ ttest }

constructor TTest.Create();　　
begin
inherited;
Fnumber := 100;
FText := '123';
FText2 := 'TTest.Create';
Form1.Memo1.Lines.add(FText2);
end;

procedure TTest.increase;
begin
Inc(Fnumber);
Form1.Memo1.Lines.add(Fnumber.ToString);
end;

{ TTestHelp }

constructor TTestHelp.Create();
begin
inherited;
Fnumber := 100;
FText := 'abc';
FText2 := 'TTestHelp.Create';
Form1.Memo1.Lines.add(FText2);
end;

procedure TTestHelp.increase;
begin
Dec(Fnumber);
Form1.Memo1.Lines.add(' TTestHelp.increase:' + Fnumber.ToString);
end;

procedure TTestHelp.Show;
begin
Form1.Memo1.Lines.add('TTestHelp.Show');
end;

function TTestHelp.test(): string;
begin
Result := 'TTestHelp.test';
Form1.Memo1.Lines.add(Result);
end;
 //调用
procedure TForm1.Button1Click(Sender: TObject);
var
test: TTest;
begin
test := TTest.Create;　　
test.show;
test.test();
end;</pre>
</div>
输出如下:
<img src="https://img2023.cnblogs.com/blog/981841/202212/981841-20221210152837338-1343097019.png">
 
 
 
概括一下类助手的特点:
　　1.主类必须是已存在的类,定义时也要注意先后顺序,先定义主类,再定义类助手,否则报错,这一点应该不难理解吧.
　　2.类助手可以扩充主类的方法和属性.扩充的方法和属性可以是类方法,类变量与类属性,甚至还可以是虚拟方法!
　　3.字段只能定义在主类中,类助手中不允许定义字段,否则会提报错: E2599 字段定义不允许在帮助器类型中
　　4.主类和类助手是一体的,相当于把类助手的所有方法和属性都并到了主类里,同名即覆盖.
　　包括构建函数和解析函数.也包括方法和属性的访问权限.比如主类里面是private,类助手是可以把它设置成public覆盖过去的.
　　打个比方法,就像我们平时,把文件从A位置复制到B位置,然后中途弹出一个提示框,说存在同名文件,问你要不要覆盖,然后你选择了覆盖.
　　5.引用外部资源的类助手文件,必须在USES区域中加入.
　　6.编译器只承认最后一个类助手.注意!这里不是覆盖啦!是忽视最后一个类助手之前的所有类助手!!只取最后一个类助手进行覆盖!!然后你是不是想套娃?比如给类助手再配个助手?　　
<div class="cnblogs_code">
<pre> TTestHelp2 = class helper for TTestHelp //ERROR : E2021 需要class类型</pre>
</div>
　　天真了吧!解决的方案之一是真·套 "娃" ,这二是取别名(下面会讲)...重新定义一个类,让它继承原来的主类TTest,然后再给TTest2定义一个类助手,书中建议不要这么用,因为这会让类结构复杂化,源码难于解读.
<div class="cnblogs_code">
<pre> TTest2=class (TTest )
//something
end;
TTestHelp2 = class helper for TTest2
public
procedure aaa;
end;</pre>
</div>
 
　　7.类助手的意义在于弥补主类功能上的不足,而不是覆盖.覆盖会使人解读混乱.希望读者能明白这一点.用下面这个例子帮助大家理解:
我们通常取ListBox当前选中的值,都是
<div class="cnblogs_code">
<pre>ListBox1.Items </pre>
</div>
现在我觉得它使用起来太麻烦了,我需要按照我自己的方法来实现:
<div class="cnblogs_code">
<pre>type
TListboxHelper = class helper for TListBox　　//扩展
function ItemIndexValue: string;
end;
function TListboxHelper.ItemIndexValue: string;
begin
Result := '';
if ItemIndex >= 0 then
Result := Items ;
end; //调用 str:= ListBox1.ItemIndexValue;</pre>
</div>
record helper for 与 class helper for相似,它是针对记录类型的.暂且叫它记录助手吧. 
SysUils里的一些记录助手:
<div class="cnblogs_code">
<pre>TGUIDHelper = record helper for TGUID
TStringHelper = record helper for string
TSingleHelper = record helper for Single
TDoubleHelper = record helper for Double
TExtendedHelper = record helper for Extended
TByteHelper = record helper for Byte
TShortIntHelper = record helper for ShortInt
TWordHelper = record helper for Word
TSmallIntHelper = record helper for SmallInt
TCardinalHelper = record helper for Cardinal
TIntegerHelper = record helper for Integer
TUInt64Helper = record helper for UInt64
TInt64Helper = record helper for Int64
TNativeUIntHelper = record helper for NativeUInt
TNativeIntHelper = record helper for NativeInt
TBooleanHelper = record helper for Boolean
TByteBoolHelper = record helper for ByteBool
TWordBoolHelper = record helper for WordBool
TLongBoolHelper = record helper for LongBool
TCurrencyHelper = record helper for Currency // added in Delphi 11</pre>
</div>
 
类型助手:
　　我们上面说过,编译器对于类助手与记录助手,只会识别最后一个助手,除了真套娃,还有其他方法吗?书上说:定义一个类型别名.类型别名会被编译器当成一个全新的类型,所以它可以拥有它自己的类助手.打个比方:银行规定一个人只能开一个账户(我们抛开银行开户的逻辑不谈),张三开了一个账户之后 ,又取了个小名叫张飞又开了一个账户,这样张三就有了两个账户了(助手).当张三想用第一个账户时,他就是张三,当他想用第二的账户时,他只需要转换一下身份,变成张飞就可以了.
<div class="cnblogs_code">
<pre>type
MyInt = type Integer;　　//要取别名,因为系统中已存在 TIntegerHelper = record helper for Integer

TMyIntHelper = record helper for MyInt
function AsString: string;
end;

function MyIntHelper.AsString: string;
begin
　　Result := IntToStr (self);
end;

//调用
procedure TForm1.Button1Click(Sender: TObject);
var
MI: MyInt;
begin
MI := 10; 
Show (MI.AsString); 
// Show (MI.toString); // this doesn't work 
Show (Integer(MI).ToString)
end;</pre>
</div>
  
来源：https://www.cnblogs.com/yoooos/p/16949443.html

頁: [1]

琼殿技术论坛's Archiver

delphi D11编程语言手册 学习笔记(P344-392) 接口/类操作

delphi D11编程语言手册学习笔记(P344-392) 接口/类操作