Delphi常用关键字用法详解-白红宇

Delphi常用关键字用法详解

阅读量：6114 次

发布时间：2019-06-21

本文共 28472 字，大约阅读时间需要 94 分钟。

本文详细介绍了Delphi中常用的各个关键字名称及用法，供大家在编程过程中借鉴参考之用。详情如下：

absolute：

                            
//它使得你能够创建一个新变量, 并且该变量的起始地址与另一个变量相同.
var
 
Str: 
string
[
32
];
 
StrLen: 
Byte
absoluteStr;
//这个声明指定了变量StrLen起始地址与Str相同.
//由于字符串的第0个位置保存了字符串的长度, 所以StrLen的值即字符串长度.
begin
Str := 
'abc'
;
Edit1
.
Text := IntToStr(StrLen);
end
;
         
       

abstract：

                            
//它允许你创建抽象的方法, 包括有抽象方法的类称为抽象类.
//Abstract关键字必须与Virtual或Dynamic关键字同时使用, 因为抽象方法必须被覆盖式实现.
//抽象类不能实例化, 抽象方法不能包含方法体.
type
 
TDemo = 
class
  
private
  
protected
   
procedure
X; virtual; abstract;
  
public
   
constructor
Create;
   
destructor
Destroy; override;
  
published
 
end
;
         
       

and：

                            
//一、表示逻辑与
if
(a>
0
) 
and
(b>
0
) 
then
//二、表示位运算
var
a,b,c: 
Integer
;
begin
c := (a 
and
b);
end
;
//使用And表示逻辑时, And左右的表达式必须用小括号括起, 以避免以生条件的冲突.
//例如:
if
a>
0
and
b>
0
then
//编译器可能会理解为:
if
a>(
0
and
b)>
0
then
//或:
if
(a>
0
) 
and
(b>
0
) 
then
//但是实际编译时, 编译器会产生一个冲突, 报告错误.
//并且第一种可能包含了a>b>c的形式, 这在Delphi中不被支持.
//所以使用And运算符时必须使用括号, 以区分左右的条件.
//表示位运算时也必须加上括号, 将And以及左右参数括起.
         
       

array：

                            
//Array用于表示数组, 任何的对象都能被声明成数组.数组分为静态和动态的２种.
//静态数组
var
Arr1: 
array
[
1..10
] 
of
Integer
;
//动态数组, 由于声明时不知其元素个数, 所以必须在后期用SetLength方法设置数组的大小
var
Arr2: 
array
of
Integer
;
//数组作为参数时, 不能传入数组的大小, 只能传入数组名, 然后用Length方法获取数组的元素个数
function
X(A: 
array
of
Integer
): 
Integer
;
var
i: 
Integer
;
begin
Result := 
0
;
for
i := 
0
to
Length(A)-
1
do
Result := Result + A[i];
end
;
         
       

as：

                            
//As用于将一个对象转换为另一个对象
procedure
BtnClick(Sender:TObject);
begin
 
(Sender 
as
TButton).Caption := 
'Clicked'
;
end
;
//对于对象填充接口的转换, 必须用As进行
(HTTPRIO 
as
IExp).GetConnection;
//As不能用于数据类型的转换, 下面的代码是错误的:
var
i: 
Integer
;
s: 
string
;
begin
s := (i 
as
string
);
end
;
//正确写法是:
s := 
string
(i);
         
       

asm：

                            
//Asm关键字用于插入汇编代码, 使用汇编代码时, 必须使用asm...end;的结构, 而非begin...end;
function
IntToHex(Value: 
Integer
; Digits: 
Integer
): 
string
;
asm
 
CMP EDX, 
32
 
JBE @A1
 
xor
EDX, EDX
 
@A1: PUSH ESI
 
MOV ESI, ESP
 
SUB ESP, 
32
 
PUSH ECX
 
MOV ECX, 
16
 
CALL CvtInt
 
MOV EDX, ESI
 
POP EAX
 
CALL System.@LStrFromPCharLen
 
ADD ESP, 
32
 
POP ESI
end
;
         
       

assembler：

                            
//Assembler关键字用于支持早期的汇编, 如80386等.
//它和Asm的区别:Asm允许使用Win32汇编, 而Assembler只允许80x86汇编, 它不允许Invoke语句的出现.
function
IntToHex(AValue: 
Int64
): 
string
; assembler;
         
       

automated：

                            
//Automated访问区分符用于描述一个自动类型的成员, 它能够使程序的版本向下兼容.
//ComObj单元内的成员及其实例不能使用Automated访问区分符.
type
 
TDemo = 
class
  
automated
   
Str:
WideString
;
 
end
;
//在程序的下一个版本中, 将Str做了修改, 变成
type
TDemo = 
class
automated
Str: 
AnsiString
;
end
//则新版本的Str变量能够接受旧版本的WideString型数据, 并自动转换成AnsiString.
//在实际开发中, 如果没有特殊的需要, 一般不用automated访问区分符.
         
       

begin：

                            
//begin关键字用于表示一段程序或一个结构的开始, 必须用end关键字来结束.
procedure
X;
begin
 
ShowMessage(
'A Demo'
);
end
;
//一般的结构, 如If, For, While等也需要用begin关键字来标出结构起始点
for
i:=
1
to
100
do
begin
sum := sum + i;
if
sum > 
1000
then
Break;
end
;
         
       

case：

                            
//Case语句用于完成条件选择, Case语句的的被选择对象必须是有序类型, 包括整型, 枚举类型, 字符型等.
//Case语句必须由end结束,如果没有相符合的选择项, 可以加入else来作出通用选择.
function
GetDays(AYear,AMonth: 
Integer
): 
Integer
;
begin
 
case
AMonth 
of
  
1
,
3
,
5
,
7
,
8
,
10
,
12
: Result := 
31
;
  
4
,
6
,
9
,
11
: Result := 
30
;
  
2
: 
begin
  
if
IsLeapYear(AYear) 
then
   
Result:=
29
  
else
   
Result:=
28
;
  
