Delphi面向对象的编程方法

Delphi的编程语言是以Pascal为基础的。Pascal语言具有可读性好、编写容易的特点，这使得它很适合作为基础的开发语言。同时，使用编译器创建的应用程序只生成单个可执行文件(.EXE)，正是这种结合，使得Pascal成为Delphi这种先进开发环境的编程语言。

　　本章中，我们将讨论Object Pascal的主要特点，并讲解如何在事件处理过程和其他应用程序中，使用它来编制程序代码。本章将讲解Delphi应用程序中最常用的Object Pascal语法，而不是Pascal语言的一切细节。如果您完全不熟悉Pascal编程，请参阅一些基础的Pascal教程。如果您具有编程经验，并能熟练地使用其他流行程序语言，您将在本章的Object Pascal中发现一些相同的概念。如果您已经熟悉了Borland Pascal，就可以快速浏览或跳过本章。　

　　2.1 编写Object Pascal程序代码　

　　在前边的章节中，我们通过例程，已经编写了几行简单的代码。在本章中，我们将从熟悉Pascal编程的角度，配合实例，讲解Object Pascal编程的基本方法。

　　在编写自己的Object Pascal程序时，要注意程序的可读性。Pascal语言是英式结构语言，在程序中选择合适的缩排、大小写风格，并在需要时将程序代码分行，会使得程序代码能够很容易地被自己和他人读懂。一般的程序员都有这样的体验：如果不给程序加上适当的注解，一段时间后，自己也难以理清程序的流程。给程序及时地加上注释是良好的编程习惯。Delphi的注释需要加注在{}之间，编辑器会把它们处理成为空白。Delphi保留了Borland Pascal编辑器的风格，关键字采用黑体字，被注释的部分会变暗，这使得编程风格良好，易读易写。　

　　2.1.1 编写赋值语句　

　　在事件处理过程中，最常用到的工作就是把一个新值赋给一个属性或变量。在设计用户界面时，可以使用Object Inspector(Object Inspector)来改变其属性；但有时需要在程序执行时改变属性的值，而且有些属性只能在执行时改变，这些属性在Delphi的在线帮助的“Proprety”主题中被标为执行期属性。进行这种改变，就必须使用赋值语句。

　　下文的赋值语句表征一个OnClick事件。当按钮按动后，将编辑框部件Edit1的Color属性置为clRed:

　　procedure TForm1.Button1Click(Sender: TObject);
begin
Edit1.Color := clRed;
end;　

　　当按动按钮后赋值语句被执行，编辑框变成红色。

　　在语句中，部件的名称在属性前，中间用“.”表示属性的所属关系。这样就准确地指定了要将clRed值赋给哪一部件的哪一属性。赋值号为“:=”，不论给属性还是给变量赋值，都是将右边的值赋给左边的属性或变量。

　　当将一个属性值、变量、常量或文本数据赋给属性或变量时，所赋值的类型和接受此值的属性或变量的类型应相同或兼容。一个属性或变量的类型定义了此属性或变量的可能值集合，也定义了程序代码可以执行的运算。在前边的例程中，编辑框部件的Color属性和clRed的类型都是TColor。可以在在线帮助中找到一个属性的类型；另外一种方法是在Object Inspector中选定该属性值段，并按下F1键，则类型将在属性说明的结尾处列出，例如Color属性列出下边的语句：　

　　Property Color : TColor;　

　　有些属性是只读(Read Only)的，它们只能被读取，不能被改变。请查阅在线帮助，在Delphi中这些只读属性都有注解。　

　　2.1.2 标识符的说明与使用　

　　标识符是Delphi应用程序中一些量的名称，这些量包括变量(var)、常量(const)、类型(type)、过程(procedure)、方法(Method)及其他，Object Pascal 在应用标识符时，必须首先说明它们。Object Pascal是强类型语言，它的编译器可以检查确保赋给变量或属性的值是正确的类型，以便于您改正错误。因为Object Pascal是编译语言，所以Delphi的执行速度要比使用解释语言快得多。在使用标识符前说明它们，可以减少程序错误并增加代码的效率。　

　　2.1.2.1 变量

　　变量是程序代码中代表一个内存地址的标识符，而此地址的内存内容在程序代码执行时可以被改变。在使用变量前必须对它进行说明，即对它进行命名，并说明它的类型。在所有变量说明以前加上保留字var。变量说明左边是变量的名称，右边则是该变量的类型，中间用(:)隔开。　

　　var
Value ,Sum : Integer;
Line : String;　

　　在窗体中加入一个名称为Edit1的编辑框，再加入一个名称(属性Name)为Add的按钮部件，并建立如下的事件处理过程：

　　procedure TForm1.addClick(Sender: TObject);
var
X , Y: Integer;
begin
X := 100;
Y := 20;
Edit1.Text := IntToStr(X + Y);
end;　

　　在本例中，当按动ADD按钮时，编辑框中显示值120。在Object Pascal中，必须确保变量或属性被赋予类型相同或兼容的值。您可以尝试将赋给X的值改为100.0，或去掉IntToStr函数，在编译时会出现类型不匹配的错误，这也说明了Object Pascal强类型语言的特点。　

　　2.1.2.2 预定义类型　

　　Object Pascal有多个预定义的数据类型，您可以说明任何这些类型的变量：

　　整形：Integer的范围是-32768到32767,占2字节的内存；Shortint从-128到127，占1字节内存；Longint从-2147443648到2147483647 占4字节内存；Byte从0到255，占1字节；Word从0到65535，占2字节内存。它们都是没有小数部分的数字。

　　实型：Single可以包含7到8位有效小数部分，占用4字节的内存；Double类可以包含15到16位有效小数部分，占用8字节的内存；Extended类型包含19到20位有效小数部分，占用10字节内存；Comp可以包含19到20位有效小数部分，占用8字节内存。以上实数类型只有在8087/80287选项[N+]打开才可以使用。Real可以包含11到12位有效小数部分，占用6字节内存。它只有在和以前Borland Pascal兼容的情况下才使用，否则应使用Double或Extended。

　　布尔型：Boolean，只包含true或False两个值，占用1字节内存。

　　字符型：Char，一个ASCII字符；字符串类型String一串最长可达255个ASCII字符。

　　指针型：Pointer，可以指向任何特定类型。

　　字符串型：PChar，是一个指向以零结尾的字符串的指针。

　　除了预定义类型外，Delphi还有自行定义的类型。上述例程的TColor就是这种类型。此外，用户还可以定义自己的数据类型，这部分内容将在下文中详细讲述。

　　整型类别和实型类别都各有五种类型，同一类别中，所有的类型与其他同类别的都相容，您可以将一种类型的值赋给相同类别中不同类型的变量或属性，而只需要这个值的范围在被赋值的变量或属性的可能值范围内。例如，对于一个Shortint型的变量，可以接受在-128到127范围内的任意整数，例如Shortint类型的7；您不能将300赋给它，因为300已经超出了Shortint的范围了。将范围检查功能打开(选用Options|Project，并在Compiler Options Page中选择Range Checking)，将会检查出一个范围错误；如果Range Checking没有被打开，那么程序代码将可以执行，但被赋值的值将不是您期望的值。

　　在一些情况下，您可以进行不同类型的变量或属性的赋值。一般来说，可以将一个较小范围的值赋给一个较大范围的值。例如，您可以将整型值10赋给一个接受实型值的Double属性而使得值成为10.0，但如果将一个Double类型的值赋给整形变量，则会出现类型错误。如果您不清楚类型的兼容性，可以参阅Delphi的在线帮助中“Type Compatibility and Assignment Compatibility”主题。　

　　2.1.2.3 常量　

　　常量在说明时就被赋予了一个值，在程序执行过程中是不可改变的。下面的例子说明了三个常量：　

　　const
Pi = 3.14159;
Answer = 342;
ProductName = "Delphi";　

