Delphi常用关键字用法详解

2024-04-10 06:50:04 18

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

absolute：

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

abstract：

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

and：

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

array：

//Array用于表示数组,任何的对象都能被声明成数组.数组分为静态和动态的２种.
//静态数组
var
Arr1:array[1..10]ofInteger;

//动态数组,由于声明时不知其元素个数,所以必须在后期用SetLength方法设置数组的大小
var
Arr2:arrayofInteger;

//数组作为参数时,不能传入数组的大小,只能传入数组名,然后用Length方法获取数组的元素个数
functionX(A:arrayofInteger):Integer;
var
i:Integer;
begin
Result:=0;
fori:=0toLength(A)-1do
Result:=Result+A[i];
end;

as：

//As用于将一个对象转换为另一个对象
procedureBtnClick(Sender:TObject);
begin
(SenderasTButton).Caption:='Clicked';
end;
//对于对象填充接口的转换,必须用As进行
(HTTPRIOasIExp).GetConnection;

//As不能用于数据类型的转换,下面的代码是错误的:
var
i:Integer;
s:string;
begin
s:=(iasstring);
end;
//正确写法是:
s:=string(i);

asm：

//Asm关键字用于插入汇编代码,使用汇编代码时,必须使用asm...end;的结构,而非begin...end;
functionIntToHex(Value:Integer;Digits:Integer):string;
asm
CMPEDX,32
JBE@A1
xorEDX,EDX
@A1:PUSHESI
MOVESI,ESP
SUBESP,32
PUSHECX
MOVECX,16
CALLCvtInt
MOVEDX,ESI
POPEAX
CALLSystem.@LStrFromPCharLen
ADDESP,32
POPESI
end;

assembler：