end
;
 
else
  
Result:=
0
;
end
;
         
       

cdecl：

                            
//Cdecl是函数调用协定的一种, 它规定了从C或C++编写的DLL中调用函数所必须遵守的规则.
//它可以将C或C++中的数据类型转换为Delphi的.
//例如C++中的代码:
int X(int i)
{ 
 
return i*2;
}
//这个函数被编译在Demo.dll中, 用Delphi调用时必须使用:
function
X(i: 
Integer
): 
Integer
; Cdecl; external 
'Demo.dll'
;
         
       

class：

                            
//Class关键字用于声明或继承一个类, 也可以使类和接口同时继承.
//另外, Class关键字也能用于声明类通用方法, 使得父类可以从类内访问子类的方法.
type
 
ClassDemo = 
class
(TObject)
  
private
  
public
   
constructor
Create;
 
end
;
//如果用class声明方法, 则该方法在类与相关类中都可以使用, 譬如:
type
ClassA = 
class
private
public
procedure
Y;
end
;
type
ClassB = 
class
(ClassA)
private
public
class
procedure
X;
end
;
//则在使用时ClassA能够直接访问ClassB的X方法
procedure
ClassA
.
Y;
begin
Self
.
X;
end
;
//此时父类将子类的class方法作为自身的方法进行调用.
         
       

const：

                            
//Const关键字用于声明常量, 使用const声明的数据将不能在程序中被改变.
//也可以用来声明函数参数, 用const指定的参数不允许在函数中改变.
const
MyFileName = 
'Delphi'
;
const
MyInteger = 
100
;
//用Const声明常量不需要指出其数据类型, 系统会自动判断类型, 并作自动调整.
//函数中可以用const声明不可更改的参数
function
X(
const
i: 
Integer
): 
string
;
//此时在函数操作过程中, i的值不可改变.
         
       

constructor：

                            
//constructor关键字用来声明一个类的构造函数, 当类被实例化时, 首先调用此函数
//构造函数一般用Create表示, Create方法能够连带类中存在的CreateWnd方法.
type
 
ClassDemo = 
class
(TObject)
  
private
   
fValue: 
Integer
;
  
public
   
constructor
Create;
 
end
;
constructor
ClassDemo
.
Create;
begin
fValue := 
0
;
end
;
         
       

contains：

                            
//Contains关键字指出了某个包(Package)是否包含某个文件.
//用Contains引入的文件必须被添加到包文件中, 它可以避免关键文件的引用丢失.
package DATAX;
 
requires
  
rtl, clx;
 
contains
  
Db, DBLocal, DBXpress;
end
.

default：

                            
//Default关键字用于指出一个属性的默认值
//只有有序类型的属性才允许默认值的存在, 否则必须在构造函数中初始化属性值.
type
 
ClassDemo = 
class
  
private
   
fValue: 
Integer
;
  
published
   
property
Value: 
Integer
read fValue 
write
fValue default 
0
;
 
end
;
//它也可以指出一个类的默认属性
property
strings[Index: 
Integer
]: 
string
read GetString 
write
PutString; Default;
         
       

destructor：

                            
//Destructor用于标识析构函数, 析构函数在类被释放时自动调用.
//析构函数只允许覆盖, 再不允许重载.析构函数通常用Destroy作为函数名.
type
 
ClassDemo = 
class
(TComponent)
  
public
   
destructor
Destroy;override;
 
end
;
//由于TComponent类中也有Destroy方法, 所以要将其重写
//但是若要重载析构函数, 则不允许, 下面代码是错误的:
destructor
Destroy; overload;
         
       

dispid：

                            
//DispId关键字被用在DispInterface接口中, 用于指定特定的适配序号.
//在DispInterface接口中, 适配序号必须是唯一的, 
//如果不指定DispId, 则系统会自动分配适配序号给接口内每一个方法.
//可以通过适配序号访问DispInterface接口中的方法.
type
 
IStringsDisp = dispinterface
  
[
'{EE05DFE2-5549-11D0-9EA9-0020AF3D82DA}'
]
  
property
ControlDefault[Index: 
Integer
]: Olevariant dispid 
0
; default;
  
function
Count: 
Integer
; dispid 
1
;
  
property
Item[Index: 
Integer
]: Olevariant dispid 
2
;
  
procedure
Remove(Index: 
Integer
); dispid 
3
;
  
procedure
Clear; dispid 
4
;
  
function
Add(Item: Olevariant): 
Integer
; dispid 
5
;
  
function
_NewEnum: IUnknown; dispid -
4
;
 
end
;
         
       

dispinterface：

                            
//DispInterface用于声明一个特定的适配器接口, 这个适配器能够接受标准系统接口中传入传出的数据.
//用DispInterface声明的接口不能被继承, 只能够被引用.
//DispInterface中方法只能调用, 并且必须被动态绑定.
//可以通过DispId为接口内方汉分配适配序号.
//DispInterface仅能用于Windows平台, 如果在Linux下进行开发, 则此关键字会自动被系统屏蔽.
//通常情况下, 不使用DispInterface.
//实例请参见DispId
         
       

div：

                            
//Div用于求两数之整数商.用于Div运算的两个数值必须均为整型, 其运算结果也为整型.
var
 
a,b,c:
Integer
;
begin
 
a := 
20
; b := 
3
;
 
c := a 
div
b; 
{6}
end
;
         
       

do：

                            
//Do关键字用于For, While, On, With语句, 构成特定的结构
//For语句:
for
i := 
1
to
100
do
sum:=sum+i;
//While语句:
while
i < 
100
do
begin
　sum := sum + i;
　Inc(i);
end
;
//On语句(异常处理):
try
　i := StrToInt(s);
except
　
on
exception 
do
ShowMessage(
'Error!'
);
end
;
//With语句:
with
Memo1
.
Lines 
do
begin
　Clear;
　Append(
'abc'
);
　Append(
'123'
);
end
;
         
       