　　象变量一样，常量也有类型。不同的是，常量假设其类型就是常量说明中其所代表的值的类型。上文的三个常量的类型分别是real型、整形、字符串型。常量用“= " 表示两边的值是相等的。　

　　2.1.3 过程与函数　

　　过程与函数是程序中执行特定工作的模块化部分。Delphi的运行库包含许多过程与函数以供您的应用程序调用。您不必了解过程与函数的逻辑，但要知道过程与函数的用途。在对象中说明的过程和函数称为方法(Method)。所有的事件处理过程都是过程，以保留字procedure开头。每一个事件处理过程只包含了当这一事件发生时需要执行的程序代码。在事件处理过程中使用Delphi已经存在的过程与函数，只需在程序代码中调用它们即可。

　　2.1.3.1 一个调用Delphi方法的简单例程　

　　下文将通过对一个Memo部件的文本进行剪切、拷贝、粘贴、清除等编辑的应用程序编制，介绍使用Delphi过程和函数的调用方法。

　　Memo(备注)部件有一个CutToClipboard方法，实现将用户在memo中选择的文本移到剪贴板上去。由于这个功能已经被建立在此方法中了，所以您只需知道这个方法做什么以及如何使用它即可。

　　下面的语句表明如何调用一个名为Memo1的memo部件的CutToClipboard方法：　

　　Memo1.CutToClipboard;　

　　通过指定Memo1的名称，说明调用哪一个部件的CutToClipboard方法。如果不指明对象名称，Delphi会显示Unknown identifier错误。当该事件处理过程被触发，程序会执行CutToclipboard中的语句，将Memo1中的文本剪贴到剪贴板上去。

　　下文的例程展示了如何调用Delphi的方法，实现将备注部件的文本信息剪切、拷贝到剪贴板上；将剪贴板上的标记文本粘贴到备注中，清除备注部件中的全部文本等四个功能。

　　打开一个新的空窗体，加入一个memo部件和四个按钮，并排列整齐。改变按钮部件的Name属性，分别命名为Cut,Copy,Paste,Clear。您会发现，当Name属性发生改变时，Caption属性将发生相应的变化。在Caption属性前加标“&”号设立加速键

　　将memo部件的ScrollBars属性设为ScVertical，以便加上滚行条。将WordWrap属性设置为True，这样当用户输入文本到达Memo部件的右边缘时会自动回行。将Line属性第一行的Memo1文本删除，使得memo部件在初始显示时为空的。

　　为每一个按钮建立如下的事件处理过程：　

　　procedure TForm1.CutClick(Sender: TObject)；
begin
Memo1.CutToClipboard;
end;　
procedure TForm1.CopyClick(Sender: TObject);
begin
Memo1.CopyToClipboard;
end;　
procedure TForm1.PasteClick(Sender: TObject);
begin
Memo1.PasteFromClipboard;
end;　
procedure TForm1.ClearClick(Sender: TObject);
begin
Memo1.clear;
end;　

　　执行此程序。您可以在备注部件中输入文本，在进行了文本的标记后，可以任意地进行剪切、拷贝、粘贴和清除。当按钮被按动时，就调用相应的过程进行处理。用户可以通过查阅在线帮助进行Memo部件的Topic Search，在Memo Component项中查阅Method，会得到以上过程的详细说明。　

　　2.1.3.2 调用Delphi的含参过程　

　　有些过程要求用户指明参数。被调用的过程会在执行时使用传入的参数值，这些值在过程中被认为是已经被说明的变量。例如，LoadFromFile方法在TString对象中被说明为：　

　　Procedure LoadFromFile(const FileName: String)；　

　　在调用这一过程时，应指明FileName参数是要装入的文件名称。下面的程序将先打开Open对话框，当您选择了一个文件后，Delphi将把该文件读入一个Memo部件：　

　　begin
OpenDialog.Execute;
Memo1.lines.LoadFromFile(OpenDialog.FileName);
end;　

　　2.1.3.3 使用Delphi函数　

　　与过程一样，函数的程序代码也执行特定的工作。它和过程的差别为：函数执行时会返回一个值，而过程则没有返回值。函数可以用来赋给一个属性或变量；也可以使用返回值来决定程序的流程。

　　前文中我们实际上已经接触过了函数。在讲述变量时，曾用到过下面的程序段： Edit1.Text := IntToStr(X + Y)；其中，IntToStr(Value)把一个LongInt类型的数值转化为字符串的值，Value是IntToStr唯一的参数，它可以是一个整形的值、变量、属性或产生整形值的表达式。调用函数，必须把返回值赋给和此返回值类型兼容的变量或属性。

　　有些函数返回一个True或False的布尔量，用户的程序可以根据返回值来决定跳转。下文的例程讲述了函数返回值为Boolean的判断用法：

　　在窗体中加入一个ColorDialog对象和一个Name属性为ChangeColor的按钮。为按钮的OnClick事件建立事件处理过程如下：　

　　procedure TForm1.ChangeColorClick(Sender: TObject);
begin
if ColorDialog1.Execute then
Form1.Color := ColorDialog1.Color
else
Form1.Color := clRed;
end;　

　　此事件处理过程使用一个返回Boolean值的Execute方法。按动按钮，并在颜色对话框中选择一个颜色。如果按动OK按钮，ColorDialog.Execute方法将返回True，则Form1.Color将被赋值为ColorDialog1.Color，窗体显现您选用的颜色；如果按动颜色对话框的Cancel按钮，方法将返回False值，窗体将变为红色。

　　2.1.4 跳转语句　

　　Object Pascal的跳转语句有if和case两个。　

　　2.1.4.1 if语句　

　　if语句会计算一个表达式，并根据计算结果决定程序流程。在上文的例程中，根据ColorDialog.Execute的返回值，决定窗体的背景颜色。if保留字后跟随一个生成Boolean值True或False的表达式。一般用“=”作为关系运算符，比较产生一个布尔型值。当表达式为True时，执行then后的语句。否则执行else后的代码，if语句也可以不含else部分，表达式为False时自动跳到下一行程序。

　　if语句可以嵌套，当使用复合语句表达时，复合语句前后需加上begin…end。else保留字前不能加“；”，而且，编译器会将else语句视为属于最靠近的if语句。必要时，须使用begin…end保留字来强迫else部分属于某一级的if语句。　

　　2.1.4.2 case语句　

　　case语句适用于被判断的变量或属性是整形、字符型、枚举型或子界型时(LongInt除外)。用case语句进行逻辑跳转比编写复杂的if语句容易阅读，而且程序代码整形较快。

　　下面的例程显示一个使用case语句的窗体：

　　建立如下的事件处理过程：　

　　procedure TForm1.Button1Click(Sender: TObject);
var
Number : Integer;
begin
Number := StrToInt(Edit1.Text);
case Number of
1,3,5,7,9: Label2.Caption := '奇数';
0,2,4,6,8: Label2.Caption := '偶数';
10..100:
begin
Label2.Caption := '在10到100之间';
Form1.Color := clBlue;
end;
else
Label2.Caption := '大于100或为负数';
end;
end;　

　　执行程序，当Edit1部件接受到一个值，并按动“OK”按钮触发程序后，Number便被赋值为用户输入的数值。case语句根据Number的值判断该执行哪一条语句。象if语句一样。case语句也有可选择的else部分。case语句以end结尾。　

　　2.1.5 循环语句　

　　Object Pascal的循环语句有三种：repeat、while和for语句。　

　　2.1.5.1 repeat语句　

　　repeat语句会重复执行一行或一段语句直到某一状态为真。语句以repeat开始，以until结束，其后跟随被判断的布尔表达式。参阅以下的例程：　

　　i := 0;
repeat
i := i+1;
Writen(i);
until i=10;　