//Assembler关键字用于支持早期的汇编,如80386等.
//它和Asm的区别:Asm允许使用Win32汇编,而Assembler只允许80x86汇编,它不允许Invoke语句的出现.
functionIntToHex(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关键字来结束.
procedureX;
begin
ShowMessage('ADemo');
end;
//一般的结构,如If,For,While等也需要用begin关键字来标出结构起始点
fori:=1to100do
begin
sum:=sum+i;
ifsum>1000thenBreak;
end;

case：

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

cdecl：

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

class：

//Class关键字用于声明或继承一个类,也可以使类和接口同时继承.
//另外,Class关键字也能用于声明类通用方法,使得父类可以从类内访问子类的方法.
type
ClassDemo=class(TObject)
private
public
constructorCreate;
end;
//如果用class声明方法,则该方法在类与相关类中都可以使用,譬如:
type
ClassA=class
private
public
procedureY;
end;

type
ClassB=class(ClassA)
private
public
classprocedureX;
end;
//则在使用时ClassA能够直接访问ClassB的X方法
procedureClassA.Y;
begin
Self.X;
end;
//此时父类将子类的class方法作为自身的方法进行调用.

const：

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

constructor：

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

contains：

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

default：

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

destructor：

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

dispid：

//DispId关键字被用在DispInterface接口中,用于指定特定的适配序号.
//在DispInterface接口中,适配序号必须是唯一的,
//如果不指定DispId,则系统会自动分配适配序号给接口内每一个方法.
//可以通过适配序号访问DispInterface接口中的方法.
type
IStringsDisp=dispinterface
['{EE05DFE2-5549-11D0-9EA9-0020AF3D82DA}']
propertyControlDefault[Index:Integer]:Olevariantdispid0;default;
functionCount:Integer;dispid1;
propertyItem[Index:Integer]:Olevariantdispid2;
procedureRemove(Index:Integer);dispid3;
procedureClear;dispid4;
functionAdd(Item:Olevariant):Integer;dispid5;
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:=adivb;{6}
end;

do：

//Do关键字用于For,While,On,With语句,构成特定的结构
//For语句:
fori:=1to100dosum:=sum+i;

//While语句:
whilei<100do
begin
sum:=sum+i;
Inc(i);
end;

//On语句(异常处理):
try
i:=StrToInt(s);
except
onexceptiondoShowMessage('Error!');
end;

//With语句:
withMemo1.Linesdo
begin
Clear;
Append('abc');
Append('123');
end;

downto：

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

dynamic：

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

else：

//else用于引导程序的运行方向,它可以与If,Case和On语句联用,当条件不满足时,转到else下运行
//If语句(在If语句中,else前不允许有分号):
ifa>bthen
c:=a
else
c:=b;

//Case语句:
caseTagOf
1:Result:=1;
2:Result:=2;
3:Result:=3;
else
Result:=0;
end;

//On语句(异常处理):
try
i:=StrToInt(s);
Excpet
onEZeroDividedoResult:=1;
onEOverflowdoResult:=2;
else
Result:=0;
end;

end：

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

except：

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

export：

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

exports：

//exports用于输出对象,它必须被用在接口和实现之间,可以同时输出多个项,项与项之间用逗号分开.
libraryDemo;
functionX(i:Integer):string;stdcall;
begin
Result:=IntToStr(i);
end;

exports
X;

begin
end.

//如果输出的对象被重载,则必须给对象起个别名,并注明参数.
libraryDemo;

functionX(i:Integer):string;overload;stdcall;
begin
Result:=IntToStr(i);
end;

functionX(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内的方法.
{$LDemo.OBJ}
procedureX(i:Integer);external;
//如果是从dll或外部程序中引用,则可以使用以下代码:
functionA(FileName:string):string;external'Demo.dll';

//如果被引用的函数被重载,则必须另外指出引用的名称.
functionA(Name:string):string;overload;stdcall;external'Demo.dll'name'A1';
functionA(Code:Integer):string;overload;stdcall;external'Demo.dll'name'A2';

//使用External关键字时,必须注意大小写,否则将出现错误.

far：

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

file：

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

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循环结构,用于做指定次数的循环.
fori:=1to100dosum:=sum+i;
//如果循环变量是递减的,则可以用DownTo关键字
fori:=100downto1doInc(sum);

forward：

//Forward关键字用于方法的前置定义.只定义方法声明,然后在程序的后面对方法进行实现.
//这么做有利于代码的可读性,可以将所有的声明放在一起,然后将所有的实现也放在一起.
functionX(i:Integer):Integer;forward;
procedureY(s:string);forward;
...
functionX;
begin
Result:=i*2;
end;
procedureY;
begin
WriteLn(s);
end;

//用Forward前置声明的方法在实现时不需要再输入方法的参数和返回值,直接使用方法名即可.

function：

//Function用于声明函数
functionX(i:Integer):Integer;
//它也可以用于动态函数的声明
type
TFun=function(i:Integer):Integerofobject;

//动态声明时,不需要指出函数名,只需要指出参数和返回类型就可以,具体的函数名可以在后期绑定.

goto：

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

if：

//If关键字引出If条件语句,用于对条件进行判断.
var
a,b:Integer;
begin
a:=2;b:=3;
ifa>bthen
WriteLn('a='+IntToStr(a))
else
WriteLn('b='+IntToStr(b));
end;
//If语句的通常结构是If...Then...else,else语句也可以不要.
//在If语句内如果有多个子语句,则必须用begin...End结构进行区分.
ifa>bthen
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
usesfrmAbout;
begin
FormAbout.Show;
end;
//一个完整的单元必须拥有implementation部分.

implements：

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

in：

//In用于判断一个集合中是否包含某个元素.被判断的内容必须是单个集合元素和一个集合的实例.
type
TCol=(cA,cB,cC);
TCols=setofTCol;
var
Cols:TCols;
begin
Cols:=[cA,cB];
ifcAinColsthen
ShowMessage('cAinCols')
else
ShowMessage('cAnotinCols');
end;
//In也用于工程文件中,用于标识某个文件是否被工程所引用.
Uses
Unit1in'Unit1.pas';

//In可以被用在For语句中,用于循环取出一个集合中的元素.
var
s:string;
sl:TStringList;
begin
...
forsInsldo
begin
ShowMessage(s);
end;
end;

index：

//Index用于在属性中标识序号,以便用相同的属性方法(Get,Set)对不同的属性进行操作.
type
TForm1=class(TForm)
private
functionGetInfo(constIndex:Integer):Longint;
procedureSetInfo(constIndex:Integer;constValue:Longint);
public
propertyiLeft:Longintindex0readGetInfowriteSetInfo;
propertyiTop:Longintindex1readGetInfowriteSetInfo;
propertyiWidth:Longintindex2readGetInfowriteSetInfo;
propertyiHeight:Longintindex3readGetInfowriteSetInfo;
end;
functionTForm1.GetInfo(constIndex:Integer):Longint;
begin
caseIndexof
0:result:=self.Left;
1:Result:=self.Top;
2:result:=self.Width;
3:result:=self.Height;
end;
end;

//Index关键字也用于在属性中指出多个元素,例如:
propertySelected[Index:Integer]:BooleanreadGetSelectedwriteSetSelected;

inherited：

//Inherited用于调用父类的方法.
type
TDemo=class(TComponent)
public
constructorCreate(AOwner:TComponent);override;
end;
constructorTDemo.Create(AOwner:TComponent);
begin
inheritedCreate(AOwner);
end;

//如果调用的是与自身同名的方法,则也可以省去方法名和参数.如上例中的
inheritedCreate(AOwner);
//可以改成:
Inherited;

initialization：

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

inline：

//InLine关键字用于Asm或assembler结构中,
//用于指出该汇编语句是向下兼容的.它对于程序的编译没有任何影响.
functionIntToStr(Value:Integer):string;
asm
InLine;
PUSHESI
MOVESI,ESP
SUBESP,16
xorECX,ECX
PUSHEDX
xorEDX,EDX
CALLCvtInt
MOVEDX,ESI
POPEAX
CALLSystem.@LStrFromPCharLen
ADDESP,16
POPESI
end;

interface：

//Interface标识了单元中的接口部分,单元的基本结构为:
//Unit...Interface...implementation...end.
//函数,过程等的声明必须写在Interface关键字后.
//如果在Interface后引用对象,则对象是没有实例的,使用时必须被实例化.
Interface
usesfrmAbout;
var
FAbout:TFormAbout;
begin
FAbout:＝TFormAbout.Create(Self);
FAbout.Show;
end;
//一个完整的单元必须拥有Interface部分.

//Interface也可以用作接口的声明.
type
IMalloc=interface(IInterface)
['{00000002-0000-0000-C000-000000000046}']
functionAlloc(Size:Integer):Pointer;stdcall;
functionRealloc(P:Pointer;Size:Integer):Pointer;stdcall;
procedureFree(P:Pointer);stdcall;
functionGetSize(P:Pointer):Integer;stdcall;
functionDidAlloc(P:Pointer):Integer;stdcall;
procedureHeapMinimize;stdcall;
end;

is：

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

label：

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

library：

//Library关键字用于指出一个工程为类库.类库编译后生成DLL文件,可被其他程序调用.
libraryEditors;
usesEdInit,EdInOut,EdFormat,EdPrint;
exports
InitEditors,
doneEditorsnamedone,
InsertTextnameInsert,
DeleteSelectionnameDelete,
FormatSelection,
PrintSelectionnamePrint,
SetErrorHandler;
begin
InitLibrary;
end.

message：

//Message关键字用于声明消息方法,
//带有Message的方法必须指出接收的消息类型,并通过引用将消息传入方法中,以便进行处理.
procedureRefresh(varMsg:TMessageRecordtype);messageID_REFRESH;
procedureRefresh(varMsg:TMessageRecordtype);
begin
ifChr(Msg.Code)=#13then
...
else
inherited;
end;

//用户可以自定义消息,自定义消息也能够被Message接收,并引发事件.

mod：

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

name：

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

near：

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

nil：

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

nodefault：

//NoDefault关键字指出了一个属性不允许有默认值,这通常用在继承中.
type
TClassA=class
private
fValue:Integer;
published
propertyValue:IntegerreadfValuewritefValuedefault0;
end;
TClassB=class(TClassA)
published
propertyValue:IntegerreadfValuewritefValuenodefault;
end;

//由上例可知,TClassA中的Value有默认值0,
//TClassB继承了TClassA,所以也继承了其默认值,在此用NoDefault去掉默认值

not：

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

object：

//Object用于声明一个对象,这个对象可以是任意的,并且向下兼容.Object只能被Object所继承.
//声明对象的方法与声明类的方法是相同的.
type
ODemoA=object
end;
ODemoB=object(ODemoA)
end;

//Object关键字还用于声明动态函数或过程,例如:
type
TMyFun=function(i:Integer):IntegerofObject;
TMyProc=procedure(s:string)ofobject;

//经过object声明的函数或过程可以被动态的绑定到指定的函数体,或是绑定到控件是事件中.

of：

//Of关键用于和其他关键字构成指定的结构.Of可以与Case,Class,Array,File,Set,Object连用.
//Case语句:
caseTagOf
0:Result:='a';
1:Result:='b';
end;

//Class语句:
type
TDemo=classofTComponent;

//Array结构:
var
MyInt:arrayofInteger;

//File结构:
var
MyFile:fileofByte;

//Set语句:
type
TCol=(cA,cB,cC);
TCols=setofTCol;

//Object结构:
type
MyFun=function(I:Integer):IntegerofObject;

on：

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

or：

//一、表示逻辑或
if(a>0)or(b>0)then
//二、表示位运算
var
a,b,c:Integer;
begin
c:=(aorb);
end;

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

out：

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

overload：

//Overload关键字指出了用于重载的方法,重载即方法名相同,
//但是参数数量,类型或顺序不同,满足此条件的构成重载.
functionX(i:Integer):string;overload;
functionX(s:string):string;overload;
//从父类继承时,如果子类拥有和父类相同的方法,则也必须用overload构成重载,
//但是此类重载也必须满足重载的要求.
type
TDemo=class(TComponent)
public
procedureCreateWnd(AOwner:TWinControl);overload;
end;

//如上例,子类拥有的方法为:
procedureCreateWnd;{继承自父类}
procedureCreateWnd(AOwner:TWinControl);{子类声明}
//共两个CreateWnd方法.

//如果不使用重载,则在子类中可以覆盖父类的方法.

override：

//Override用于覆盖一个Virtual或是Dynamic形式的方法.
//覆盖时必须沿用被覆盖方法的声明,并且不允许修改原方法的参数和返回类型.
procedureCreate(AOwner:TComponent);override;
//Override多用于继承,用子类覆盖掉父类的方法.
type
TClassA=class
procedureX;virtual;
end;

TClassB=class(TClassA)
procedureX;override;
end;

//如上例,子类拥有的方法为:
procedureX;{从父类覆盖}
//父类拥有的方法为:
procedureX;{父类自身方法,未被覆盖}

//如果父类的方法未用Virtual或Dynamic声明,
//或是有修改参数的需要,则必须用Reintroduce关键字进行覆盖.

package：

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

packed：

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

pascal：

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

private：

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

procedure：

//Procedure用于声明过程
procedureX(i:Integer);
//它也可以用于动态函数的声明
type
TProc=procedure(i:Integer)ofobject;

//动态声明时,不需要指出过程名,只需要指出参数就可以,具体的过程名可以在后期绑定.

program：

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

property：

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

protected：

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

public：

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

published：

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

raise：

//Raise语句用于抛出异常,
//如果希望通过外部程序处理异常,或是在异常发生时重新将异常抛出,可以使用Raise语句.
functionGetString(i:Integer):string;
begin
ifi<0then
raiseexception.Create('IntegerCannotsmallerthan0');
Result:=IntToStr(i);
end;
//在异常处理中,可以重新抛出异常
try
i:=StrToInt(s);
except
onE:exceptiondo
raiseexception.Create(E.Message);
end;

read：

//Read用于标识属性中读取所使用的成员或方法.
private
fValue:Integer;
published
propertyValue:IntegerreadfValue;
//上例中即表明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注册控件或是专家工具.
procedureRegister;
begin
RegisterComponents('Sample',[TDemo]);
end;

reintroduce：

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

repeat：

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

requires：

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

resourcestring：

//ResourceString用于声明资源字符串,资源字符串可以在被声明的结构内使用.
ResourceString
CreateError='Cannotcreatefile%s';
OpenError='Cannotopenfile%s';
LineTooLong='Linetoolong';
ProductName='BorlandRocks';
SomeResourceString=SomeTrueConstant;

safecall：

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

set：

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

shl：

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

shr：

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

stdcall：

//Stdcall是函数调用协定的一种,它规定了能让程序调用的函数所应遵守的规则.
//Stdcall关键字必须在主调方和被调方之间形成配对.
//例如,被调方函数:
LibraryDemo;
functionX(i:Integer):Integer;stdcall;
begin
Result:=i*2;
end;
exports
X;
begin
end.

//主调方函数:
functionX(i:Integer):Integer;stdcall;external'Demo.dll';

//同时需要注意,使用Stdcall关键字时,被调函数是大小写敏感的,此处极容易出错.

stored：

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

string：

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

then：

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

threadvar：

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

to：

//To关键字用于For语句,指明循环变量是递增的.
fori:=10to100do
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.
UnitUnit1;
Interface
usesClasses;
implementation
end.
//一个完整的单元必须拥有Unit作为开头.

until：

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

uses：

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

var：

//var关键字用于声明一个变量或是对象,用var声明的变量接值传递.
var
i:Integer;
s:string;
//var也可以用于标识按引用传递的方法参数
functionX(vari:Integer):Integer;

//上述函数中的参数i即按引用传递,它的值可以在函数执行时被改变,并返回主调函数.

varargs：

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

virtual：

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

while：

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

with：

//With关键字用于将相同的对象集合起来处理,它可以省去输入大量重复的代码,使代码看上去比较精简.
withForm1.Memo1.Linesdo
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
propertyValue:IntegerwritefValue;
//上例中即表明Value属性的值写入到fValue成员上.

writeonly：

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

xor：

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

Delphi常用关键字用法详解

热门推荐

随机推荐