Delphi經常使用關鍵字用法詳解

時間  2019-11-07
標籤 delphi 經常 使用 關鍵字 用法 詳解 欄目 Delphi 简体版
原文   原文鏈接

absolute：
node

?
1
2
3
4
5
6
7
8
9
10
//它使得你可以建立一個新變量, 而且該變量的起始地址與另外一個變量相同.
var
Str: string [ 32 ];
StrLen: Byte absoluteStr;
//這個聲明指定了變量StrLen起始地址與Str相同.
//因爲字符串的第0個位置保存了字符串的長度, 因此StrLen的值即字符串長度.
begin
Str := 'abc' ;
Edit1 . Text := IntToStr(StrLen);
end ;

abstract：
git

?
1
2
3
4
5
6
7
8
9
10
11
12
13
//它容許你建立抽象的方法, 包括有抽象方法的類稱爲抽象類.
//Abstract關鍵字必須與Virtual或Dynamic關鍵字同時使用, 由於抽象方法必須被覆蓋式實現.
//抽象類不能實例化, 抽象方法不能包含方法體.
type
TDemo = class
private
protected
procedure X; virtual; abstract;
public
constructor Create;
destructor Destroy; override;
published
end ;

and：數組

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
//1、表示邏輯與
if (a> 0 ) and (b> 0 ) then
//2、表示位運算
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：
異步

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
//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：
編輯器

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
//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：
ide

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
//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：
函數

?
1
2
3
//Assembler關鍵字用於支持早期的彙編, 如80386等.
//它和Asm的區別:Asm容許使用Win32彙編, 而Assembler只容許80x86彙編, 它不容許Invoke語句的出現.
function IntToHex(AValue: Int64 ): string ; assembler;

automated：
工具

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
//Automated訪問區分符用於描述一個自動類型的成員, 它可以使程序的版本向下兼容.
//ComObj單元內的成員及其實例不能使用Automated訪問區分符.
type
TDemo = class
automated
Str: WideString ;
end ;
//在程序的下一個版本中, 將Str作了修改, 變成
type
TDemo = class
automated
Str: AnsiString ;
end
//則新版本的Str變量可以接受舊版本的WideString型數據, 並自動轉換成AnsiString.
//在實際開發中, 若是沒有特殊的須要, 通常不用automated訪問區分符.

begin：
ui

?
1
2
3
4
5
6
7
8
9
10
11
//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：
spa

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
//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：

?
1
2
3
4
5
6
7
8
9
//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：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
//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：

?
1
2
3
4
5
6
7
8
//Const關鍵字用於聲明常量, 使用const聲明的數據將不能在程序中被改變.
//也能夠用來聲明函數參數, 用const指定的參數不容許在函數中改變.
const MyFileName = 'Delphi' ;
const MyInteger = 100 ;
//用Const聲明常量不須要指出其數據類型, 系統會自動判斷類型, 並做自動調整.
//函數中能夠用const聲明不可更改的參數
function X( const i: Integer ): string ;
//此時在函數操做過程當中, i的值不可改變.

constructor：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
//constructor關鍵字用來聲明一個類的構造函數, 當類被實例化時, 首先調用此函數
//構造函數通常用Create表示, Create方法可以連帶類中存在的CreateWnd方法.
type
ClassDemo = class (TObject)
private
fValue: Integer ;
public
constructor Create;
end ;
constructor ClassDemo . Create;
begin
fValue := 0 ;
end ;

contains：

?
1
2
3
4
5
6
7
8
//Contains關鍵字指出了某個包(Package)是否包含某個文件.
//用Contains引入的文件必須被添加到包文件中, 它能夠避免關鍵文件的引用丟失.
package DATAX;
requires
rtl, clx;
contains
Db, DBLocal, DBXpress;
end .

default：

?
1
2
3
4
5
6
7
8
9
10
11
//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：

?
1
2
3
4
5
6
7
8
9
10
//Destructor用於標識析構函數, 析構函數在類被釋放時自動調用.
//析構函數只容許覆蓋, 再不容許重載.析構函數一般用Destroy做爲函數名.
type
ClassDemo = class (TComponent)
public
destructor Destroy;override;
end ;
//因爲TComponent類中也有Destroy方法, 因此要將其重寫
//可是若要重載析構函數, 則不容許, 下面代碼是錯誤的:
destructor Destroy; overload;

dispid：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
//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：