downto：

                            
//DownTo关键字用于For语句, 指明循环变量是递减的.
for
i := 
100
downto
1
do
ListBox1
.
Items
.
Add(IntToStr(i));
//在For语句中, 循环变量递增用To关键字, 递减用DownTo关键字.
         
       

dynamic：

                            
//Dynamic用于声明一个动态的方法, 
//动态方法可以被覆盖, 并且可以使代码大小尽可能的减少(区别于Virtual).
procedure
X(i: 
Integer
); dynamic;
         
       

else：

                            
//else用于引导程序的运行方向, 它可以与If, Case和On语句联用, 当条件不满足时, 转到else下运行
//If语句(在If语句中, else前不允许有分号):
if
a > b 
then
c := a
else
c:=b;
//Case语句:
case
Tag 
Of
1
:Result:=
1
;
2
:Result:=
2
;
3
:Result:=
3
;
else
Result:=
0
;
end
;
//On语句(异常处理):
try
i := StrToInt(s);
Excpet
on
EZeroDivide 
do
Result := 
1
;
on
EOverflow 
do
Result := 
2
;
else
Result := 
0
;
end
;
         
       

end：

                            
//End用于结束一个语句块或是一个单元.
//它可以与begin, Case, Class, Interface, Asm, Unit, Package等相匹配.
//对于语句块(局部结束), End后必须添加分号.
//而对于单元或包(全局结束), end后必须添加句号.
//在If语句中else关键字前的End后不允许添加符号.
procedure
X;
begin
　
with
Button1 
do
　
begin
　　
if
Button1
.
ShowHint 
then
　　　Button1
.
Caption := 
'Hinted'
　　
else
　　　Button1
.
Caption := 
'Not Hinted'
;
　
end
;
end
;
//在包内使用End来结束:
package DATAX;
requires
rtl,
clx;
contains Db, DBLocal, DBXpress;
end
.
         
       

except：

                            
//except关键字用于异常处理, 必须用在try语句内, 如果发生异常, 则执行except后的语句
try
 
i := StrToInt(s);
except
 
ShowMessage(
'Error!'
);
end
;
         
       

export：

                            
//Export标明了函数调用协定, 指出函数可以被输出, 输出的函数能被本地或远程调用.
//其他程序可以用dll的形式调用程序内的函数.它是向下兼容的.
function
Add(a,b: 
Integer
): 
Integer
; export;
//如果这个程序被编译为Demo.exe, 并且另一个程序需要调用这个函数, 可以使用以下语句
function
Add(a,b: 
Integer
): 
Integer
; stdcall; external 
'Demo.exe'
;
         
       

exports：

                            
//exports用于输出对象, 它必须被用在接口和实现之间, 可以同时输出多个项, 项与项之间用逗号分开.
libraryDemo;
function
X(i: 
Integer
): 
string
; stdcall;
begin
　Result:=IntToStr(i);
end
;
exports
　X;
begin
end
.
//如果输出的对象被重载, 则必须给对象起个别名, 并注明参数.
library
Demo;
function
X(i: 
Integer
): 
string
; overload; stdcall;
begin
　Result := IntToStr(i);
end
;
function
X(s: 
string
): 
Integer
; overload; stdcall;
begin
　Result := StrToInt(s);
end
;
exports
X(i: 
Integer
) name 
'x1'
,
X(s: 
string
) name 
'x2'
;
begin
end
.
         
       

external：

                            
//External关键字用于引用一个外部的或是OBJ内的方法.
{$L Demo.OBJ}
procedure
X(i:
Integer
);external;
//如果是从dll或外部程序中引用, 则可以使用以下代码:
function
A(FileName: 
string
): 
string
; external 
'Demo.dll'
;
//如果被引用的函数被重载, 则必须另外指出引用的名称.
function
A(Name: 
string
): 
string
; overload; stdcall; external 
'Demo.dll'
name 
'A1'
;
function
A(Code: 
Integer
): 
string
; overload; stdcall; external 
'Demo.dll'
name 
'A2'
;
//使用External关键字时, 必须注意大小写, 否则将出现错误.
         
       

far：

                            
//Far标明了函数调用协定, 指出函数可以被远程调用.
//其他程序可以用dll的形式调用程序内的函数.它是向下兼容的.
functionAdd(a,b: 
Integer
): 
Integer
; Far;
//如果这个程序被编译为Demo.exe, 并且另一个处于其他计算机的程序需要调用这个函数, 可以使用以下语句:
function
Add(a,b: 
Integer
): 
Integer
; stdcall; external 
'Demo.exe'
;
         
       

file：

                            
//File关键字指出了文件操作类型, 文件必须被声明为File, 
//如果在File后追加Of和文件类型, 则文件可以被定义为读写指定类型数据.
type
 
TPerson = 
record
  
PName: 
string
[
32
];
  
PAge: 
Integer
;
 
end
;
var
 
PFile: 
file
of
TPerson;
         
       

finalization：

                            
//finalization关键字标识了单元被释放时所要调用的方法, 
//通常是释放掉单元中不能自动释放的对象, 也可以不用.
//finalization最常用的情况是对OLE对象做反初始化.
initialization
 
ActiveX
.
OleInitialize(
nil
);
finalization
 
ActiveX
.
OleUninitialize;
         
       

finally：

                            
//finally关键字指出了异常处理中最后必须要调用的方法, 
//不论是否发生异常, finally后的语句总是在try语句结束时执行.
try
 
Node := Node
.
GetNext;
 
Edit1
.
Text := Node
.
Text;
finally
　Node := 
nil
;
end
;
         
       

for：

                            
//For关键字引出For循环结构, 用于做指定次数的循环.
for
i := 
1
to
100
dosum := sum + i;
//如果循环变量是递减的, 则可以用DownTo关键字
for
i := 
100
downto
1
do
Inc(sum);
         
       

forward：

                            
//Forward关键字用于方法的前置定义.只定义方法声明, 然后在程序的后面对方法进行实现.
//这么做有利于代码的可读性, 可以将所有的声明放在一起, 然后将所有的实现也放在一起.
function
X(i: 
Integer
): 
Integer
; forward;
procedure
Y(s: 
string
); forward;
...
function
X;
begin
 
