{它使得你能够创建一个新变量, 并且该变量的起始地址与另一个变量相同.}
var
  Str: string[32];
  StrLen: Byte absolute Str;

{这个声明指定了变量StrLen起始地址与Str相同.}
{由于字符串的第0个位置保存了字符串的长度, 所以StrLen的值即字符串长度.}
begin
  Str := 'abc';
  Edit1.Text := IntToStr(StrLen);
end;

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

{一、表示逻辑与}
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用于表示数组, 任何的对象都能被声明成数组.数组分为静态和动态的２种.}

{静态数组}
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用于将一个对象转换为另一个对象}
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...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关键字用于支持早期的汇编, 如80386等.}
{它和Asm的区别:Asm允许使用Win32汇编, 而Assembler只允许80x86汇编, 它不允许Invoke语句的出现.}
function IntToHex(AValue: Int64): string; assembler;

{Automated访问区分符用于描述一个自动类型的成员, 它能够使程序的版本向下兼容.}
{ComObj单元内的成员及其实例不能使用Automated访问区分符.}
type
  TDemo = class
    automated
      Str:WideString;
  end;

{在程序的下一个版本中, 将Str做了修改, 变成}
type
  TDemo = class
    automated
      Str: AnsiString;
  end
{则新版本的Str变量能够接受旧版本的WideString型数据, 并自动转换成AnsiString.}
{在实际开发中, 如果没有特殊的需要, 一般不用automated访问区分符.}

{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语句必须由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是函数调用协定的一种, 它规定了从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关键字也能用于声明类通用方法, 使得父类可以从类内访问子类的方法.}
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 MyFileName = 'Delphi';
const MyInteger = 100;

{用Const声明常量不需要指出其数据类型, 系统会自动判断类型, 并作自动调整.}
{函数中可以用const声明不可更改的参数}
function X(const i: Integer): string;
{此时在函数操作过程中, i的值不可改变.}

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

constructor ClassDemo.Create;
begin
  fValue := 0;
end;

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

{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用于标识析构函数, 析构函数在类被释放时自动调用.}
{析构函数只允许覆盖, 再不允许重载.析构函数通常用Destroy作为函数名.}
type
  ClassDemo = class(TComponent)
    public
      destructor Destroy;override;
  end;

{由于TComponent类中也有Destroy方法, 所以要将其重写}
{但是若要重载析构函数, 则不允许, 下面代码是错误的:}
destructor Destroy; overload;

{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中方法只能调用, 并且必须被动态绑定.}
{可以通过DispId为接口内方汉分配适配序号.}
{DispInterface仅能用于Windows平台, 如果在Linux下进行开发, 则此关键字会自动被系统屏蔽.}
{通常情况下, 不使用DispInterface.}

{实例请参见DispId}

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

{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关键字用于For语句, 指明循环变量是递减的.}
for i := 100 downto 1 do
  ListBox1.Items.Add(IntToStr(i));

{在For语句中, 循环变量递增用To关键字, 递减用DownTo关键字.}

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

{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用于结束一个语句块或是一个单元.}
{它可以与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关键字用于异常处理, 必须用在try语句内, 如果发生异常, 则执行except后的语句}
try
  i := StrToInt(s);
except
  ShowMessage('Error!');
end;

{Export标明了函数调用协定, 指出函数可以被输出, 输出的函数能被本地或远程调用.}
{其他程序可以用dll的形式调用程序内的函数.它是向下兼容的.}
function Add(a,b: Integer): Integer; export;

{如果这个程序被编译为Demo.exe, 并且另一个程序需要调用这个函数, 可以使用以下语句}
function Add(a,b: Integer): Integer; stdcall; external 'Demo.exe';

{exports用于输出对象, 它必须被用在接口和实现之间, 可以同时输出多个项, 项与项之间用逗号分开.}
library Demo;

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关键字用于引用一个外部的或是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标明了函数调用协定, 指出函数可以被远程调用.}
{其他程序可以用dll的形式调用程序内的函数.它是向下兼容的.}
function Add(a,b: Integer): Integer; Far;

{如果这个程序被编译为Demo.exe, 并且另一个处于其他计算机的程序需要调用这个函数, 可以使用以下语句:}
function Add(a,b: Integer): Integer; stdcall; external 'Demo.exe';

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

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

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

{For关键字引出For循环结构, 用于做指定次数的循环.}
for i := 1 to 100 do sum := sum + i;

{如果循环变量是递减的, 则可以用DownTo关键字}
for i := 100 downto 1 do Inc(sum);

{Forward关键字用于方法的前置定义.只定义方法声明, 然后在程序的后面对方法进行实现.}
{这么做有利于代码的可读性, 可以将所有的声明放在一起, 然后将所有的实现也放在一起.}
function X(i: Integer): Integer; forward;
procedure Y(s: string); forward;
...
function X;