?
1
2
3
4
5
6
7
//DispInterface用於聲明一個特定的適配器接口, 這個適配器可以接受標準系統接口中傳入傳出的數據.
//用DispInterface聲明的接口不能被繼承, 只可以被引用.
//DispInterface中方法只能調用, 而且必須被動態綁定.
//能夠經過DispId爲接口內方漢分配適配序號.
//DispInterface僅能用於Windows平臺, 若是在Linux下進行開發, 則此關鍵字會自動被系統屏蔽.
//一般狀況下, 不使用DispInterface.
//實例請參見DispId

div：

?
1
2
3
4
5
6
7
//Div用於求兩數之整數商.用於Div運算的兩個數值必須均爲整型, 其運算結果也爲整型.
var
a,b,c: Integer ;
begin
a := 20 ; b := 3 ;
c := a div b; {6}
end ;

do：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
//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：

?
1
2
3
4
//DownTo關鍵字用於For語句, 指明循環變量是遞減的.
for i := 100 downto 1 do
ListBox1 . Items . Add(IntToStr(i));
//在For語句中, 循環變量遞增用To關鍵字, 遞減用DownTo關鍵字.

dynamic：

?
1
2
3
//Dynamic用於聲明一個動態的方法,
//動態方法能夠被覆蓋, 而且可使代碼大小盡量的減小(區別於Virtual).
procedure X(i: Integer ); dynamic;

else：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
//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：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
//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：

?
1
2
3
4
5
6
//except關鍵字用於異常處理, 必須用在try語句內, 若是發生異常, 則執行except後的語句
try
i := StrToInt(s);
except
ShowMessage( 'Error!' );
end ;

export：

?
1
2
3
4
5
//Export標明瞭函數調用協定, 指出函數能夠被輸出, 輸出的函數能被本地或遠程調用.
//其餘程序能夠用dll的形式調用程序內的函數.它是向下兼容的.
function Add(a,b: Integer ): Integer ; export;
//若是這個程序被編譯爲Demo.exe, 而且另外一個程序須要調用這個函數, 可使用如下語句
function Add(a,b: Integer ): Integer ; stdcall; external 'Demo.exe' ;

exports：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
//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：

?
1
2
3
4
5
6
7
8
9
10
11
//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：

?
1
2
3
4
5
//Far標明瞭函數調用協定, 指出函數能夠被遠程調用.
//其餘程序能夠用dll的形式調用程序內的函數.它是向下兼容的.
functionAdd(a,b: Integer ): Integer ; Far;
//若是這個程序被編譯爲Demo.exe, 而且另外一個處於其餘計算機的程序須要調用這個函數, 可使用如下語句:
function Add(a,b: Integer ): Integer ; stdcall; external 'Demo.exe' ;

file：

?
1
2
3
4
5
6
7
8
9
//File關鍵字指出了文件操做類型, 文件必須被聲明爲File,
//若是在File後追加Of和文件類型, 則文件能夠被定義爲讀寫指定類型數據.
type
TPerson = record
PName: string [ 32 ];
PAge: Integer ;
end ;
var
PFile: file of TPerson;

finalization：

?
1
2
3
4
5
6
7
//finalization關鍵字標識了單元被釋放時所要調用的方法,
//一般是釋放掉單元中不能自動釋放的對象, 也能夠不用.
//finalization最經常使用的狀況是對OLE對象作反初始化.
initialization
ActiveX . OleInitialize( nil );
finalization
ActiveX . OleUninitialize;

finally：

?
1
2
3
4
5
6
7
8
//finally關鍵字指出了異常處理中最後必需要調用的方法,
//不管是否發生異常, finally後的語句老是在try語句結束時執行.
try
Node := Node . GetNext;
Edit1 . Text := Node . Text;
finally
　Node := nil ;
end ;

for：

?
1
2
3
4
//For關鍵字引出For循環結構, 用於作指定次數的循環.
for i := 1 to 100 dosum := sum + i;
//若是循環變量是遞減的, 則能夠用DownTo關鍵字
for i := 100 downto 1 do Inc(sum);

forward：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
//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：

?
1
2
3
4
5
6
7
//Function用於聲明函數
functionX(i: Integer ): Integer ;
//它也能夠用於動態函數的聲明
type
　TFun = function (i: Integer ): Integer of object ;
 
//動態聲明時, 不須要指出函數名, 只須要指出參數和返回類型就能夠, 具體的函數名能夠在後期綁定.

goto：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
//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：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
//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：

?
1
2
3
4
5
6
7
8
9
10
//Implementation標識了單元中的實現部分, 單元的基本結構爲:
//Unit...Interface...implementation...end.
//函數體, 過程體等必須寫在implementation關鍵字後.
//若是在implementation後引用對象, 則對象是非公開的, 僅能供單元自身使用.
implementation
uses frmAbout;
begin
FormAbout . Show;
end ;
//一個完整的單元必須擁有implementation部分.