Result := i * 
2
;
end
;
procedure
Y;
begin
WriteLn
(s);
end
;
//用Forward前置声明的方法在实现时不需要再输入方法的参数和返回值, 直接使用方法名即可.
         
       

function：

                            
//Function用于声明函数
functionX(i: 
Integer
): 
Integer
;
//它也可以用于动态函数的声明
type
　TFun = 
function
(i: 
Integer
): 
Integer
of
object
;
//动态声明时, 不需要指出函数名, 只需要指出参数和返回类型就可以, 具体的函数名可以在后期绑定.
         
       

goto：

                            
//Goto语句用在跳转行号, 可以跳转到当前结构层内任意位置.
//必须在声明处用label关键字声明行号.
//由于Goto语句会破坏程序的结构, 不推荐使用.
var
　a,b: 
Integer
;
label
　X,Y;
begin
　
if
a > b 
then
　　
goto
X
　
else
　　
goto
Y;
X:
　
WriteLn
(
'a > b'
);
Y:
　
WriteLn
(
'b > a'
);
end
;
         
       

if：

                            
//If关键字引出If条件语句, 用于对条件进行判断.
var
　a,b: 
Integer
;
begin
　a := 
2
; b := 
3
;
　
if
a>b 
then
　　
WriteLn
(
'a='
+ IntToStr(a))
　
else
　　
WriteLn
(
'b='
+ IntToStr(b));
end
;
//If语句的通常结构是If...Then...else, else语句也可以不要.
//在If语句内如果有多个子语句, 则必须用begin...End结构进行区分.
if
a > b 
then
begin
　
WriteLn
(
'a>b'
);
　
WriteLn
(
'a='
+ IntToStr(a));
　
WriteLn
(
'b='
+ IntToStr(b));
End
else
　
WriteLn
(
'b>a'
);
         
       

implementation：

                            
//Implementation标识了单元中的实现部分, 单元的基本结构为:
//Unit...Interface...implementation...end.
//函数体, 过程体等必须写在implementation关键字后.
//如果在implementation后引用对象, 则对象是非公开的, 仅能供单元自身使用.
implementation
 
uses
frmAbout;
begin
 
FormAbout
.
Show;
end
;
//一个完整的单元必须拥有implementation部分.
         
       

implements：

                            
//Implements指出了一个属性从接口继承, 此时属性被转换成接口对象.
//通过接口动态绑定属性, 并动态的设定属性值.
type
　IMyInterface = 
interface
　　
procedure
P1;
　　
procedure
P2;
　
end
;
　TMyImplclass = 
class
　　
procedure
P1;
　　
procedure
P2;
　
end
;
　TMyclass = 
class
(TInterfacedObject, IMyInterface)
　　FMyImplClass: TMyImplClass;
　　
property
MyImplClass: TMyImplclass read FMyImplclass implements IMyInterface;
　　
procedure
IMyInterface
.
P1 = MyP1;
　　
procedure
MyP1;
　
end
;
//通过implements声明后, 可以在类声明时指出接口中方法的实体, 如上例中的:
procedure
IMyInterface
.
P1 = MyP1;
         
       

in：

                            
//In用于判断一个集合中是否包含某个元素.被判断的内容必须是单个集合元素和一个集合的实例.
type
　TCol = (cA,cB,cC);
　TCols = 
set
of
TCol;
var
　Cols: TCols;
begin
　Cols := [cA,cB];
　
if
cA 
in
Cols 
then
　　ShowMessage(
'cA in Cols'
)
　
else
　　ShowMessage(
'cA not in Cols'
);
end
;
//In也用于工程文件中, 用于标识某个文件是否被工程所引用.
Uses
　Unit1 
in
'Unit1.pas'
;
//In可以被用在For语句中, 用于循环取出一个集合中的元素.
var
　s: 
string
;
　sl: TStringList;
begin
　...
　
for
s 
In
sl 
do
　
begin
　　ShowMessage(s);
　
end
;
end
;
         
       

index：

                            
//Index用于在属性中标识序号, 以便用相同的属性方法(Get,Set)对不同的属性进行操作.
type
　TForm1 = 
class
(TForm)
　
private
　　
function
GetInfo(
const
Index: 
Integer
): 
Longint
;
　　
procedure
SetInfo(
const
Index: 
Integer
; 
const
Value: 
Longint
);
　
public
　　
property
iLeft:
Longint
index 
0
read GetInfo 
write
SetInfo;
　　
property
iTop:
Longint
index 
1
read GetInfo 
write
SetInfo;
　　
property
iWidth:
Longint
index 
2
read GetInfo 
write
SetInfo;
　　
property
iHeight:
Longint
index 
3
read GetInfo 
write
SetInfo;
　
end
;
function
TForm1
.
GetInfo(
const
Index: 
Integer
): 
Longint
;
begin
　
case
Index 
of
　　
0
: result := self
.
Left;
　　
1
: Result := self
.
Top;
　　
2
: result := self
.
Width;
　　
3
: result := self
.
Height;
　
end
;
end
;
//Index关键字也用于在属性中指出多个元素, 例如:
property
Selected[Index: 
Integer
]: 
Boolean
read GetSelected 
write
SetSelected;
         
       

inherited：

                            
//Inherited用于调用父类的方法.
type
　TDemo = 
class
(TComponent)
　
public
　　
constructor
Create(AOwner: TComponent); override;
　
end
;
constructor
TDemo
.
Create(AOwner: TComponent);
begin
　
inherited
Create(AOwner);
end
;
//如果调用的是与自身同名的方法, 则也可以省去方法名和参数.如上例中的
inherited
Create(AOwner);
//可以改成:
Inherited
;
         
       

initialization：

                            
//initialization关键字标识了单元被载入时所要调用的方法, 
//通常是初始化一些不能自动初始化的对象, 也可以不用.
//initialization最常用的情况是对OLE对象做初始化.
initialization
 