　　当此语句被执行时，窗体的下方会出现1到10的数字。布尔表达式 i=10 (注意，与其他语言不同的是，“=”是关系运算符，而不能进行赋值操作)直到repeat..until程序段的结尾才会被计算，这意味着repeat语句至少会被执行一次。　

　　2.1.5.2 while语句　

　　while语句和repeat语句的不同之处是，它的布尔表达式在循环的开头进行判断。while保留字后面必须跟一个布尔表达式。如果该表达式的结果为真，循环被执行，否则会退出循环，执行while语句后面的程序。

　　下面的例程达到和上面的repeat例程达到同样的效果：　

　　i := 0;
while i<10 do
begin
i := i+1;
writeln(i);
end; 　

　　2.1.5.3 for语句　

　　for语句的程序代码会执行一定的次数。它需要一个循环变量来控制循环次数。您需要说明一个变量，它的类型可以是整形、布尔型、字符型、枚举型或子界型。

　　下面的程序段会显示1到5的数字，i为控制变量：　

　　var
i : integer;
for i := 1 to 5 do
writeln(i);　

　　以上介绍了三种循环语句。如果您知道循环要执行多少次的话，可以使用for语句。for循环执行速度快，效率比较高。如果您不知道循环要执行多少次，但至少会执行一次的话，选用repeat..until语句比较合适；当您认为程序可能一次都不执行的话，最好选用while..do语句。　

　　2.1.6 程序模块

　　程序模块在Object Pascal中是很重要的概念。它们提供了应用程序的结构，决定了变量、属性值的范围及程序执行的过程。它由两个部分组成：可选择的说明部分和语句部分。如果有说明部分，则必在语句部分之前。说明部分包括变量说明、常量说明、类型说明、标号说明、程序，函数，方法的说明等。语句部分叙述了可执行的逻辑行动。

　　在Delphi中，最常见的程序模块便是事件处理过程中的程序模块。下面的事件处理过程是含有变量说明部分的程序模块：　

　　procedure TForm.Button1Click(Sender Tobject);
var {程序模块的说明部分}
Name : string;
begin {程序模块的语句部分}
Name := Edit1.Text;
Edit2.Text := 'Welcome to Delphi'+Name;
end; {程序模块结束}　

　　库单元也是程序模块。库单元的interface部分含有库函数、类型、私有，公有域的说明，也可以含有常量、变量的说明。这一部分可以作为程序模块的说明部分。在库单元的implementation部分中通常含有各种事件处理过程，它们可以视为模块的语句部分，是事件处理模块。库单元模块结束于库单元结束的end.处。

　　程序模块中可以包含其他的程序模块。上文库单元模块中含有事件处理模块。而库单元模块实际是在工程程序模块中。

　　所有的Delphi应用程序都有相同的基本结构。当程序逐渐复杂时，在程序中加入模块即可。例如在库单元模块中加入事件处理模块，向工程中加入库单元模块等。模块化编程使得程序结构良好，并且对数据具有保护作用。　

　　2.1.7 关于作用范围　

　　2.1.7.1 标识符的作用范围　

　　一个变量、常量、方法、类型或其他标识符的范围定义了这个标识符的活动区域。对于说明这个标识符的最小程序模块而言，此标识符是局部的。当您的应用程序在说明一个标识符的程序模块外执行时，该标识符就不在此范围内。这意味着此时执行的程序无法访问这个标识符，只有当程序再度进入说明这个标识符的程序模块时，才可以访问它。

　　下面的示意图表示一个含有两个库单元的工程，每个库单元中又各有三个过程或事件处理过程。

　　2.1.7.2 访问其他程序模块中的说明　

　　您可以在当前的程序模块中访问其他程序模块中的说明。例如您在库单元中编写一个事件处理过程来计算利率，则其他的库单元可以访问这个事件处理过程。要访问不在当前库单元中的说明，应在这个说明之前加上其他应用程序的名称和一个点号(.)。例如，在库单元Unit1中有事件处理过程CalculateInterest过程，现在您想在库单元Unit2中调用这一过程，则可以在Unit2的uses子句中加入Unit1，并使用下面的说明：　

　　Unit1.CalculateInterest(PrincipalInterestRate : Double)；　

　　应用程序的代码不能在一个模块外访问它说明的变量。事实上，当程序执行跳出一个模块后，这些变量就不存在于内存中了。这一点对于任何标识符都是一样的，不管事件处理过程、过程、函数还是方法，都具有这一性质。这样的标识符称为局部变量。　

　　2.1.7.3 按照作用范围说明标识符

　　您可以在应用程序的不同地方说明一个标识符，而只需保证它们的有效范围不同即可。编译器会自动访问最靠近当前范围的标识符。

　　库单元的全局变量一般可以说明在保留字implementation后面。例如，下面的例程实现将两个编辑框中的整数相加，显示在第三个编辑框中。用到了一个整形的全局变量Count：　

　　…implememntation　
var
Count : Integer;　
procedure TForm1.AddClick(Sender:TObject);
var
FirstNumber,SecondNumber:Integer;
begin
Count := Count + 1;
Counter.Text := IntToStr(Count);
FirstNumber := StrToInt(Edit1.Text);
SecondNumber := StrToInt(Edit2.Text);
Edit3.Text := IntToStr(FirstNumber+SecondNumber);
end;
…　

　　为了实现每按动一次按钮Count增加一次，必须对全程变量Count进行初始化处理。在程序库单元的结尾处，最后一个end.保留字之前，加入保留字initialization和初始化Count的代码：　

　　…
initialization
Count := 0;　

　　这样当事件处理过程AddClick被触发时，Count就会被增加一次，以表征计算次数。如果用面向对象编程，则Count可以说明成窗体的一个域，这在下一节中将有讲述。　

　　2.1.8 编写一个过程或函数

　　在您开发Delphi应用程序时，所需的大部分代码都编写在事件处理过程中，但有时仍然需要编写不是事件处理过程的函数或过程。例如，您可以把在多个事件处理过程中用得到语句编写成过程，然后任何事件处理过程、过程、函数都可以象调用已经存在的过程或函数一样直接调用它。好处是您只需编写一次代码，而且程序代码会比较清楚。

　　2.1.8.1 一个自行编写的函数例程　

　　在上文两个数相加的程序中，如果编辑框中无值，则会使得程序出错中断。为避免这种情况，编写下面的函数，检查编辑框中是否有值，如无值，则提醒用户输入：　

　　function NoValue(AnEditBox:TEdit):Boolean;
begin
if AnEditBox.Text='' then
begin
AnEditBox.Color := clRed;
AnEditBox.Text := '请输入整数值';
Result := True;
end
else
begin
AnEditBox.Color := clWindow;
Result := False;
end;
end;　

　　NoValue函数会检查编辑框是否为空，如果是，编辑框颜色变红，并提醒用户输入一个整数，然后函数返回真值；Result保留字在Delphi中用来专指函数返回值。在上文的例程中加入NoValue函数：　

　　procedure TForm1.AddClick(Sender: TObject);
var
FirstNumber,SecondNumber : Integer;
begin
if NoValue(Edit1)or NoValue(Edit2) then
exit;
Count := Count + 1;
Counter.Text := IntToStr(Count);
FirstNumber := StrToInt(Edit1.Text);
SecondNumber := StrToInt(Edit2.Text);
Edit3.Text := IntToStr(FirstNumber+SecondNumber);
end;　

　　如果其中的任何一个返回真值，则表示有编辑框空，会执行exit过程，使得当前的程序模块停止执行，并使得编辑框出现输值提示。当新值被输入后，再执行程序时，红色提示被隐去，恢复正常的计算状态。　

　　2.1.8.2 过程和函数的标题　

　　每一个过程或函数都以标题开始，其中包括过程或函数的名称和它使用的参数。过程以保留字procedure开始，函数以保留字function开始。参数位于括号里面，每一个参数以分号分隔。例如：　

　　procedure validateDate(Day : Integer; month : Integer; Year : Integer);