implements：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
//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：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
//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：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
//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：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
//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：

?
1
2
3
4
5
6
7
//initialization關鍵字標識了單元被載入時所要調用的方法,
//一般是初始化一些不能自動初始化的對象, 也能夠不用.
//initialization最經常使用的狀況是對OLE對象作初始化.
initialization
ActiveX . OleInitialize( nil );
finalization
ActiveX . OleUninitialize;

inline：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
//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：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
//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：

?
1
2
3
4
5
6
7
8
//Is關鍵字用於對象的判斷, 有某些狀況下, 也能夠做"As"使用.
var
　 Comp : TComponent;
begin
...
　 if Comp Is TEdit then
　　( Comp as TEdit).Text := 'Edit' ;
end ;

label：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
//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：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
//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：

?
1
2
3
4
5
6
7
8
9
10
11
12
//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：

?
1
2
3
4
5
6
7
//Mod用於求兩數之整數模, 即餘數.用於Mod運算的兩個數值必須均爲整型, 其運算結果也爲整型.
var
　a,b,c: Integer ;
begin
　a := 20 ; b := 3 ;
　c := a mod b; {2}
end ;

name：

?
1
2
3
4
5
//Name關鍵字用於指出方法的別名,
//對於一個要被外部引用的方法, 建議用Name申請方法別名, 以免外部程序改動方法的實體內容.
//從外部引用一個方法時, 若是該方法有別名, 則必須用Name進行標識.
function MessageBox(HWnd: Integer ; Text, Caption: PChar ; Flags: Integer ): Integer ;
stdcall; external 'user32.dll' name 'MessageBoxA' ;

near：

?
1
2
3
4
5
//Near標明瞭函數調用協定, 指出函數能夠被本地調用.
//其餘程序能夠用dll的形式調用程序內的函數.它是向下兼容的.
function Add(a,b: Integer ): Integer ; near;
//若是這個程序被編譯爲Demo.exe, 而且另外一個處於本地的程序須要調用這個函數, 可使用如下語句:
function Add(a,b: Integer ): Integer ; stdcall; external 'Demo.exe' ;

nil：

?
1
2
3
4
5
6
//Nil用於表示一個空指針, 或是沒有實例的對象.
while Node <> nil do
begin
　ListBox1 . Items . Add(Node . Text);
　Node := Node . GetNext;
end ;

nodefault：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
//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：

?
1
2
3
4
5
6
7
8
9
//Not用於取反, 它否認了原先的結果.例如:
if a > b then
//能夠寫成:
if not (a < b) then
//Not關鍵字一般用於切換Boolean型的屬性
procedure Button1Click(Sender: TObject);
begin
　StatusBar1 . Visible := not StatusBar1 . Visible;
end ;

object：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
//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：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
//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：

?
1
2
3
4
5
6
7
//On關鍵字用於異常處理, 指出發生的異常, 並獲取異常信息.
try
　i := StrToInt(s);
except
　 on E: exception do
　　ShowMessage(E . Message);
end ;

or：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
//1、表示邏輯或
if (a> 0 ) or (b> 0 ) then
//2、表示位運算
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：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
//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：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
//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：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
//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：

?
1
2
3
4
5
6
7
8
9
//Package關鍵字用於指出一個工程爲控件庫.
//控件庫編譯後生成BPL文件, 可被安裝到Delphi的控件庫中, 從而在之後的開發中使用控件.
package DATAX;
requires
rtl,
clx;
contains
MyUnit in 'C:\MyProject\MyUnit.pas' ;
end .

packed：

?
1
2
3
4
5
6
7
//Packed關鍵字用於對結構體記錄或數組進行打包, 打包後被打包對象的體積能顯著減少.
type
　TPerson = packed Record
　　PName: string [ 32 ];
　　PAge: Integer ;
　 end ;
　MyArray: packed array of PChar ;

pascal：

?
1
2
3
4
5
6
7
//Pascal標明瞭函數調用協定,
//指出函數在調用時遵循Pascal緣由, 即先對全部的變量進行初始化,
//避免因異步線程調用而產生的錯誤.它是向下兼容的.
function X(i: Integer ): Integer ; Pascal;
begin
　Result := i * 2 ;
end ;

private：

?
1
//Private標明瞭類內元素的訪問區分權限, 被Private區分的元素只能被本類內部訪問.

procedure：