ActiveX
.
OleInitialize(
nil
);
finalization
 
ActiveX
.
OleUninitialize;
         
       

inline：

                            
//InLine关键字用于Asm或assembler结构中, 
//用于指出该汇编语句是向下兼容的.它对于程序的编译没有任何影响.
function
IntToStr(Value: 
Integer
): 
string
;
asm
　InLine;
 
PUSH ESI
 
MOV  ESI, ESP
 
SUB  ESP, 
16
 
xor
ECX, ECX
 
PUSH EDX
 
xor
EDX, EDX
 
CALL CvtInt
 
MOV  EDX, ESI
 
POP  EAX
 
CALL System.@LStrFromPCharLen
 
ADD  ESP, 
16
 
POP  ESI
end
;
         
       

interface：

                            
//Interface标识了单元中的接口部分, 单元的基本结构为:
//Unit...Interface...implementation...end.
//函数, 过程等的声明必须写在Interface关键字后.
//如果在Interface后引用对象, 则对象是没有实例的, 使用时必须被实例化.
Interface
　
uses
frmAbout;
var
　FAbout: TFormAbout;
begin
　FAbout :＝ TFormAbout
.
Create(Self);
　FAbout
.
Show;
end
;
//一个完整的单元必须拥有Interface部分.
//Interface也可以用作接口的声明.
type
　IMalloc = 
interface
(IInterface)
　[
'{00000002-0000-0000-C000-000000000046}'
]
　　
function
Alloc(Size: 
Integer
): 
Pointer
; stdcall;
　　
function
Realloc(P: 
Pointer
; Size: 
Integer
): 
Pointer
; stdcall;
　　
procedure
Free(P: 
Pointer
); stdcall;
　　
function
GetSize(P: 
Pointer
): 
Integer
; stdcall;
　　
function
DidAlloc(P: 
Pointer
): 
Integer
; stdcall;
　　
procedure
HeapMinimize; stdcall;
　
end
;
         
       

is：

                            
//Is关键字用于对象的判断, 有某些情况下, 也可以作"As"使用.
var
　
Comp
: TComponent;
begin
 
...
　
if
Comp
Is
TEdit 
then
　　(
Comp
as
TEdit).Text := 
'Edit'
;
end
;
         
       

label：

                            
//label关键字用于声明行号标签, 以便用Goto进行转向, 不推荐使用.
var
　a,b: 
Integer
;
label
　X,Y;
begin
　
if
a > b 
then
　　
goto
X
　
else
　　
goto
Y;
X:
　
WriteLn
(
'a>b'
);
Y:
　
WriteLn
(
'b>a'
);
end
;
         
       

library：

                            
//Library关键字用于指出一个工程为类库.类库编译后生成DLL文件, 可被其他程序调用.
library
Editors;
uses
EdInit, EdInOut, EdFormat, EdPrint;
exports
 
InitEditors,
 
doneEditors name done,
 
InsertText name Insert,
 
DeleteSelection name Delete,
 
FormatSelection,
 
PrintSelection name Print,
 
SetErrorHandler;
begin
 
InitLibrary;
end
.
         
       

message：

                            
//Message关键字用于声明消息方法, 
//带有Message的方法必须指出接收的消息类型, 并通过引用将消息传入方法中, 以便进行处理.
procedure
Refresh(
var
Msg: TMessageRecordtype); messageID_REFRESH;
procedure
Refresh(
var
Msg: TMessageRecordtype);
begin
if
Chr(Msg
.
Code) = #
13
then
...
else
inherited
;
end
;
//用户可以自定义消息, 自定义消息也能够被Message接收, 并引发事件.
         
       

mod：

                            
//Mod用于求两数之整数模, 即余数.用于Mod运算的两个数值必须均为整型, 其运算结果也为整型.
var
　a,b,c: 
Integer
;
begin
　a := 
20
; b := 
3
;
　c := a 
mod
b; 
{2}
end
;
         
       

name：

                            
//Name关键字用于指出方法的别名, 
//对于一个要被外部引用的方法, 建议用Name申请方法别名, 以避免外部程序改动方法的实体内容.
//从外部引用一个方法时, 如果该方法有别名, 则必须用Name进行标识.
function
MessageBox(HWnd: 
Integer
; Text, Caption: 
PChar
; Flags: 
Integer
): 
Integer
; 
 
stdcall; external 
'user32.dll'
name 
'MessageBoxA'
;
         
       

near：

                            
//Near标明了函数调用协定, 指出函数可以被本地调用.
//其他程序可以用dll的形式调用程序内的函数.它是向下兼容的.
function
Add(a,b: 
Integer
): 
Integer
; near;
//如果这个程序被编译为Demo.exe, 并且另一个处于本地的程序需要调用这个函数, 可以使用以下语句:
function
Add(a,b: 
Integer
): 
Integer
; stdcall; external 
'Demo.exe'
;
         
       

nil：

                            
//Nil用于表示一个空指针, 或是没有实例的对象.
while
Node <> 
nil
do
begin
　ListBox1
.
Items
.
Add(Node
.
Text);
　Node := Node
.
GetNext;
end
;
         
       

nodefault：

                            
//NoDefault关键字指出了一个属性不允许有默认值, 这通常用在继承中.
type
　TClassA = 
class
　
private
　　fValue: 
Integer
;
　
published
　　
property
Value: 
Integer
read fValue 
write
fValue default 
0
;
　
end
;
　TClassB = 
class
(TClassA)
　
published
　　
property
Value:
Integer
read fValue 
write
fValue nodefault;
　
end
;
//由上例可知, TClassA中的Value有默认值0, 
//TClassB继承了TClassA, 所以也继承了其默认值, 在此用NoDefault去掉默认值
         
       

not：

                            
//Not用于取反, 它否定了原先的结果.例如:
if
a > b 
then
//可以写成:
if
not
(a < b) 
then
//Not关键字通常用于切换Boolean型的属性
procedure
Button1Click(Sender: TObject);
begin
　StatusBar1
.
Visible := 
not
StatusBar1
.
Visible;
end
;
         
       