　　您也可以将相同类型的参数组合在一起，则上述过程头写作：　

　　procedure ValidateDate(Day, Month, Year : Integer);　

　　函数在标题中还多了一项：返回值的类型。下面是一个返回值为Double型的函数标题：　

　　function CalculateInterest(principal,InterestRate:Double):Double;　

　　2.1.8.3 函数和过程中的类型说明　

　　一个过程或函数程序模块也含有说明部分和语句部分。说明部分可以包括类型说明、变量说明、常量说明等。除了Object Pascal语言中已经定义的类型之外，Delphi的应用程序还可以建立新的数据类型。类型说明部分有保留字type开始。下面是一些类型的说明：　

　　type
Tcount = Integer;
TPrimaryColor = (Red,Yellow,Blue);
TTestIndex = 1..100;
TTextValue = -99..99;
TTestList = array [TTestIndex] of TTestValue;
TCharVal = Ord('A')..Ord('Z') ;
Today = (Monday,Tuesday,Wednesday,Thursday,Friday,Saturday,
Sunday) ;　

　　在类型标识符后面，用“＝”号定义了新的类型。类型界定了变量的取值范围，例如，TCount类型的变量必须是整形值；一个TPrimaryColor类型的变量只能是red、yellow或blue等等。每一个类型的名称都是由字母T开始，这并非必须的，但它是Delphi的惯例，在区别类型名和标识符时非常有用。类型说明可以是局部的，也可以是全局的。如果您把它放在implementation后面，则表明对于库单元来讲，它是全局的，所有的事件处理过程和其他的过程、函数都可以调用它。如果类型是在过程中被说明的，则是局部的，离开这一过程，该类型将失效。

　　一般来讲，在过程和函数中，任何类型说明都在变量说明之前，而任何变量说明都在常量之前。但是，只要遵从说明必须在过程与函数的标题之后，而且在程序代码之前，即是有效的。

　　2.1.8.4 过程和函数的语句部分　

　　过程或函数的语句部分由begin开始，end结束。函数需要一个返回值。可以将返回值赋给函数名称，也可以将返回值赋给Result变量。下面的例程将返回值赋给函数名称：　

　　function CalculateInterest(Principal,InterestRate: Double):Double;
begin
CalculateInterest := Principal * InterestRate;
end;　

　　将返回值赋给Result变量也是可以的，则上面的程序改为：　

　　Result := Principal*InterestRate;

　　下面是这个函数的调用方法：

　　InterestEarned :=CalculateInterest(2000,0.012);

　　在Implementation后面的过程和函数，可以且只能被此库单元的事件处理过程使用。要让过程和函数可以被其他的程序库单元使用，则需要将过程或函数的标题部分放在库单元中的interface部分，而把含标题的整个过程或函数放在库单元的inplementation部分，并在要访问这个过程或函数的库单元的uses子句中加入说明这个过程或函数的库单元名称。　

　　2.1.8.5 函数的递归调用　

　　在Object Pascal中，过程或函数必须先说明再调用。上文的NoValue函数必须在使用它的事件处理过程之前说明和执行，否则程序会报告一个未知标识符的错误。

　　以上规则在递归调用时是例外情况。所谓递归调用，是指函数A调用函数B，而函数B又调用函数A的情况。在递归调用中，函数要进行前置，即在函数或过程的标题部分最后加上保留字forword。下文的例程是一个递归调用的典型例子：　

　　…
implementation
var
alpha:Integer;
procedure Test2(var A:Integer):forword;
{Test2被说明为前置过程}
procedure Test1(var A:Integer);
begin
A :=A-1;
if A>0 then
test2(A); {经前置说明，调用未执行的过程Test2}
writeln(A);
end;
procedure Test2(var A:Integer);{经前置说明的Test2的执行部分}
begin
A :=A div 2;
if A>0 rhen
test1(A); {在Test2中调用已执行的过程Test1}
end;　
procedure TForm1.Button1Click(Sender:TObject);
begin
Alpha := 15; {给Alpha赋初值}
Test1(Alpha); { 第一次调用Test1,递归开始}
end;　

　　按钮的OnClick事件处理过程给Alpha赋初值，并实现先减1再除2的循环递归调用，直到Alpha小于0为止。　

　　2.1.8.6 过程和函数的参数　

　　当您的程序代码在调用一个过程或函数时，通常用参数传递数据到被调用的过程或函数中。最常用的参数有数值参数、变量参数和常量参数三种。

　　由被调用过程或函数定义的参数为形参，而由调用过程或函数指明的参数叫实参。在NoValue函数中，说明函数体中的AnEditBox是形参，而调用时在if NoValue(Edit1)…中，Edit1是实参。

　　数值参数在运行过程中只改变其形参的值，不改变其实参的值，即参数的值不能传递到过程的外面。试看下面的例程：　

　　procedure Calculate(CalNo:Integer);
begin
CalNo := CalNo*10;
end;　

　　用以下例程调用Calculate函数：

　　…
Number := StrToInt(Edit1.Text);
Calculate(Number);
Edit2.Text := IntToStr(Number);
…　

　　Number接受由编辑框1输入的数值，经Calculate过程运算。它是一个数值型实参。在进入Calculate函数后，会把Number实参拷贝给形参CalNo，在过程中CalNo增大十倍，但并未传递出来，因此Number值并未改变，在编辑框2中显示仍然是编辑框1中的输入值。形参和实参占用不同的内存地址，在过程或函数被调用时，将实参的值复制到形参占用的内存中。因此出了过程或函数后，形参和实参的数值是不同的，但实参的值并不发生变化。

　　如果您想改变传入的参数值，就需要使用变量参数，即在被调用程序的参数表中的形参前加上保留字var。例如：　

　　procedure Calculate(var CalNo : Integer);　

　　则CalNo并不在内存中占据一个位置，而是指向实参Number。当一个变参被传递时，任何对形参所作的改变会反映到实参中。这是因为两个参数指向同一个地址。将上一个例程中过程头的形参CalNo前面加上var，再以同样的程序调用它，则在第二个编辑框中会显示计算的结果，把第一个编辑框中的数值放大十倍。这时形参CalNo和实参Number的值都是Nnmber初始值的10倍。

　　如果当过程或函数执行是要求不改变形参的值，最保险的办法是使用常量参数。在参数表的参数名称前加上保留字const可以使一个形参成为常量参数。使用常量参数代替数值参数可以保护您的参数，使您在不想改变参数值时不会意外地将新的值赋给这个参数。

　　2.1.9 定义新的数据类型　

　　Object Pascal有一些系统预定义的数据类型，在2.1.2中已经对它们作了介绍。您可以利用这些数据类型以建立新的数据类型来满足程序的特定需要。下面简单地叙述了您能建立的主要数据类型，如枚举型、子界型、数组型、集合型、记录型、对象型等。　

　　2.1.9.1 枚举类型　

　　一个枚举型的说明列出了所有这种类型可以包括的值：　

　　type
Tdays=( Sunday ,Monday,Tuesday,Wednesday,Thursday,Friday,Saturday); 　

　　可以定义上述枚举类型的变量：

　　var
DayOfWeek:TDays; 　

　　在枚举型中，括号中的每一个值都有一个由说明它的位置决定的整形值。例如Sunday有整形值0，Monday有整形值1等。您可以把DayOfWeek说明为一个整形变量，并将一星期的每一天赋一个整形值以达到相同的效果，但用枚举型会使得程序可读性好，编写容易。当您在枚举型中列出值时，您同时说明了这个值是一个标识符。例如您的程序中如果已经含有TDays类型且说明了DayOfWeeks变量，则程序中便不能使用Monday变量，因为它已经被说明为标识符了。 　

　　2.1.9.2 子界类型　

　　子界型是下列这些类型中某范围内的值：整形、布尔量、字符型或枚举型。在您想限制一个变量的取值范围时，子界型是非常有用的。　