?
1
2
3
4
5
6
7
//Procedure用於聲明過程
procedureX(i: Integer );
//它也能夠用於動態函數的聲明
type
　TProc = procedure (i: Integer ) of object ;
 
//動態聲明時, 不須要指出過程名, 只須要指出參數就能夠, 具體的過程名能夠在後期綁定.

program：

?
1
2
3
4
5
6
7
8
9
10
11
//Program關鍵字用於指出一個工程爲應用程序.控件庫編譯後生成exe文件, 能夠直接執行
program Project1;
uses
Forms,
Unit1 in 'Unit1.pas' ;
{$R *.res}
begin
Application . Initialize;
Application . CreateForm(TForm1, Form1);
Application . Run;
end .

property：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
//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：

?
1
//Protected標明瞭類內元素的訪問區分權限, 被Protected區分的元素只能被本類內部和其子類訪問.

public：

?
1
//Public標明瞭類內元素的訪問區分權限, 被Public區分的元素可以被類內和類外任何對象訪問.

published：

?
1
2
3
//Published標明瞭類內元素的訪問區分權限.
//被Published區分的元素可以被類內和類外任何RTTI對象訪問
//只在聲明在Published區分符下的屬性纔可以成爲顯式屬性並在對象查看器中顯示.

raise：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
//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：

?
1
2
3
4
5
6
//Read用於標識屬性中讀取所使用的成員或方法.
private
　fValue: Integer ;
published
　 property Value: Integer readfValue;
//上例中即代表Value屬性的值從fValue成員上讀取.

readonly：

?
1
2
3
//ReadOnly關鍵字用於標識一個對象是否只讀.
propertyReadOnly;
//當ReadOnly設爲True時, 不容許用戶手動修改屬性, 只能經過其餘對象來操做.

record：

?
1
2
3
4
5
6
7
//Record關鍵字用於聲明一個結構體記錄,
//一個結構體能夠視爲一個不須要實例化的對象, 擁有本身的成員.
type
　TPerson = record
　　PName: string [ 32 ];
　　PAge: Integer ;
　 end ;

register：

?
1
2
3
4
5
6
7
//Register標明瞭函數調用協定, 指出函數在被調用時能夠在註冊表內留下記錄.它是向下兼容的.
functionAdd(a,b: Integer ): Integer ; Register; Register
//關鍵字還用於向控件庫或是IDE註冊控件或是專家工具.
procedure Register;
begin
　RegisterComponents( 'Sample' , [TDemo]);
end ;

reintroduce：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
//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：

?
1
2
3
4
5
6
7
//repeat關鍵字用於引出repeat循環結構,
//該循環必須先執行一次循環體, 而後再對循環條件進行判斷.repeat必須與Until關鍵字聯合使用.
i := 0 ;
repeat
　sum := sum + i;
　Inc(i);
until (i >= 100 );

requires：

?
1
2
3
4
5
6
//Requires關鍵字指出了編譯Package時的必備條件.若Requires的條件未知足, 則不容許編譯包.
package DATAX;
requires
rtl,
clx;
end .

resourcestring：

?
1
2
3
4
5
6
7
//ResourceString用於聲明資源字符串, 資源字符串能夠在被聲明的結構內使用.
ResourceString
　CreateError = 'Cannot create file %s' ;
　OpenError = 'Cannot open file %s' ;
　LineTooLong = 'Line too long' ;
　ProductName = 'Borland Rocks' ;
　SomeResourceString = SomeTrueConstant;

safecall：

?
1
2
3
4
5
//Safecall是函數調用協定的一種, 它規定了被COM調用的函數所必須遵照和規則.
//在編譯時, Safecall聲明的函數被編譯成COM接口兼容的.
procedure X(s: WideString ); safecall;
//在編譯後成爲:
procedure X(s: PAnsiString );

set：

?
1
2
3
4
5
6
7
8
9
10
//Set關鍵字用於聲明集合類, 集合類容許用集合運算符, 如in等進行操做.
type
　TCol = (cA,cB,cC);
　TCols = set ofTCol;
//操做時容許使用加減符號來添加或刪除某個集合元素
var
　Cols: Tcols;
begin
　Cols := Cols + [cA,cB];
end ;

shl：

?
1
2
3
4
5
6
//SHL表示向左移位, 左移的位數即乘以2的冪數
var
　x: Integer ;
begin
　X := 2 shl 3 ; {16}
end ;

shr：

?
1
2
3
4
5
6
//SHR表示向右移位, 右移的位數即除以2的冪數
var
　x: Integer ;
begin
　X := 16 shr 2 ; {4}
end ;