object：

                            
//Object用于声明一个对象, 这个对象可以是任意的, 并且向下兼容.Object只能被Object所继承.
//声明对象的方法与声明类的方法是相同的.
type
　ODemoA = 
object
　
end
;
　ODemoB = 
object
(ODemoA)
　
end
;
//Object关键字还用于声明动态函数或过程, 例如:
type
　TMyFun = 
function
(i: 
Integer
): 
Integer
of
Object
;
　TMyProc = 
procedure
(s: 
string
) 
of
object
;
//经过object声明的函数或过程可以被动态的绑定到指定的函数体, 或是绑定到控件是事件中.
         
       

of：

                            
//Of关键用于和其他关键字构成指定的结构.Of可以与Case, Class, Array, File, Set, Object连用.
//Case语句:
case
Tag 
Of
　
0
: Result := 
'a'
;
　
1
: Result := 
'b'
;
end
;
//Class语句:
type
　TDemo = 
class
of
TComponent;
//Array结构:
var
　MyInt: 
array
of
Integer
;
//File结构:
var
　MyFile: 
file
of
Byte
;
//Set语句:
type
　TCol = (cA,cB,cC);
　TCols = 
set
of
TCol;
//Object结构:
type
　MyFun = 
function
(I: 
Integer
): 
Integer
of
Object
;
         
       

on：

                            
//On关键字用于异常处理, 指出发生的异常, 并获取异常信息.
try
　i := StrToInt(s);
except
　
on
E: exception 
do
　　ShowMessage(E
.
Message);
end
;
         
       

or：

                            
//一、表示逻辑或
if
(a>
0
) 
or
(b>
0
) 
then
//二、表示位运算
var
a,b,c: 
Integer
;
begin
c := (a 
or
b);
end
;
//使用Or表示逻辑时, Or左右的表达式必须用小括号括起, 以避免以生条件的冲突
//如果在条件语句中使用 Or, 则编辑器不知道用户使用Or做什么
例如:
if
a>
0
or
b>
0
then
//编译器可能会理解为:
if
a>(
0
or
b)>
0
then
//或者
if
(a>
0
) 
or
(b>
0
) 
then
//但是实际编译时, 编译器会产生一个冲突, 报告错误
//并且第一种可能包含了a>b>c的形式, 这在Delphi中不被支持
//所以使用Or运算符时必须使用括号, 以区分左右的条件.
//表示位运算时也必须加上括号, 将Or以及左右参数括起.
         
       

out：

                            
//Out关键字说明了方法参数的输出方式, 一般的函数只能有一个返回值, 
//使用Out可以在一个函数中返回多个结果.
//Out和var不同, Out是以返回值的形式进行参数返回, 而var是直接输入一个参数的地址.
procedure
X(out i: 
Integer
; out s: 
string
);
begin
　i := i * 
2
;
　s := s + 
'abc'
;
end
;
procedure
TForm1
.
Button1Click(Sender: TObject);
var
　i: 
Integer
;
　s: 
string
;
begin
　i := 
20
;
　s := 
'xxx'
;
　X(i,s);
end
;
         
       

overload：

                            
//Overload关键字指出了用于重载的方法, 重载即方法名相同, 
//但是参数数量, 类型或顺序不同, 满足此条件的构成重载.
function
X(i: 
Integer
): 
string
; overload;
function
X(s: 
string
): 
string
; overload;
//从父类继承时, 如果子类拥有和父类相同的方法, 则也必须用overload构成重载, 
//但是此类重载也必须满足重载的要求.
type
　TDemo = 
class
(TComponent)
　
public
　　
procedure
CreateWnd(AOwner: TWinControl); overload;
　
end
;
//如上例, 子类拥有的方法为:
procedure
CreateWnd; 
{继承自父类}
procedure
CreateWnd(AOwner: TWinControl); 
{子类声明}
//共两个CreateWnd方法.
//如果不使用重载, 则在子类中可以覆盖父类的方法.
         
       

override：

                            
//Override用于覆盖一个Virtual或是Dynamic形式的方法.
//覆盖时必须沿用被覆盖方法的声明, 并且不允许修改原方法的参数和返回类型.
procedure
Create(AOwner: TComponent); override;
//Override多用于继承, 用子类覆盖掉父类的方法.
type
　TClassA = 
class
　　
procedure
X; virtual;
　
end
;
　TClassB = 
class
(TClassA)
　　
procedure
X; override;
　
end
;
//如上例, 子类拥有的方法为:
procedure
X; 
{从父类覆盖}
//父类拥有的方法为:
procedure
X; 
{父类自身方法, 未被覆盖}
//如果父类的方法未用Virtual或Dynamic声明, 
//或是有修改参数的需要, 则必须用Reintroduce关键字进行覆盖.
         
       

package：

                            
//Package关键字用于指出一个工程为控件库.
//控件库编译后生成BPL文件, 可被安装到Delphi的控件库中, 从而在以后的开发中使用控件.
package DATAX;
 
requires
  
rtl,
  
clx;
 
contains
  
MyUnit 
in
'C:\MyProject\MyUnit.pas'
;
end
.
         
       

packed：

                            
//Packed关键字用于对结构体记录或数组进行打包, 打包后被打包对象的体积能显著减小.
type
　TPerson = 
packed
Record
　　PName: 
string
[
32
];
　　PAge: 
Integer
;
　
end
;
　MyArray: 
packed
array
of
PChar
;
         
       

pascal：

                            
//Pascal标明了函数调用协定, 
//指出函数在调用时遵循Pascal原因, 即先对所有的变量进行初始化, 
//避免因异步线程调用而产生的错误.它是向下兼容的.
function
X(i: 
Integer
): 
Integer
; Pascal;
begin
　Result := i * 
2
;
end
;
         
       

private：

                            
//Private标明了类内元素的访问区分权限, 被Private区分的元素只能被本类内部访问.