　　type
Thours = 0..23;
TValidLetter = 'A' .. 'F';
TDays = ( Sunday ,Monday,Tuesday,Wednesday,Thursday,
Friday,Saturday); {枚举型}
TWorkDay = Monday..Friday; {一个TDays型的子界}　

　　子界型限定了变量的可能取值范围。当范围检查打开时，(在库单元的Implementation后面有{$R*.DFM}字样表示范围检查打开，否则您可以在Options|Project|Complier Options中选择Range Cheking来打开范围检查)，如果变量取到子界以外的值，会出现一个范围检查错误。　

　　2.1.9.3 数组类型　

　　数组是某种数据类型的有序组合，其中每一个元素的值由其相对位置来指定，您可以在数组的某个位置上放置数据，并在需要时使用这些数据。下面的类型说明了一个Double型的数组变量：

　　var
Check : array [1..10] of Double;　

　　它表示Check指向一个含有10个Double型元素的数据串列，代表每一个元素的是1到10之间的数字，称为索引。数组的每一项由数组名称加上[]中的索引来表示。Check包含10个变量，Check[1]表示第一个变量。您也可以把数组定义成类型：

　　type
TCheck = array[1..10] of Double;

　　则变量说明改为：

　　var
Check :TCheck;　

　　您可以通过给数组赋值等方法来使用数组。下面的语句将0.0赋给Check数组中的所有元素：　

　　for J := 1 to 10 do
Check[J] := 0.0;

　　数组也可以是多维的，下面的类型定义了一个20行、20列的数组。

　　type
Ttable = array[1..20,1..20] of Double;
var
table1:TTable;　

　　想将这一表格的所有数据初始化为0.0，您可以使用for循环：　

　　var
Col,Row:Integer;
…
for Col :=1 to 20 do
for Row := 1 to 20 do
Table1[Col,Row] := 0.0;

　　2.1.9.4 字符串类型　

　　字符串类型事实上是一个一维的字符数组。当您说明一个字符串型的变量时，您应当指明这个字符串的大小，下面是说明字符串类型的例子：

　　type
MyString: string[15];
var
MyName: MyString;　

　　则变量MyName被说明成为最多可以包含15个字符。如果您没有说明字符串的大小，Delphi会认为字符串包含最大值255个字符。给字符串赋值可以直接使用单引号括起的字串赋值：　

　　MyName := 'Frank.Smith';

　　或MyName := '张明'；　

　　因为MyName是一个可以包含15个字符的MyString型变量，上文的两个的变量都是有效的，一个汉字可以视作两个字符。当您给字符串型变量赋的值多于定义数值时，例如将MyName赋为‘FrankSmith.Franklin’，则Delphi只会接受前15个字符‘FrankSmith.Fran’。在内存中，字符串通常占用比所说明的大小多一个字节的空间，因为第一个位置是一个包含这个数组大小的字节。您可以使用索引值来访问字符串的字符，MyName[1]可以得到MyName的第一个字符'F'。

　　您可以使用Delphi丰富的运算符、过程和函数来处理字符串型的变量和属性。下面介绍几个常用的运算符和Delphi过程或函数：

　　Concat和(+)功能相同，都可以将多个字符串组合在一起，建立一个较大的字符串；Copy会返回一个字符串中的子字符串；Delete在一个字符串中从一个指定位置起删除一定数目的字符；Insert在一个字符串中插入一个字符串；Length返回字符串的长度；Pos返回一个子字符串在一个字符串中的位置，即索引值。　

　　2.1.9.5 集合类型　

　　集合类型是一群相同类型元素的组合，这些类型必须是有限类型如整形、布尔型、字符型、枚举型和子界型。在检查一个值是否属于一个特定集合时，集合类型非常有用。下面的例程可以说明集合类型的用法：

　　在窗体上加入一个编辑框和一个按钮，清除编辑框中的文字，在其上加上Caption为“输入元音”的标签Label，并在编辑框的下方加入一个空的标签，将按钮的Default属性改为True，建立按钮的事件处理过程如下：　

　　procedure TForm1.Button1Click(Sender:TObject);
type
Tvowels=set of Char;
var
Vowels:TVowels;
begin
Vowels := ['a','e','i','o','u'];
if Edit1.Text[1] in Vowels then
Lable2.Caption := '是元音';
else
Lable2.Caption := '请再试';
end;　

　　执行这个程序，在编辑框中输入字母，表达式Edit1.Text[1] in Vowels的结果是布尔型的，in是运算符，用来判断字母是否存在于集合中。输入的判别结果会显示在编辑框的下方。以上就用到了集合类型TVowels。　

　　2.1.9.6 记录类型　

　　记录是您的程序可以成组访问的一群数据的集合。下面的例程说明了一个记录类型的用法：　

　　type
TEmployee=record
Name : string[20];
YearHired:1990..2000;
Salsry: Double;
Position: string[20];
end;　

　　记录包含可以保存数据的域，每一个域有一个数据类型。上文的记录TEmployee类型就含有四个域。您可以用以下的方式说明记录型的变量：　

　　var
NewEmployee,PromotedEmployee:TEmployee;

　　用如下的方法可以访问记录的单域：

　　NewEmployee.Salary := 1000;

　　编写如下的语句可以给整个记录赋值：　

　　with PromotedEmployee do
begin
Name :='';
YearHired := 1993;
Salary := 2000.00
Position := 'editor';
end;　

　　您的程序可以将记录当成单一实体来操作：　

　　PromptEmployee := NewEmployee;

　　以上介绍了用户常用的自定义类型。在Delphi的编程中，对象是非常重要的用户自定义数据类型。象记录一样，对象是结构化的数据类型，它包含数据的域(Field)，也包含作为方法的过程和函数。在Delphi中，当您向窗体中加入一个部件，也就是向窗体对象中加入了一个域；每一个部件也是对象，每当您建立一个事件处理过程使得部件可以响应一个事件时，您即自动地在窗体中加入了一个方法。在本章第2节中，将详细讲述Delphi面向对象编程的方法和技巧。　

　　2.1.10 Object Pascal的库单元Unit　

　　Units是常量、变量、数据类型、过程和函数的集合，而且能够被多个应用程序所共享。Delphi已经拥有许多预定义的程序库单元可供您建立您的程序库单元使用。Delphi的Visual Component Library由多个程序库单元组成，它们说明了对象、部件以供您的应用程序用来设计用户界面。例如，当您在窗体中加入一个Check Box时，Delphi自动在您的程序库单元中加入了Stdctrls库单元，因为TCheckBox部件是在StdCtrls库单元中说明的。

　　当您设计您的窗体时，Delphi自动建立一个和您的窗体有关的库单元。您的库单元不必都和窗体有关，也可以使用预定义的只包含数学运算函数的库单元，或是自行编写数学函数库单元。在一个库单元中所有的说明都相互有关系，例如，CDialogs程序库单元包含了在您的应用程序中使用的普通对话框的所有说明。　

　　2.1.10.1 Object Pascal程序库单元的结构　

　　不管一个库单元是否和一个窗体有关，库单元的结构都是相同的。其结构如下：　

　　unit <库单元名称>　
interface　
uses <选择性的库单元列表>
{公有说明}　
implementation　
uses <选择性的库单元列表>
{私有说明}
{过程和函数的执行部分}
initialization {选择性的}
{选择性的初始化程序}
end.　

　　2.1.10.2 程序库单元的接口部分　

　　interface是库单元的接口部分，它决定了本库单元对其他任何库单元或程序的可见(可访问)部分。您可以在接口部分说明变量、常量、数据类型、过程和函数等等。Delphi在您设计窗体的库单元中，将窗体数据类型、窗体变量和事件处理过程都说明在这一部分。