stdcall：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
//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：

?
1
2
//Stored用於指出一個屬性的值是否能被保留, 若指定了True, 則容許對屬性值進行賦值撤銷的操做.
property Value: string read fValue write fValue stored True ;

string：

?
1
2
3
//String是一個數據類型, 它表明了字符串.
var
　Str: string ;

then：

?
1
2
3
4
5
6
7
8
9
//Then關鍵字用於If語句中, 當If條件成立時, 執行Then後的語句.
var
　a,b: Integer ;
begin
　 if a > b then
　　 WriteLn ( 'a' )
　 else
　　 WriteLn ( 'b' );
end ;

threadvar：

?
1
2
3
4
5
6
//Threadvar標識了一個隨線程啓動而建立的變量,
//若是用Threadvar聲明變量, 則在程序結束前必須手動釋放其佔用的空間.
threadvar S: AnsiString ;
S := 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' ;
S := '' ;
//S := ''; 即釋放變量S所佔用的內存.

to：

?
1
2
3
4
//To關鍵字用於For語句, 指明循環變量是遞增的.
for i := 10 to 100 do
　ListBox1 . Items . Add(IntToStr(i));
//在For語句中, 循環變量遞增用To關鍵字, 遞減用DownTo關鍵字.

try：

?
1
2
3
4
5
6
//try語句用於異常處理, 對於有可能發生異常的語句, 能夠放在try結構下, 以便對其進行異常保護.
try
　i := StrToInt(s);
except
　ShowMessage( 'Error' );
end ;

type：

?
1
2
3
4
5
6
7
8
//Type關鍵字用於聲明各類對象, 用Type關鍵字聲明的對象, 在傳遞時按引用傳遞.
type
　TDemo = class
　 end ;
//type也用來聲明枚舉類型或是按引用傳遞的變量.
type
　TCol = (cA,cB,cC);
　TInt = Integer ;

unit：

?
1
2
3
4
5
6
7
//Unit標識了單元的開頭, 單元的基本結構爲 Unit...Interface...implementation...end.
Unit Unit1;
Interface
　 uses Classes;
implementation
end .
//一個完整的單元必須擁有Unit做爲開頭.

until：

?
1
2
3
4
5
6
7
//Until關鍵字用於判斷repeat循環結構的循環條件,
//若是循環條件爲真, 則退出循環.Until必須與repeat關鍵字聯合使用.
i := 0 ;
repeat
　sum := sum + i;
　Inc(i);
until (i >= 100 );

uses：

?
1
2
3
4
5
6
//Uses用於引用一個外部的單元, 而且可以使用該單元中的公共部分.
//Uses語句一般放在一個單元的接口或是實現部分.
Interface
　 uses Classes;
Implemention
　 uses frmAbout;

var：

?
1
2
3
4
5
6
7
8
//var關鍵字用於聲明一個變量或是對象, 用var聲明的變量接值傳遞.
var
　i: Integer ;
　s: string ;
//var也能夠用於標識按引用傳遞的方法參數
function X( var i: Integer ): Integer ;
 
//上述函數中的參數i即按引用傳遞, 它的值能夠在函數執行時被改變, 並返回主調函數.

varargs：

?
1
2
3
//varArgs標識了引用參數, 它必須和Cdecl關鍵字聯用, 代表容許調用的函數使用引用傳遞.
function printf(Format: PChar ): Integer ; cdecl; varargs;
//上述代碼從C++的類庫中引用了Printf函數, 並容許按引用的方式傳入參數.

virtual：

?
1
2
3
//Virtual用於聲明一個虛方法,
//虛方法能夠被覆蓋, 而且可使程序運行速度儘量的快(區別於Dynamic).
procedure X(i: Integer ); virtual;

while：

?
1
2
3
4
5
6
7
//While關鍵字用於引出While循環語句, 循環前先進行循環條件的判斷, 若是條件爲真則執行循環.
i := 0 ;
while i < 100 do
begin
　sum := sum + i;
　Inc(i);
end ;

with：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
//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：

?
1
2
3
4
5
6
//Write用於標識屬性中寫入所使用的成員或方法.
private
　fValue: Integer ;
published
　 property Value: Integer writefValue;
//上例中即代表Value屬性的值寫入到fValue成員上.

writeonly：

?
1
2
3
//writeonly關鍵字用於標識一個對象是否只寫.
property writeonly;
//當writeonly設爲True時, 不容許用戶讀取屬性, 只能經過其餘對象來操做.

xor：

?
1
2
3
4
5
6
7
8
9
10
11
12
//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}
相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程