procedure：

                            
//Procedure用于声明过程
procedureX(i: 
Integer
);
//它也可以用于动态函数的声明
type
　TProc = 
procedure
(i: 
Integer
) 
of
object
;
//动态声明时, 不需要指出过程名, 只需要指出参数就可以, 具体的过程名可以在后期绑定.
         
       

program：

                            
//Program关键字用于指出一个工程为应用程序.控件库编译后生成exe文件, 可以直接执行
program
Project1;
uses
 
Forms,
 
Unit1 
in
'Unit1.pas'
;
{$R *.res}
begin
 
Application
.
Initialize;
 
Application
.
CreateForm(TForm1, Form1);
 
Application
.
Run;
end
.
         
       

property：

                            
//Property关键字用于声明属性, 属性分为显式属性和隐式属性两种, 
//只有声明在published访问区分符下的属性才是显式属性, 可以直接在对象查看器中查看.
type
　TDemo = 
class
　
Private
　　fValue: Integr;
　
Published
　　
property
Value: 
Integer
read fValue 
write
fValue;
　
end
;
//事件也是属性的一种, 可以在published区分符下用Property进行声明
type
　TOnTextChange=
procedure
(Sender: TObject) 
of
object
;
　TDemo = 
class
　
private
　　fEvent: TOnTexChange;
　
published
　　
property
OntextChange: TOnTextChange read fEvent 
write
fEvent;
　
end
;
         
       

protected：

                            
//Protected标明了类内元素的访问区分权限, 被Protected区分的元素只能被本类内部和其子类访问.

public：

                            
//Public标明了类内元素的访问区分权限, 被Public区分的元素能够被类内和类外任何对象访问.

published：

                            
//Published标明了类内元素的访问区分权限.
//被Published区分的元素能够被类内和类外任何RTTI对象访问
//只在声明在Published区分符下的属性才能够成为显式属性并在对象查看器中显示.

raise：

                            
//Raise语句用于抛出异常, 
//如果希望通过外部程序处理异常, 或是在异常发生时重新将异常抛出, 可以使用Raise语句.
function
GetString(i: 
Integer
): 
string
;
begin
　
if
i < 
0
then
　　
raise
exception
.
Create(
'Integer Cannot smaller than 0'
);
　Result := IntToStr(i);
end
;
//在异常处理中, 可以重新抛出异常
try
　i := StrToInt(s);
except
　
on
E: exception 
do
　　
raise
exception
.
Create(E
.
Message);
end
;
         
       

read：

                            
//Read用于标识属性中读取所使用的成员或方法.
private
　fValue: 
Integer
;
published
　
property
Value: 
Integer
readfValue;
//上例中即表明Value属性的值从fValue成员上读取.
         
       

readonly：

                            
//ReadOnly关键字用于标识一个对象是否只读.
propertyReadOnly;
//当ReadOnly设为True时, 不允许用户手动修改属性, 只能通过其他对象来操作.

record：

                            
//Record关键字用于声明一个结构体记录, 
//一个结构体可以视为一个不需要实例化的对象, 拥有自己的成员.
type
　TPerson = 
record
　　PName: 
string
[
32
];
　　PAge: 
Integer
;
　
end
;
         
       

register：

                            
//Register标明了函数调用协定, 指出函数在被调用时可以在注册表内留下记录.它是向下兼容的.
functionAdd(a,b: 
Integer
): 
Integer
; Register; Register
//关键字还用于向控件库或是IDE注册控件或是专家工具.
procedure
Register;
begin
　RegisterComponents(
'Sample'
, [TDemo]);
end
;
         
       

reintroduce：

                            
//Reintroduce用于重新发布方法, 通常用于继承时, 
//如果要覆盖的方法是静态方法, 或是需要修改方法的参数等, 必须用Reintroduce进行重发布.
//对于Virtual或Dynamic方法, 可以直接用Override进行覆盖.
type
　TClassA = 
class
　　
procedure
X;
　
end
;
　TClassB = 
class
(TClassA)
　　
procedure
X; reintroduce;
　
end
;
　TClassC = 
class
(TClassB)
　　
procedure
X(i: 
Integer
); reintroduce;
　
end
;
         
       

repeat：

                            
//repeat关键字用于引出repeat循环结构, 
//该循环必须先执行一次循环体, 然后再对循环条件进行判断.repeat必须与Until关键字联合使用.
i := 
0
;
repeat
　sum := sum + i;
　Inc(i);
until
(i >= 
100
);
         
       

requires：

                            
//Requires关键字指出了编译Package时的必备条件.若Requires的条件未满足, 则不允许编译包.
package DATAX;
 
requires
  
rtl,
  
clx;
end
.

resourcestring：

                            
//ResourceString用于声明资源字符串, 资源字符串可以在被声明的结构内使用.
ResourceString
　CreateError = 
'Cannot create file %s'
;
　OpenError = 
'Cannot open file %s'
;
　LineTooLong = 
'Line too long'
;
　ProductName = 
'Borland Rocks'
;
　SomeResourceString = SomeTrueConstant;
         
       

safecall：

                            
//Safecall是函数调用协定的一种, 它规定了被COM调用的函数所必须遵守和规则.
//在编译时, Safecall声明的函数被编译成COM接口兼容的.
procedure
X(s: 
WideString
); safecall;
//在编译后成为:
procedure
X(s: 
PAnsiString
);
         
       

set：

                            
//Set关键字用于声明集合类, 集合类允许用集合运算符, 如in等进行操作.
type
　TCol = (cA,cB,cC);
　TCols = 
set
ofTCol;
//操作时允许使用加减符号来添加或删除某个集合元素
var
　Cols: Tcols;
begin
　Cols := Cols + [cA,cB];
end
;
         
       

shl：

                            
//SHL表示向左移位, 左移的位数即乘以2的幂数
var
　x: 
Integer
;
begin
　X := 
2
shl
3
; 
{16}
end
;
         
       

shr：

                            
//SHR表示向右移位, 右移的位数即除以2的幂数
var
　x: 
Integer
;
begin
　X := 
16
shr
2
; 
{4}
end
;
         
       