　　interface标志库单元接口部分的开始。在interface中的说明对要使用这些说明的其他库单元或应用程序是可见的。一个库单元可以使用其他Unit的说明，只需要在uses子句中指明那些库单元即可。例如，您在库单元A中编写程序代码，且您想调用UnitB于interface部分说明的程序。您可以把库单元B的名称加入到A的interface部分的uses子句中，则任何A中的程序都可以调用B中说明的程序。而且，如果B中interface部分的uses子句中出现C库单元，尽管A中未曾出现C，A同样可以调用B、C库单元在interface中说明的程序。但如果B出现在A的interface部分的uses子句中，那么库单元A便不能出现在B的interface的uses子句中。因为这样会产生对库单元的循环访问。当试图编译时，会产生出现错误信息。　

　　2.1.10.3 程序库单元的实现部分　

　　实现部分implementation中包含interface中说明的过程、函数、事件处理过程的具体实现程序代码。这一部分可以有自己的额外说明，但这些说明是私有的，外部程序不能调用这些说明。在interface中说明的函数实体必须在implementation部分出现，可以使用标题简写：只输入procedure或function保留字，后面跟过程或函数的名称即可，其后则是程序的实现部分了。如果您在implementation部分说明任何常式，其标题并未出现在interface部分，则必须写全其标题部分。

　　在implementation部分的uses子句中指定的库单元，只供给本库单元的程序使用其interface中说明的程序。其他使用本库单元的库单元，不能访问这些在implementation的udes子句中库单元的说明，因为在implementation后进行的库单元包含是私有的。所以上例中，如果C出现在B的implementation部分，则A不能使用C的公有部分，除非C出现在A的uses子句中。在implementation中出现的循环访问是Delphi所允许的，如果A的implemetation的uses子句中出现B，则B的implementation部分也可以出现A。　

　　2.1.10.4 程序库单元的初始化部分　

　　初始化当前库单元所使用的数据，或是通过interface部分将数据提供给其他应用程序、库单元使用时，您可以在库单元中加入一个initialization部分，在库单元的end前加上您的初始化语句。当一个应用程序使用一个库单元时，在库单元中的initialization部分会先于其他的代码执行。如果一个应用程序使用了多个库单元，则每一个库单元的初始化部分都会在所有的程序代码前执行。　

　　2.1.10.5 使用Delphi的可视化部件及其库单元　

　　当您在窗体中加入可视化部件时，如果该部件在可视化部件库中，Delphi会在您的库单元的interface部分的uses子句中自动加上需要使用的库单元名称。但有些对象在Delphi的环境中并没有可视化部件存在，例如，您想在库单元中加入一个预定义的信息框，则您必须把MsgDlg库单元加入您的uses子句中。如果您要使用TPrinter对象的话，必须将Printer库单元加入uses子句中。在在线帮助中可以查到对象所属的预定义库单元。

　　要使用在其他库单元中说明的函数，应在函数的前面加上这一库单元的名称，并用‘.’号隔开。例如，要在Unit2中使用Unit1中说明的Calculate函数，应使用下面的方法：

　　Number := Unit1.Calculate(10);

　　您可以在任何标识符如属性、常量、变量、数据类型、函数等之前加上库单元的名称。您可以在自由地在任何Delphi库单元中加入程序代码，但不要改变由Delphi生成的程序。　

　　2.1.10.6 建立与窗体无关的新库单元　

　　如果您想在工程中建立一个和任何窗体无关的新库单元，可以现选用File|New Unit。这时一个新的库单元加入了工程，新库单元的代码如下：　

　　unit Unit2;
interface
implementation
end.　

　　Delphi将根据您的工程中的文件数目为您的库单元选择名称，您可以在程序骨架间加入您的程序代码。

　　当编译您的工程时，这个新加入的库单元会被编译为一个具有.DCU后缀的文件。这个新生成的文件是链接到工程的可执行文件上的机器代码。

　　2.1.10.7 将库单元加入工程　

　　将库单元加入工程是比较简单的。无论是您自己建立的库单元还是Delphi建立的与窗体有关的库单元，如果已经完成，则先打开您想加入库单元的工程(可以用Open Project打开工程)；再选用File|Open File，然后选择您想加入的源程序(.PAS文件)，并选择OK即可。则库单元被加入到应用程序中。　

　　2.2 用Delphi的对象进行编程　

　　Delphi是基于面向对象编程的先进开发环境。面向对象的程序设计(OOP)是结构化语言的自然延伸。OOP的先进编程方法，会产生一个清晰而又容易扩展及维护的程序。一旦您为您的程序建立了一个对象，您和其他的程序员可以在其他的程序中使用这个对象，完全不必重新编制繁复的代码。对象的重复使用可以大大地节省开发时间，切实地提高您和其他人的工作效率。　

　　2.2.1 什么是对象　

　　一个对象是一个数据类型。对象就象记录一样，是一种数据结构。按最简单的理解，我们可以将对象理解成一个记录。但实际上，对象是一种定义不确切的术语，它常用来定义抽象的事务，是构成应用程序的项目，其内涵远比记录要丰富。在本书中，对象可被理解为可视化部件如按钮、标签、表等。

　　了解对象，最关键的是掌握对象的特性。一个对象，其最突出的特征有三个：封装性、继承性、多态性。　

　　2.2.1.1 对象的封装性　

　　对对象最基本的理解是把数据和代码组合在同一个结构中，这就是对象的封装特性。将对象的数据域封闭在对象的内部，使得外部程序必需而且只能使用正确的方法才能对要读写的数据域进行访问。封装性意味着数据和代码一起出现在同一结构中，如果需要的话，可以在数据周围砌上“围墙”，只有用对象类的方法才能在“围墙”上打开缺口。　

　　2.2.1.2 对象的继承性　

　　继承性的含义直接而且显然。它是指把一个新的对象定义成为已存在对象的后代；新对象继承了旧类的一切东西。在往新对象中添加任何新内容以前，父类的每一个字段和方法都已存在于子类中，父类是创建子类的基石。　

　　2.2.1.3 对象的多态性　

　　多态性是在对象体系中把设想和实现分开的手段。如果说继承性是系统的布局手段，多态性就是其功能实现的方法。多态性意味着某种概括的动作可以由特定的方式来实现，这取决于执行该动作的对象。多态性允许以类似的方式处理类体系中类似的对象。根据特定的任务，一个应用程序被分解成许多对象，多态性把高级设计处理的设想如新对象的创建、对象在屏幕上的重显、程序运行的其它抽象描述等，留给知道该如何完美的处理它们的对象去实现。　

　　2.2.1.4 通过Delphi实例了解对象　

　　让我们结合Delphi的实例讨论对象的概念:

　　当您要建立一个新工程时，Delphi 将显示一个窗体作为设计的基础。在程序编辑器中，Delphi将这个窗体说明为一个新的对象类型，并同时在与窗体相关联的库单元中生成了创建这个新窗体对象的程序代码。　

　　unit Unit1;　
interface　
uses SysUtils, Windows, Messages, Classes, Graphics, Controls, Forms, Dialogs;　
type
TForm1 = class(TForm) {窗体的类型说明开始}
private
{ Private declarations }
public
{ Public declarations }
end; {窗体的类型说明结束}　
var
Form1: TForm1; {说明一个窗体变量}　
implementation　
{$R *.DFM} 　
end.　

　　新的窗体类型是TForm1，它是从TForm继承下来的一个对象。它具有对象的特征：含有域或方法。由于您未给窗体加入任何部件，所以它只有从TForm类中继承的域和方法，在窗体对象的类型说明中，您是看不到任何域、方法的说明的。Form1称为TForm1类型的实例(instance)。您可以说明多个对象类型的实例，例如在多文档界面(MDI)中管理多个子窗口时就要进行这样的说明。每一个实例都有自己的说明，但所有的实例却共用相同的代码。

　　假设您向窗体中加入了一个按钮部件，并对这个按钮建立了一个OnClick事件处理过程。再查看Unit1的源程序，会发现TForm1的类型说明部分如下：

