程序師世界是廣大編程愛好者互助、分享、學習的平台,程序師世界有你更精彩!
首頁
編程語言
C語言|JAVA編程
Python編程
網頁編程
ASP編程|PHP編程
JSP編程
數據庫知識
MYSQL數據庫|SqlServer數據庫
Oracle數據庫|DB2數據庫
 程式師世界 >> 編程語言 >> 更多編程語言 >> 更多關於編程 >> Delphi常用關鍵字用法詳解

Delphi常用關鍵字用法詳解

編輯:更多關於編程

Delphi常用關鍵字用法詳解。本站提示廣大學習愛好者:(Delphi常用關鍵字用法詳解)文章只能為提供參考,不一定能成為您想要的結果。以下是Delphi常用關鍵字用法詳解正文


本文詳細引見了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用於表示數組, 任何的對象都能被聲明成數組.數組分為靜態和靜態的2種.
//靜態數組
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}
  1. 上一頁:
  2. 下一頁:
Copyright © 程式師世界 All Rights Reserved