stdcall：

                            
//Stdcall是函数调用协定的一种, 它规定了能让程序调用的函数所应遵守的规则.
//Stdcall关键字必须在主调方和被调方之间形成配对.
//例如, 被调方函数:
Library
Demo;
function
X(i: 
Integer
): 
Integer
; stdcall;
begin
　Result := i * 
2
;
end
;
exports
　X;
begin
end
.
//主调方函数:
function
X(i: 
Integer
): 
Integer
; stdcall; external 
'Demo.dll'
;
//同时需要注意, 使用Stdcall关键字时, 被调函数是大小写敏感的, 此处极容易出错.
         
       

stored：

                            
//Stored用于指出一个属性的值是否能被保留, 若指定了True, 则允许对属性值进行赋值撤销的操作.
property
Value: 
string
read fValue 
write
fValue stored 
True
;
         
       

string：

                            
//String是一个数据类型, 它代表了字符串.
var
　Str: 
string
;
         
       

then：

                            
//Then关键字用于If语句中, 当If条件成立时, 执行Then后的语句.
var
　a,b: 
Integer
;
begin
　
if
a > b 
then
　　
WriteLn
(
'a'
)
　
else
　　
WriteLn
(
'b'
);
end
;
         
       

threadvar：

                            
//Threadvar标识了一个随线程启动而创建的变量, 
//如果用Threadvar声明变量, 则在程序结束前必须手动释放其占用的空间.
threadvar
S: 
AnsiString
;
S := 
'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
;
S := 
''
;
//S := ''; 即释放变量S所占用的内存.
         
       

to：

                            
//To关键字用于For语句, 指明循环变量是递增的.
for
i := 
10
to
100
do
　ListBox1
.
Items
.
Add(IntToStr(i));
//在For语句中, 循环变量递增用To关键字, 递减用DownTo关键字.
         
       

try：

                            
//try语句用于异常处理, 对于有可能发生异常的语句, 可以放在try结构下, 以便对其进行异常保护.
try
　i := StrToInt(s);
except
　ShowMessage(
'Error'
);
end
;
         
       

type：

                            
//Type关键字用于声明各种对象, 用Type关键字声明的对象, 在传递时按引用传递.
type
　TDemo = 
class
　
end
;
//type也用来声明枚举类型或是按引用传递的变量.
type
　TCol = (cA,cB,cC);
　TInt = 
Integer
;
         
       

unit：

                            
//Unit标识了单元的开头, 单元的基本结构为 Unit...Interface...implementation...end.
Unit
Unit1;
Interface
　
uses
Classes;
implementation
end
.
//一个完整的单元必须拥有Unit作为开头.
         
       

until：

                            
//Until关键字用于判断repeat循环结构的循环条件, 
//如果循环条件为真, 则退出循环.Until必须与repeat关键字联合使用.
i := 
0
;
repeat
　sum := sum + i;
　Inc(i);
until
(i >= 
100
);
         
       

uses：

                            
//Uses用于引用一个外部的单元, 并且能够使用该单元中的公共部分.
//Uses语句通常放在一个单元的接口或是实现部分.
Interface
　
uses
Classes;
Implemention
　
uses
frmAbout;
         
       

var：

                            
//var关键字用于声明一个变量或是对象, 用var声明的变量接值传递.
var
　i: 
Integer
;
　s: 
string
;
//var也可以用于标识按引用传递的方法参数
function
X(
var
i: 
Integer
): 
Integer
;
//上述函数中的参数i即按引用传递, 它的值可以在函数执行时被改变, 并返回主调函数.
         
       

varargs：

                            
//varArgs标识了引用参数, 它必须和Cdecl关键字联用, 表明允许调用的函数使用引用传递.
function
printf(Format: 
PChar
): 
Integer
; cdecl; varargs;
//上述代码从C++的类库中引用了Printf函数, 并允许按引用的方式传入参数.
         
       

virtual：

                            
//Virtual用于声明一个虚方法, 
//虚方法可以被覆盖, 并且可以使程序运行速度尽可能的快(区别于Dynamic).
procedure
X(i: 
Integer
); virtual;
         
       

while：

                            
//While关键字用于引出While循环语句, 循环前先进行循环条件的判断, 如果条件为真则执行循环.
i := 
0
;
while
i < 
100
do
begin
　sum := sum + i;
　Inc(i);
end
;
         
       

with：

                            
//With关键字用于将相同的对象集合起来处理, 它可以省去输入大量重复的代码, 使代码看上去比较精简.
with
Form1
.
Memo1
.
Lines 
do
begin
　Clear;
　Append(
'abc'
);
　Append(
'def'
);
　SaveToFile(
'C:\demo.txt'
);
end
;
//上面这段代码如果不使用With语句, 则显得非常冗余复制内容到剪贴板代码:
Form1
.
Memo1
.
Lines
.
Clear;
Form1
.
Memo1
.
Lines
.
Append(
'abc'
);
Form1
.
Memo1
.
Lines
.
Append(
'def'
);
Form1
.
Memo1
.
Lines
.
SaveToFile(
'C:\demo.txt'
);
         
       

write：

                            
//Write用于标识属性中写入所使用的成员或方法.
private
　fValue: 
Integer
;
published
　
property
Value: 
Integer
writefValue;
//上例中即表明Value属性的值写入到fValue成员上.
         
       

writeonly：

                            
//writeonly关键字用于标识一个对象是否只写.
property
writeonly;
//当writeonly设为True时, 不允许用户读取属性, 只能通过其他对象来操作.

xor：

                            
//Xor用于取异或, 当两个操作数相等时, 返回False, 不等时返回True.
var
　a,b: 
Integer
;
begin
　a := 
2
; b := 
3
;
　
if
a 
xor
b 
then
　　
WriteLn
(
'a xor b'
)
　
else
　　
WriteLn
(
'a not xor b'
);
end
;
//Xor也用于计算异或值
WriteLn
(IntToStr(
3
xor
5
)); 
{6}
         
       