　　type
TForm1 = class(TForm)
Button1: TButton;
procedure Button1Click(Sender: TObject);
private
{ Private declarations }
public
{ Public declarations }
end;　

　　现在TForm1对象有了一个名为Button1的域：它是您在窗体中加入的按钮。TButton是一个对象类型，Button1是Tbutton的一个实例。它被TForm1对象所包含，作为它的数据域。每当您在窗体中加入一个部件时，部件的名称就会作为TFom1的域加入到类型说明中来。在Delphi中，您所编写的事件处理过程都是窗体对象的方法。每当您建立一个事件处理过程，就会在窗体的对象类型中说明一个方法。

　　当您使用Object Inspector来改变对象(部件)的名称时，这个名称的改变会反映到程序中。例如，在Object Inspector中将Form1的Name属性命名为ColorBox，您会发现在类型说明部分，会将前文的TForm1改为：　

　　TColorBox=class(TForm);　

　　并且在变量说明部分，会说明ColorBox为TColorBox类型的变量，由Delphi自动产生的事件处理过程名称会自动改为TColorBox.Button1Click；但您自行编写的实现部分的代码却不会被自动修改。因此，如果您在改变Name属性前编写了程序，则您必须将事件处理过程中的对象名称进行改变。所以，原先的Form1.Color要改为ColorBox.Color。　

　　2.2.2 从一个对象中继承数据和方法　

　　前面的TForm1类型是很简单的，因为它只含有域Button1和方法Button1Click。但是在这个窗体上，您可以改变窗体的大小、加入或删除窗体的最大最小化按钮，或设置这个窗体为MDI界面。对于一个只包含一个域和方法的对象来讲，您并没有看到显式的支持程序。在窗体上单击鼠标或用Object Inspector的上端的Object Selector选中Form1对象，按动F1查阅它的在线帮助，您会在Properties和Method中找到它的继承到的全部属性和方法。这些是在TForm类型中说明的，TForm1是TForm的子类，直接继承了它所有的域、方法、属性和事件。例如窗体的颜色属性Color就是在TForm中说明的。当您在工程中加入一个新窗体时，就等于加入了一个基本模型。通过不断地在窗体中加入部件，您就自行定义了一个新的窗体。要自定义任何对象，您都将从已经存在的对象中继承域和方法，建立一个该种对象的子类。例如对象TForm1就被说明为对象TForm的子类，拥有一个窗体部件的基本属性或方法。只有当您在窗体中加入了部件或编写了事件处理过程时，Form1才成为您自己的类型。

　　一个比较特殊的对象是从一个范围较广或较一般的对象中继承下来的，它是这个特别对象的祖先，这个对象则称为祖先的后代。一个对象只能有一个直接的祖先，但是它可以有许多后代。TForm是TForm1类型的祖先，所有的窗体对象都是TForm的后代。

　　用F1查阅窗体的在线帮助时，您会发现TForm被称为component(部件)。这是因为所有的部件都是对象。

　　在这个结构中所有的部件都是对象。部件类型TComponent从TObject类型中继承数据和程序代码，并具有额外的可以用作特殊用途的属性、方法、事件，所以部件可以直接和用户打交道，记录它的状态并存贮到文件中等等。控制类型TControl从TComponent中继承而来，又增加了新的功能，如它可以显示一个对象。在上图中，虽然TCheckBox不是直接由TObject继承来的，但是它仍然有任何对象所拥有的属性，因为在VCL结构中，TCheckBox终究还是从TObject 中继承了所有功能的特殊对象，但它还有些自行定义的独到的功能，如可以选择记录状态等。　

　　2.2.3 对象的范围　

　　2.2.3.1 关于对象的范围　

　　一个对象的范围决定了它的数据域、属性值、方法的活动范围和访问范围。在一个对象的说明部分说明的数据域、属性值、方法都只是在这个对象的范围中，而且只有这个对象和它的后代才能拥有它们。虽然这些方法的实际程序代码可能是在这个对象之外的程序库单元中，但这些方法仍然在这个对象的范围内，因为它们是在这个对象的说明部分中说明的。

　　当您在一个对象的事件处理过程中编写程序代码来访问这个对象的属性值、方法或域时，您不需要在这些标识符之前加上这个对象变量的名称。例如，如果您在一个新窗体上加入一个按钮和一个编辑框，并为这个按钮编写OnClick事件处理过程：　

　　procedure TForm1.Button1Click(Sender:Tobject);
begin
Color :=clFuchsia;
Edit1.Color :=clLime;
end; 　

　　其中的第一行语句是为整个窗体Form1着色。您也可以编写如下：

　　Form1.Color :=clFuchsia;　

　　但您可以不必加上Form1.，因为Button1Click方法是在TForm1对象的范围里。当您在一个对象的范围中时，您可以省略所有这个对象中的属性值、方法、域之前的对象标识符。但是当您编写第二个语句改变编辑框的底色时，因为此时您想访问的是TEdit1对象的Color属性，而不是TForm1类型的，所以您需要通过在属性前面加上编辑框的名称来指明Color属性值的范围。如果不指明，Delphi会象第一个语句一样，将窗体的颜色变成绿色。因为Edit1部件是在窗体中的，它是窗体的一个数据域，所以您同样不必指明其从属关系。

　　如果Edit1是在其他窗体中，那么您需要在编辑框之前加上这个船体对象的名称了。例如，如果Edit1是在Form2之中，那它是Form2说明的一个数据域，并位于Form2的范围中，那么您需要将第二句改为：　

　　Form2.Edit1.Color := clLime;　

　　而且需要把Unit2加入Unit1的uses子句中。

　　一个对象的范围扩展到这个对象的所有后代。TForm的所有属性值、方法和事件都在TForm1的范围中，因为TForm1是TForm的后代。您的应用程序不能说明和祖先的数据域重名的类型、变量等。如果Delphi显示了一个标识符被重复定义的信息，就有可能是一个数据域和其祖先对象(例如TForm)的一个数据域有了相同的名称。可以尝试改变这个标识符的名称。　

　　2.2.3.2 重载一个方法　

　　您可以重载(Override)一个方法。通过在后代对象中说明一个与祖先对象重名的方法，就可以重载一个方法。如果想使这个方法在后代对象中作和祖先对象中一样的工作但是使用不同的方式时，您就可以重载这个方法。Delphi不推荐您经常重载方法，除非您想建立一个新的部件。重载一个方法，Delphi编译器不会给出错误或警告提示信息。

　　2.2.4 对象公有域和私有域的说明　

　　当使用Delphi的环境来建立应用程序时，您可以在一个TForm的后代对象中加入数据域和方法，也可以通过直接修改对象类型说明的方法来为一个对象加上域和方法，而不是把一个部件加入窗体或事件处理过程中。

　　您可以在对象的Public或Private部分加入新的数据域和方法。Public和Private是Object Pascal的保留字。当您在工程中加入新的窗体时，Delphi开始建立这个新窗体对象。每一个新的对象都包含public和private指示，以便您在代码中加入数据域和方法。在public部分中说明其它库单元中对象的方法也可以访问的数据域或方法。在private部分的说明有访问的限制。如果您在private中说明域和方法，那么它在说明这个对象的库单元外是不透明的，而且不能被访问。private中可以说明只能被本库单元方法访问的数据域和本库单元对象访问的方法。过程或函数的程序代码可以放在库单元的implementation部分。

　　2.2.5 访问对象的域和方法　

　　当您想要改变一个窗体对象的一个域的某个属性，或是调用它的一个方法时，您必须在这个属性名称或调用方法之前加上这个对象的名称。例如，如果您的窗体上有一个编辑框部件，而您需要在运行中改变它的Text属性，需要编写下列的代码：　

　　Edit1.Text := 'Welcome to Delphi';

　　同样，清除编辑框部件中选中的文本，可以调用TEdit部件的相应方法：　

　　Edit1.ClearSelection;　

　　如果您想改变一个窗体对象中一个对象域的多个属性或调用多个方法时，使用with语句可以简化您的程序。with语句在对象中可以和在记录中一样方便地使用。下面的事件处理过程在响应OnClick事件时，会对一个列表框作多个调整：　

　　procedure TForm1.Button1Click(Sender:TObject);
begin
ListBox1.Clear;
ListBox1.MultiSelect :=True;
ListBox1.Item.Add('One');
ListBox1.Item.Add('Two');
ListBox1.Item.Add('Three');
ListBox1.Sorted :=Ture;
ListBox1.FontStyle :=[fsBold];
ListBox1.Font.Color :=clPurple;
ListBox1.Font.Name :='Times New Roman';
ListBox1.ScaleBy(125,100);
end;　

　　如果使用了With语句，则程序如下：　

　　procedure TForm1.Button1Click(Sender:TObject);
begin
with (ListBox1) do
begin
Clear;
MultiSelect :=True;
Item.Add('One');
Item.Add('Two');
Item.Add('Three');
Sorted :=Ture;
FontStyle :=[fsBold];
Font.Color :=clPurple;
Font.Name :='Times New Roman';
ScaleBy(125,100);
end;
end;　

　　使用with语句，您不必在每一个属性或方法前加上ListBox1标识符，在With语句之内，所有的属性或调用方法对于ListBox这个对象而言都是在它的范围内的。　

　　2.2.6 对象变量的赋值　

　　如果两个变量类型相同或兼容，您可以把其中一个对象变量赋给另一个对象变量。例如，对象TForm1和TForm2都是从TForm继承下来的类型，而且Form1和Form2已被说明过，那么您可以把Form1赋给Form2:

　　Form2 :=Form1;

　　只要赋值的对象变量是被赋值的对象变量的祖先类型，您就可以将一个对象变量赋给另一个对象变量。例如，下面是一个TDataForm的类型说明，在变量说明部分一共说明了两个变量：AForm和DataForm。　

　　type
TDataForm = class(TForm)
Button1:TButton;
Edit1:TEdit;
DataGrid1:TDataGrid;
Database1:TDatabase;
TableSet1:TTableSet;
VisibleSession1:TVisibleSession;
private
{私有域说明}
public
{公有域说明}
end;
var
AForm:TForm;
DataForm:TDataForm;

　　因为TDataForm是TForm类型的后代，所以Dataform是AForm的后代，因此下面的赋值语句是合法的：

　　AForm :=DataForm;

　　这一点在Delphi中是极为重要的。让我们来看一下应用程序调用事件处理过程的过程，下面是一个按钮部件的OnClick事件处理过程：

　　procedure TForm1.Button1Click(Sender:TObject);
begin
end;

　　您可以看到TObject类在Delphi的Visual Component Library的顶部，这就意味着所有的Delphi对象都是TObject的后代。因为Sender是TObject类型，所以任何对象都可以赋值给它。虽然您没有看见赋值的程序代码，但事实上发生事件的部件或控制部件已经赋给Sender了，这就是说Sender的值是响应发生事件的部件或控制部件的。

　　您可以使用保留字is来测试Sender以便找到调用这个事件处理过程的部件或控制部件的类型。Delphi中的一个显示drag-and-drop的DRAGDROP.DPR工程。加载它，可以查阅到DROPFONT.PAS库单元的代码，在Memo1DragOver方法中检查了一个对象变量的类型。在这种情形下，参数是Source而不是Sender。　

　　procrdure TForm1.Memo1DragOver(SenderSource:TObject;X,Y:integer;
State:TDragState;var Accept:Boolean);
begin
Accept :=Source is TLabel;
end; 　

　　Source参数也是TObject类型，Source被赋值为那个被拖曳的对象。用Memo1DragOver方法的目的是确保只有标签可以被拖曳。Accept是布尔型参数，如果Accept为True，那么用户选择的部件可以被拖曳；反之当Accept的值为False时，用户就不可以拖曳选择控制部件。is保留字检查Source是否TLabel的类型，所以Accept只有在用户拖曳一个标签时才为真，并作为变参输出到函数之外。

　　下面的drag-and-drop展示的Memo1DragDrop事件处理过程中也使用了Source参数。这个方法是为了把Memo部件的字型改变成和放入这个备注控制部件的标签一样的字型：　

　　procedure TForm1.Memo1DragDrop(SenderSource:TObject;
X,Y:Integer);
begin
Memo1.Font := (Source as TLabel).Font;
end;　

　　当您在这个事件处理过程中编写赋值语句时，开发人员并不知道用户会放入哪一个标签，只有通过参考这个标签的名称(Source as TLabel)用户才能知道，并把标签类型赋给Memo1.TFont。Source包含了用户拖放控制部件的名称，只有当Source是一个标签时，这个事件处理过程才允许这个赋值发生。

　　2.2.7 建立非可视化对象　

　　您在Delphi中使用的大部分对象都是您在设计和运行期间可以看见的部件，例如编辑框、按钮等；一些部件，如通用对话框(Common dialog box)等，在设计时看不见，而在运行时可以看见；另外有些部件，例如计时器(Timer)、数据源(Data Source)部件等，在程序的运行期间没有任何可视化的显示，但您却可以在您的应用程序中使用它们。　

　　2.2.7.1说明一个非可视化对象　

　　下面，通过一个简单的例子讲述如何建立自己的非可视化对象：

　　您可以用如下的方法，建立一个自己的TEmployee非可视化对象：　

　　type
Temployee = class(TObject);
Name := String[25];
Title := String[25];
HourlyPayRate : Double;
function CalculatePayAmount:Double;
end;　

　　在这种情况下，TEmployee从TObject继承下来，且包含三个域和一个方法。把您建立的类型说明放在库单元中的说明部分，并和窗体说明放在一起。在这个程序库单元的变量说明部分，说明一个新类型的变量：　

　　var
Employee : TEmployee;　

　　2.2.7.2用Create方法建立对象实例　

　　TEmployee只是一个对象类型。除非通过一个构造函数的调用从而被实例取代或创建，否则一个对象并不存储在内存中。构造函数是一个方法，它为新对象配置内存并且指向这个新的对象。这个新的对象也被称为这个对象类型的一个实例。

　　建立一个对象的实例，需要调用Create方法，然后构造函数把这个实例赋给一个变量。如果您想说明一个TEmployee类型的实例，在您访问这个对象的任何域之前，您的程序代码必须调用Create。

　　Employee := TEmployee.Create;　

　　Create方法并没有在TEmployee类型中说明，它继承自TObject类型。因为TEmployee是TObject的子类，所以它可以调用Create方法而创建一个TEmployee实例。然后把它赋给Employee变量。在创建了一个这样的对象后，您就可以象使用其他的Delphi对象一样访问Employee对象了。　

　　2.2.7.3 撤销对象　

　　当您使用完对象后，您应该及时撤销它，以便把这个对象占用的内存释放出来。您可以通过调用一个注销方法来撤销您的对象，它会释放分配给这个对象的内存。

　　Delphi的注销方法有两个：Destroy和Free。Delphi建议使用Free，因为它比Destroy更为安全，同时调用Free会生成效率更高的代码。

　　您可以用下列的语句释放用完的Employee对象：　

　　Employee.Free;　

　　和Create方法一样，Free方法也是TEmployee从TObject中继承过来的。把您的注销放在try…finally程序模块的finally部分，而把对象的程序代码放在try部分是编程的好习惯。这样，即使您的程序代码在使用对象时发生了异常事件，也会确保您为这个对象分配的内存会被释放。关于异常处理和try…finally程序模块的信息以及建立非可视化对象的例子，在后文中还将仔细讲述。

程序员特区

http://coderarea.net/html/bianchengyuyan/DELPHIyuyan/DELPHIzonghe/2009/0506/93053.html