深入 delphi (转）

刚刚接触的Delphi的朋友，可能最感兴趣的就是它丰富、强大的VCL（可视化构件
库）。仅仅向窗体上扔几个构件，甚至不用动手写代码，就能很容易地做出一个有实用
价值的程序，真是令人激动。但是，VCL只是Delphi的一小部分，Delphi的优秀远远不
只是表现在V
CL上。如果你仅仅停留在使用VCL这一阶段，那么你永远也不可能成为一个真正的
Delphi高手。记住，必须超越VCL，才能够接触到Delphi的核心。
　　那么，在Delphi的VCL后面，到底隐藏着什么呢？本文将讨论两个比较高级的
Delphi主题：OOP和数据库编程。
　　本文假定读者已经具有Delphi编程的基础知识，例如，熟悉Pascal语言的一般语
法，掌握简单的VCL使用，会使用Data-Ware构件编写基本的数据库程序，等等。本文不
会重复VCL的使用这样的问题。
　　
　　1、OOP
　　
　　OOP的英文全称是Object Oriented Programming，翻译过来就是面向对象编程。
OOP是一种非常重要的编程思想。也许你会对这种抽象的东西不感兴趣，可是几乎任何
一个高手都会告诉你：“语言并不重要，重要的是编程思想。”
　　大家知道，Delphi的语言基础是Object Pascal。这是Borland在传统的Pascal语言
中增加了面向对象的特性后发展而成，并且特地冠以Object的字样，以示与传统的
Pascal语言的差别，可见面向对象技术对其影响之大。可以说，Delphi构建在Object
Pascal的基础之上，而Object Pascal构建在面向对象技术之上。
　　事实上，不但Delphi，OOP也是C++、Java等其他许多现代编程语言的基础（Visual
Basic不完全地支持OOP）。熟练地掌握OOP技术，是深入掌握Delphi的必要条件，是迈
入高手境界的必经之路，也是一个成熟的程序员的标志之一。理解了OOP技术之后，很
多以前令你困惑的东西会迎刃而解。
　　有趣的是，虽然Delphi是完全基于OOP的，但是一个完全不了解OOP的程序员也能够
使用Delphi编写程序，因为Delphi会自动完成绝大多数的工作。当你开始学习Delphi的
时候，你可能无法想象，当简单地往窗体上添加一个按钮时，Delphi会完成多么复杂的
工作吧
！但是既然有志于深入Delphi的世界，成为一个真正的程序员，我们就应该对Delphi的
细节具有好奇心。
　　这些理论可能会让人觉得枯燥和望而生畏，其实当你掌握了它之后就会觉得没什么
了。当然，你需要有足够的毅力。

　　OOP有三个主要的特征：
　
　　1.1 数据封装
　　
　　让我们先看一段代码：
　　
　　type
　　　TDate = class
　　　Mouth,day,Year:Integer;
　　　procedure SetValue(m,d,y:Integer);
　　　function LeapYear:Boolean;
　　end;
　　
　　我们首先会看到class关键字，它的中文译名为“类”。类是一个非常重要的概
念。根据权威的定义，类是：一种用户定义的数据类型，它具有自己的说明和一些操
作。一个类中含有一些内部数据和一些过程或函数形式的对象方法，通常来描述一些非
常相似的对象
所具有的共同特征和行为。
　　这个定义可能比较晦涩。你可以把类想象为一种特殊的Record类型，其中不但可能
包含数据，而且可能包含函数和过程（在OOP中称之为方法）。这些数据和方法被统称
为类的成员。
　　上面这个类很显然是一个日期类型，它包括Mouth，Day，Year这三个数据成员，和
SetValue、LeapYear这两个方法。顺便说一句，在Delphi中，习惯以字母T作为每个类
的前缀，就象Viusal C++中习惯以字母C作为每个类的前缀一样。
　　Mouth，Day，Year这三个数据成员指定了该日期的年、月、日。SetValue方法为这
三个数据成员赋值，而LeapYear检查当前日期所在的那一年是否是闰年。下面我们给出
这两个方法的实现部分：
　　
　　procedure TDate.SetValue(m,d,y):Integer;
　　begin
　　　Mouth := m;
　　　Day := d;
　　　Year := y;
　　end;
　　
　　function TDate.LeapYear:Boolean;
　　begin
　　　if (Year mod 4 <> 0) then
　　　　LeapYear := False
　　　else if (Year mod 100 <> 0)
　　　　LeapYear := True
　　　else if (Year mod 400 <> 0)
　　　　LeapYear := False
　　　else
　　　　LeapYear := True;
　　end;
　　
　　实现了这些定义之后，就可以这样调用它们：
　　
　　var
　　　ADay: TDate;
　　begin
　　　//建立一个对象
　　　ADay := TDate.create;
　　　//使用之
　　　ADay.SetValue(1,1,2000);
　　　if ADay.LeapYear then
　　　　ShowMessage('闰年：' + Inttostr(ADay.year));
　　　//释放对象
　　　ADay.free;
　　end;
　　
　　我们来逐行解释这些代码的含义。var后面那一行声明了一个TDate类的变量。
　　声明了变量之后，我们怎么使用它呢？使用TDate类的Create方法可以建立一个该
类的对象，并将其赋予ADay变量。
　　现在我们又接触到了OOP中另一个重要的概念：对象。什么是对象？简言之，对象
就是类的实例，或者说，是类定义的数据类型的变量。当建立一个类的对象时，系统为
它分配一块内存。例如我们定义一个变量A为Integer类型，那么，Integer是一个数据
类型，A就是一个实例。类与对象的关系就类似于这两者之间的关系。区别类和对象是
非常重要的，甚至一些专业的程序员都往往将他们搞混。
　　细心的读者可能注意到，在TDate类的定义中，并没有Create这个方法。那么这个
Create方法是从哪里来的呢？Create方法是每一个Class都具有隐含的方法，它的作用
是建立这个类的实例。请注意，在这里，类和其他的数据类型是不同的。其他的数据类
型都是声明了变量之后就可以直接使用，而类类型必须在使用Create方法创建它的实例
（对象）之后才能使用。
　　事实上，在C++和其他大多数的OOP语言中，声明一个类的变量就能够同时建立起这
个类的对象。而Delphi（包括它的孪生兄弟C++Builder）在这方面与众不同，必须要
Create一下才能真正建立对象。同时，在这个对象不再需要时，必须要手工调用free方
法释放这个对象（当然，free方法也是每个类隐含的）。这和Delphi独特的“对象引用
模型”有关，有兴趣的朋友可以查阅有关资料，我就不多说了。
　　这种情况造成了一个非常有趣的现象，那就是，编程的初学者往往忘记在使用对象
之前create它，从而出错，但从C++转向Delphi的高手也常常犯同样的错误……
　　顺便告诉大家一个诀窍，当编译器出现“Read of Address: ffffffff”这样的错
误时，多半是因为在使用对象之前忘了Create，可以从这方面入手检查代码。另外，也
千万不要忘记在不需要它时使用free释放掉，否则可能造成内存泄漏。
　　在建立和释放对象的代码的中间，是使用对象的代码。访问对象的数据成员非常简
单，和Record类型没有什么区别。可以点号表达式来访问它们：
　　
　　ADay.Year := 2000;
　　ADay.Mouth := 1;
　　ADay.Day := 1;
　　
　　同样，也可以使用点号表达式来调用对象的方法。如果你阅读了方法实现部分的代
码，你可以很容易地发现，ADay.SetValue1,1,2000)这一句分别为三个数据成员赋了
值，而ADay.LeapYear调用则返回当前日期所在年是否为闰年。至此，整段代码的意义
也就清楚了。
　　然而，类不仅仅这么简单。上面这个例子是一个非常简单的类，可以直接访问它的
任何成员（数据和方法）。但某些类的成员是不能被随便访问的。Delphi中用三个关键
字区分这些成员的访问权限：
　　
　　表1

Private 该类型的成员只能在声明类中被访问
Public 该类型的成员可以被程序中的任何地方的代码访问
Protected 该类型的成员只能在声明类以及声明类的派生类中被访问
　　
　　Protected类型的成员以及什么是“派生类”等问题我们留到以后再进行讨论，现
在我们将注意力集中在前两者。
　　Public类型就是在上面例子中的那种类型，这个很好理解。而Private类型，根据
表格中的简单解释，只能在该成员被声明的那个类（也就是该成员所属的那个类啦）中
被访问，越出这个界限，它就是不可见的。那么，Private类型的成员将如何被使用呢
？简单地说，就是通过一个Public类的方法来访问它。
　　让我们看一个新的例子：
　　
　　type
　　　TDate = class
　　　private
　　　Mouth,day,Year:Integer;
　　　Public
　　　procedure SetValue(m,d,y:Integer);
　　　function LeapYear:Boolean;
　　　function GetText:String;
　　end;
　　
　　　在这个类中，Mouth，Day，Year这三个成员被声明为Private成员，因此它们在
类以外的其它地方是不可访问的。也就是说，如果你使用
　　
　　ADay.Year := 2000;
　　
　　这样的代码，那么编译器将会报错。但是，我们可以照样通过SetValue方法为它们
赋值：
　　
　　ADay.SetValue(1,1,2000);
　　
　　这行代码是合法的，因为SetValue本身是TDate类的成员，而且它又是一个Public
成员。而使用GetText方法则可以得到当前日期值（这也是得到当期日期值的唯一办
法）。
　　这样的设置使得类的一些成员被隐含起来，用户只能用一些专门的方法来使用它
们。那些可以被外部代码访问的成员称之为类的接口。这样做有什么好处呢？首先，这
让类的作者可以检测被赋值的内容。比如，用户可能给一个对象赋予13月40日这样的无
效日期。而在隐含了一些成员之后，类的作者可以在方法的代码中检测这些值是否有
效，从而大大地减少了产生错误的机会。其次，使用规范的类，作者可以随时修改类内
部的代码，而使用该类的代码却无需任何修改！这样使得代码的维护成了一件轻松的事
件，特别是对于多人协作的大型软件而言。
　　这就叫做数据的封装（encapsulation）。这是OOP的第一个特征。一个优秀的OOP
程序员，应该在设计类的时候，就确定将哪些重要的数据封装起来，并给出一个高效率
的接口。
　　需要指出的一点是，表1中Private部分的论述对于“标准的”OOP语言（例如C++）
是完全正确的，但对于Delphi有一个例外。在Delphi中，Private成员除了在声明类中
可以访问外，在声明类所在的单元（.pas文件）中的任何地方都能被访问，不论这些代
码与声明
类的关系如何。严格来说，这是违反OOP的原则的，我不明白Borland为何要这么做（据
说是为了方便）。在关于Delphi的优劣性的讨论中，这是常被涉及的一个问题。
　　
　　1.2 继承与派生
　　
　　我们再来看一段代码：
　　
　　type
　　　　TNewDate = class(TDate)
　　　Public
　　　　function GetTextNew:String;
　　end;
　　
　　function GetText:String;
　　begin
　　　return := inttostr(Mouth) + ':' + inttostr(Day) + ':' +
inttostr(Year);
　　end;
　　
　　可以看到，在class后面出现一个包含在括号中的类名。这种语法表示新的类继承
了一个旧的类。继承了原有类的类称之为派生类，也叫子类，被继承的类称之为基类，
也叫父类。
　　派生类与基类之间是什么关系呢？当派生类继承自一个基类时，它自动具有基类的
所有数据、方法以及其他类型，无须在派生类中再做说明。例如，可以象下面这段代码
这样使用TNewDate类：
　　
　　var
　　　ADay: TNewDate;
　　begin
　　　ADay := TNewDate.create;
　　　ADay.SetValue(1,1,2000);
　　　if ADay.LeapYear then
　　　　ShowMessage('闰年：' + Inttostr(ADay.year));
　　　ADay.free;
　　end;
　　
　　而且，派生类还可以在基类的基础上加入自己的数据和方法。可以看到在TnewDate
类中增加了一个新的方法GetTextNew。下面给出这个方法的实现部分：
　　
　　function GetTextNew:String;
　　begin
　　　return := GetText;
　　end;
　　
　　然后调用它：
　　
　　ADay.GetTextNew;
　　
　　这个新的方法工作得很好。
　　为什么GetTextNew方法必须调用基类中的GetText方法，而不能直接使用GetText方
法中的那些代码呢？原因是，Mouth，Day，Year这三个成员被声明为Private成员，因
此它们即使在派生类中也是不能被访问的，所以必须调用基类中的GetText方法，间接
地使用它们。如果要直接使用它们的话，可以将这三个成员的属性从Private改为
Protected。在表1中可以看到，Protected属性的成员可以在声明类以及声明类的派生
类中被访问，然而仍然不能被这两种情况以外的其他代码所访问。现在我们终于可以理
解了，这个特殊的属性实际上提供了极大的方便：它使得类的成员被封装，避免了混
乱，同时又能够让派生类方便地使用它们。
　　（如果你是一个细心的人，你可能发现上面的话中间有一个小小的仳漏。当你真的
在GetTextNew方法中访问了基类的Private成员的话，你可能会惊奇地发现程序也能够
编译通过而且正常运行！其实，这个问题和OOP本身没有关系。上面我已经说过，在
Delphi中，Private成员在声明类所在的单元文件中的任何地方都能被访问，因此如果
TNewDate类和TDate类在同一个.pas文件中时，这种情况就不足为怪了。）
　　怎么样，是不是觉得非常奇妙？通过这种继承的机制，类不再仅仅是数据和方法的
封装，它提供了开放性。你可以方便地继承一个功能强大的类，然后添加进自己需要的
特性，同时，你又不需要对基类进行任何的修改。相反，原作者对基类的任何改动，都
可以在你的新类中立即反映出来。这非常符合代码的重用要求。
　　这种继承机制也非常符合现实世界中的情形。可以设想，一般意义上的“动物”是
一个类，具有自己的一些特征（成员）；而“狗”是“动物”的派生类，它具有动物的
所有特征，同时还具有自己独有的特征（四条腿，汪汪叫，等等）。而“狗”这个类可
以继续派生下去，例如“黑狗”“白狗”，它们除了保留狗的全部特征之外，还具有自
己的特征（黑颜色，白颜色，等等）。而具体到一只活生生的，可以认为它就是“黑
狗”或“白狗”（或其他什么狗）的一个实例（对象）。
　　OOP这种对现实世界的模拟不仅极大地简化了代码的维护，而且使得整个编程思想
产生了革命性的变化，较之模块化编程有了飞跃的进步。
　　如果你曾经仔细阅读过VCL的资料甚至它的源代码，你就可以发现，整个VCL都是建
立在这种强大的封装-继承的机制之上的。你可以看到一张详细的VCL层次结构图，就象
是一个庞大的家谱，各种VCL构件通过层层继承而产生。例如，一个简简单单的TForm
类，就是许多次继承之后的产物：
　　TObject - TPersistent - TConponent - TControl - TWinControl -
TScrollingWinControl - TCustomForm - TForm
　　不但Delphi的VCL，Visual C++中的著名的MFC（Microsoft Foundation Class,微
软基本类库），以及以前Borland C++中风光一时的OWL（Object Window Library，对
象窗口类库），都是建立在这种机制之上。所不同的是，对于前两种语言，你要花上好
几个月的功夫去基本掌握那些繁复无比的类，才能写出比较有实用价值的程序，而在
Delphi中，大部分的工作Delphi都已经自动帮你完成了。例如，每次你向程序中加入一
个窗体时，Delphi就自动为你从TForm派生一个新类（默认为TForm1），并且为这个新
类创造一个实例。你对这个窗体的改动（添加构件和代码之类），无非是为这个派生类
加入一些新的特性而已；你再也用不着自己去处理最大化、最小化、改变大小这一类的
情况，因为这些代码都在基类中被实现，而被派生类所继承了。这就是Delphi的伟大之
处。当然，Delphi的VCL也绝不比MFC或OWL逊色（事实上它是由后者演变而来）。
　　（可能有人会问起VB的情况。VB不支持继承，因此并没有什么复杂的类库，它自己
的控件也少得可怜，主要是使用ActiveX控件。）。
　　也许你已经若有所悟，为你的发现而心痒难骚了吧。但是，我们要讨论的东西当然
不会仅仅这么简单。
　　在1.1部分（“数据封装”），我们讲到了“Create方法是每一个Class都具有隐含
的方法”。其实，这种说法是不准确的。事实是，在Delphi中，所有的类都默认继承自
一个最基础的类TOject，甚至在你并未指定继承的类名也是如此。Create方法是
TObject类具有的方法，因此理所当然，所有的类都自动获得了Create方法，不管你是
否实现过它。想想看就知道了：如果没有Create方法的话，怎样建立一个对象呢？
　　你可能注意到了Create方法是一个特殊的方法。不错，Create方法的确非常特殊，
甚至于它的“头衔”不再是function或procedure，而是Constructor（构造器）。你可
以在VCL的源码中见到这样一些例子：
　　
　　Constructor Create;
　　
　　构造器不仅是一个Delphi关键字，而且是一个OOP方法学的名词。与之相对应的，
还有Destructor（毁坏器）。前者负责完成创建一个对象的工作，为它分配内存，后者
负责释放这个对象，回收它的内存。要注意的一点是，Constructor的名字一般是
Create，但Destructor的名字却不是Free，而是Destroy。例如：
　　
　　Destructor Destroy;
　　
　　那么，在以前的代码，为什么又使用Free来释放对象呢？二者的区别是，Destroy
会直接释放对象，而Free会事实检查该对象是否存在，如果对象存在，或者对象不为
nil，它才会调用Destroy。因此，程序中应该尽量使用free来释放对象，这样更加安全
一些。（但要
注意，free也不会自动将对象置为nil，所以在调用free之后，最好是再手动将对象置
为nil。）
　　象对待一般的函数或过程那样，也可以向构造器传递参数：
　　
　　type
　　　TDate = class
　　　　private
　　　　Mouth,day,Year:Integer;
　　　　Public
　　　　function LeapYear:Boolean;
　　　　function GetText:String;
　　　　Constructor Create(m,d,y:Integer);
　　　end;
　　
　　procedure TDate.Create(m,d,y):Integer;
　　　begin
　　　Mouth := m;
　　　Day := d;
　　　Year := y;
　　end;
　　
　　调用它：
　　
　　ADay: TDate;
　　begin
　　　ADay := TDate.create(1,1,2000);
　　　if ADay.LeapYear then
　　　　ShowMessage('闰年：' + Inttostr(ADay.year));
　　　ADay.free;
　　end;
　　
　　这样，在Create方法里就完成了对数据的初始化，而无须再调用SetValue方法了。
　　
　　接下来，我们将要涉及到另一个重要的、也是很有趣的问题：方法的虚拟与重载。

　　可能你已经有点晕了吧……还是先看一个新的例子：
　　
　　type
　　　TMyClass = class
　　　　procedure One;virtual;
　　　end;
　　
　　type
　　　TNewClass = class(TMyClass)
　　　　procedure One;override;
　　　end;
　　
　　procedure TMyclass.One;virtual;
　　begin
　　　ShowMessage('调用了TMyclass的方法！');
　　end;
　　
　　procedure TNewClass.One; override;
　　begin
　　　Inherited;
　　　ShowMessage('调用了TNewClass的方法！');
　　end;
　　
　　可以看到，从TMyClass派生了一个新类TNewClass。这两个类都声明了一个名字相
同的方法One。所不同的是，在TMyClass中，One方法后面多了一个Virtual关键字，表
示这个方法是一个虚拟方法（Virtual Method）。而在TNewClass中，One方法后面多了
一个Override关键字，表示该方法进行了重载（Override）。重载技术能够实现许多特
殊的功能。

　　让我们来仔细分析它们的实现部分。在TMyclass.One方法的实现部分，调用
ShowMessage过程弹出一个对话框，说明该方法已被调用；这里没有任何特别的地方。
在TNewClass.One方法中，出现了一条以前从未出现过的语句：
　　
　　Inherited;
　　
　　这个词的中文意思是“继承”。我们暂时不要去涉及到太过复杂的OOP概念，只要
知道这条语句的功能就是了。它的功能是调用基类中相当的虚拟方法中的代码。例如，
你如果使用以下代码：
　　
　　var
　　　AObject: TNewClass;
　　begin
　　　AObject := TNewClass.create;
　　　AObject.One;
　　　AObject.free;
　　end;
　　
　　那么程序将弹出两次对话框，第一次是调用TMyclass类中的One方法，第二次才是
TNewClass.One方法中的代码。
　　重载技术使得我们不但可以在派生类中添加基类没有的数据和方法，而且可以非常
方便地继承基类中原有方法的代码，只需要简单地加入Inherited就可以了。如果你不
加入Inherited语句，那么基类的相应方法将被新的方法覆盖掉。但是必须注意，重载
只有在基类的方法被标志为Virtual时才能进行，而且重载的方法必须具有和虚拟方法
完全相同的参数类型。
　　虚拟方法还有一种特例，即抽象方法：
　　
　　procedure One;override;abstract;
　　
　　在One方法后面，不但有override关键字，还多了一个abstract关键字（意为抽
象）。这种方法称为抽象方法（在C++中称为纯虚拟函数）。含有抽象方法的类称为抽
象类。抽象方法的独特之处在于，它只有声明，而根本没有实现部分，如果你企图调用
一个对象的抽象方法，你将得到一个异常。只有当这个类的派生类重载并实现了该方法
之后，它才能够被调用。(在C++中，甚至根本就不能建立一个抽象类的实例。)
　　既然如此，那么这种抽象方法又有什么用呢？这个问题我们将在接下来的“多态”
部分进行讨论。
　　
　　1.3 多态
　　
　　多态相对来说比较复杂一点。不过不要担心，它的内容比较少，而且如果以前的知
识掌握得比较稳固的话，多态的概念是水到渠成的。
　　先来讨论一下类型的兼容性问题。下面是一个例子：
　　
　　type
　　　TAnimal = Class
　　　　Procedure Voice;virtual;
　　　　...
　　　end;
　　
　　　TDog = Class(TAnimal)
　　　　Procedure Voice;Override;
　　　　...
　　　end;
　　
　　implementation
　　
　　Procedure TAnimal.Voice;virtual;
　　Begin
　　　PlaySound('Anim.wav',0,snd_Async);
　　End;
　　
　　Procedure TDog.Voice;virtual;
　　Begin
　　　PlaySound('Dog.wav',0,snd_Async);
　　End;
　　
　　TDog类继承了TAnimal类，并重载了其中的Voice方法。PlaySound是一个WIN API函
数，可以播放指定的wav文件。（这个函数的定义在MMSystem.pas文件中可以找到。）
　　先看这段代码：
　　
　　var
　　　MyAnimal1, MyAnimal2: TAnimal;
　　Begin
　　　MyAnimal1 := TAnimal.Create;
　　　MyAnimal2 := TDog.Create;
　　　...
　　
　　在实现部分的第一行中，建立了一个TAnimal类型的对象，并将其赋予TAnimal类型
的变量MyAnimal1。这是很正常的事。但在第二行中，建立了一个TDog类型的对象，并
将其赋予了TAnimal类型的变量MyAnimal2。这看上去令人吃惊，但这些代码是完全合法
的。
　　众所周知，Pascal以及Object Pascal是一种类型定义严格的语言，你不能将某个
类型的值赋予不同类型的变量，例如将一个整型值赋予布尔型变量，将会导致出错。但
是，这个规则在涉及到OOP领域时，出现了一个重要的例外，那就是：可以将一个子类
的值赋予一个父类类型的变量。但倒过来却是不行的，一个父类的值决不能赋予一个子
类类型的变量。
　　如果将这个原则放到现实世界中，那就很容易理解了：“狗”继承自“动物”，因
为狗也是一种动物。所以可以将一个“狗”类型的值赋予“动物”类型的变量，因为
“狗”具有“动物”的一切特征。但反过来，“动物”不具有“狗”的所有特征，因此
反向赋值是不行的。
　　那么，这种兼容规则在编程中究竟有什么用处呢？
　　请注意下面这段代码：
　　
　　var
　　　MyAnimal1, MyAnimal2: TAnimal;
　　Begin
　　　MyAnimal1 := TAnimal.Create;
　　　MyAnimal2 := TDog.Create;
　　　MyAnimal1.Sound;
　　　MyAnimal2.Sound;
　　　...
　　
　　MyAnimal1和MyAnimal2都是TAnimal的变量，而且都调用了Sound方法。但是，执行
的结果是完全不同的：前者执行的是TAnimal.Voice的代码，而后者执行的是
TDog.Voice的代码！其原因很简单，因为MyAnimal1被赋予了TAnimal类型的对象，而
MyAnimal2被赋予了TDog类型的对象。也就是说，一个TAnimal类型的变量，当它调用
Sound方法时，所执行的代码是不确定的：可能执行TAnimal.Voice的代码，也可能执行
的是TDog.Voice的代码，取决于它当时引用的是一个什么样的对象。
　　再看：
　　
　　MyAnimal1 := TAnimal.Create;
　　MyAnimal1.Sound;
　　MyAnimal1.free;
　　MyAnimal1 := TDog.Create;
　　MyAnimal1.Sound;
　　...
　　
　　同一个变量MyAnimal1，在第一次调用Sound方法时，执行的是TAnimal.Voice的代
码，在第二次时执行的是TDog.Voice的代码。MyAnimal1.Sound这行代码不需要变化，
程序可以根据不同的情况赋予该变量不同的对象，从而使它执行不同的代码。这就是多
态的定义。

　　这个非常重要的特点大大地增加了代码的可复用性。如前所述，只需要简单地写下
一行代码，就可以让程序执行不同的功能，因为这个虚拟方法同TAnimal的任何派生类
都是兼容的，甚至连那些还没有编写出来的类也是一样。而程序员并不需要了解这些派
生类的细节。利用多态性写出来代码，还具有简洁和维护性好的特点。
　　现在我们可以回到本文的1.2节结尾处的问题了。抽象方法本身不能够做任何事
情，必须在子类中被重载并实现，才能够完成有意义的工作。但抽象方法的存在，相当
于为父类留下了一个接口，当程序将一个子类的对象赋予父类的变量时，父类的变量就
可以调用这个方法，当然此时它运行的是相应的子类中重载该方法的代码。如果没有这
个抽象方法，父类的变量就不能调用它，因为它不能调用一个只在子类中存在、而在父
类中不存在的方法！
　　
　　关于OOP的介绍就到此这止。在以上这些篇幅里，介绍的只是OOP最基本的一些概
念，让读者对OOP有一定的系统认识，也为下文的讨论打好基础　。更多、更深入的东
西等待着你自己去发掘。
　　本文已经多次强调OOP的重要性，这里还要强调一次：对OOP的掌握程度，在某种意
义上决定着你对Delphi世界的理解能力。
　　
　　2、数据库
　　
　　在相对枯燥的理论之后，我们终于要开始接触到一些比较激动人心的实际应用了。

　　数据库编程是Delphi最强大的优势之一，恐怕也很少有Delphi程序员没有接触过数
据库编程的。Delphi独特的Data-Aware构件，让很多初识Delphi的人为之目瞪口呆。不
需要写任何代码，在几分钟之内就可以做出一个相当精巧的数据库程序，而且在开发期
就可以看到运行期的结果，这真是不可思议啊！但是，Delphi强大无比的数据库开发能
力，决不仅仅限于用几个构件操纵一下DBF或是Access数据库而已。你所看到只是冰山
一角。让我们仔细说来。
　　数据库虽然家族庞大，但一般来说可以分为两种：文件型数据库和C/S型数据库。
下面分别讨论。
　　
　　2.1 文件型数据库
　　所谓文件型数据库，顾名思义，是基于文件的（file-based），数据被按照一定格
式储存在磁盘里，使用时由应用程序通过相应的驱动程序甚至直接对数据文件进行读
取。也就是说，这种数据库的访问方式是被动式的，只要了解其文件格式，任何程序都
可以直接读取，这样就使得它的安全性相当糟糕。同时，在蓬勃兴起的网络应用，文件
型数据库更是难有用武之地：效率低下，不支持很多SQL命令，不支持视图、触发器、
存储过程等高级功能，等等。这些特点决定了它不适合大型的工程。
　　最为大家所熟悉的文件型数据库可能就是DBF（DBase/Foxbase/Foxpro）数据库，
在DOS时代风靡一时，相信很多人都有过抱着一本手册苦背Foxbase命令的回忆吧！其特
点是，每个Table或Index都是一个独立的文件，使用相当简单，性能还可以，安全性非
常的差，但应用非常广泛（主要是DOS时代遗留下来的，哪个单位没有两个用这种东东
编出来的老古董程序呢？）。它在今天还能占有一席之地，其主要原因之一是，正因为
简单和使用广泛，使得对它的访问是最容易的，甚至根本无需第三方的接口，就可直接
对其进行字节级的读取　。
　　除此之外，还有著名的Access数据库。这是MS Office里的构件之一，和DBF数据库
不同，所有的文件都被整合在一个.mdb文件中，这样就避免了数据库变大之后管理上带
来的麻烦。同时它还提供密码保护功能，安全性比DBF数据库要好很多。Access数据库
除了一般的文本数据之外，还擅长于对多媒体数据的处理，在对声音、图像乃至基于
OLE的对象进行处理时，令DBF数据库望尘莫及。随着微软战略的步步胜利，Access数据
库也不断发展，凭借着优秀的性能和与MS Office的无缝结合，早已超越DBase系列，成
为现今最强大的文件型数据库了。
　　Delphi中附带的Paradox也是一种文件型数据库。它是Inprise公司自己的产品。因
此和Inprise的系列开发工具配合得很不错。它支持密码保护，支持标准的SQL，性能也
还不错，但是应用就不那么广泛了。和DBF数据库一样，它的每一个Table都是一个独立
的文件，因此也有同样的管理问题。
　　上文说到可以对文件型数据库直接读取，但实际编程中很少有人这么做。因为再简
单的数据库其实也是相当复杂的，一步步分析它的格式，从底层实现所有的数据库应
用，如果都要程序员去写的话，可能会把人累死。所以数据库的开发商将这些访问代码
封装起来，向程序员开放，程序员只需要调用相应的接口就可以了。
　　以DBF为例，使用DBase/Foxbase/Foxpro系列开发工具，可以用它自己的语法开发
出应用程序。其中对DBF文件的具体操作被封装了。对于Access数据库，微软公布了一
个DAO（Database Access Object），由一系列的DLL文件组成，封装了对.mdb文件的访
问。使用VB的读者可能对DAO比较熟悉，只要在VB中嵌入DAO对象，就可以非常方便地访
问Access数据库了。ODBC（Open DataBase Connection，开放数据库互连）也是一种封
装，用意在于向开发人员提供一个统一的接口，通过这个接口可以访问任何支持ODBC的
数据库，只要该数据库提供了相应的ODBC驱动。从这一点上来说，ODBC是一种更加高级
的封装。目前几乎所有的主流的数据库都能被ODBC所支持。打开你的Windows的控制面
板，就可以看到ODBC的图标。
　　用Delphi写数据库程序的人免不了要同BDE打交道。BDE（Borland Dasebase
Engine，Borland数据库引擎）是一个和ODBC类似的东西，Borland/Inprise本来企图用
它来统一数据库接口。但后来Inprise在和微软的战争中败下阵来（ODBC是微软搞出来
的），它又不肯放弃BDE，而是将其捆绑在Delphi/C++ Builder系列开发工具中，结果
好象变成这些开发工具的一种附属品了。
　　用BDE开发数据库程序相当容易。许多Delphi教科书在写到数据库开发这一章时，
总是告诉你先在BDE中为某个DBF或Paradox数据库设置一个别名，然后往窗体上放一个
TTable构件，然后将其DatabaseName指向相应的别名……然后，这个数据库中某个表的
内容就在相应的Data-Aware构件中显示出来了。但是它们具体是怎么工作的呢？
　　Delphi对数据库进行访问时，事实上通过了很多层次的连接。如下图：
　　
　　图1
　　DataAware构件-DataSource构件-DataSet构件-BDE-数据库
　　
　　从这个图可以看出，BDE负责与具体的数据库打交道，而Dataset构件与BDE相连，
DataSource构件与Dataset构件相连，最后才连接到显示具体数据的Data-Aware构件。
在Delphi的构件面板上，Data Access页面中的构件一般属于DataSet构件，例如
TTable、TQuery，只要指定它们的DatabaseName属性，就可以将它们与某个数据库建立
连接。在Data Control页面中的构件一般是Data-Aware构件，例如TDBGrid，TDBEdit，
TDBImage。它们的作用看上去与一般的Delphi构件相似，不同之处在于，可以通过一个
DataSource构件作为中介，与DataSet构件相连，并自动显示相应的数据。
　　用Delphi的数据库构件建立一个应用程序是如此之方便，但是如果深入下去，会发
现事情并不简单。你可以尝试自己编写代码，访问数据库中字段，而不是通过
Data-Aware构件由用户来编辑。如何做到这一点呢？秘密在于Field构件。
　　可以说，Field构件是Delphi数据库应用程序的基础　。当打开一个DataSet构件
时，相应的数据会被读取，并储存在TTable或TQuery构件的Fields属性中。这个属性被
定义为Field数组。通过直接访问数组，可以使用它们，例如：
　　
　　Table1.Fields[0].AsInteger;
　　
　　这段代码访问了Table1中当前记录的第一个字段，该字段的类型为Integer。
　　也可以通过使用FieldbyName属性来使用它们：
　　
　　Table1.FieldbyName('Last Name').AsString;
　　
　　这段代码访问了Table1中当前记录的名为Last Name的字段，该字段的类型为
String。

　　事实上，Data-Aware构件就是通过访问DataSet构件的Fields属性来使用数据的。
弄明白了这一点之后，你自己也可以尝试改写一个常规的显示构件，使之具有
Data-Aware的性质。其实，大多数使用Delphi的数据库高手并不喜欢使用Data-Aware构
件，因为Data-Aware构件远不用常规的构件来得灵活。DataSet构件除了Fields属性之
外，还具有数目众多的特殊属性、方法和事件，足以应付从小型文本数据库到大型网络
数据库的所有应用。本文不拟一一讨论它们，如果读者能将它们的运用烂熟于心的话，
可以说应付数据库编程就不会有多大问题了。
　　请将注意力再次集中到图1。在图1的最后一环，可以看到BDE连接到了具体的数据
库。其实，在这一环中，也是有几个层次的。理论上来说，BDE可以连接任何类型的数
据库。对于一些比较简单的数据库，例如ASCII（纯文本型的数据库）、dBase以及
Delphi自己的Paradox，BDE可以直接访问。另外它也可以通过一些相应的驱动，访问特
定的数据库，例如通过DAO访问Access数据库。对于不能直接支持的数据库，BDE还可以
连接到ODBC，通过ODBC进行访问，虽然这样效率比较低。
　　这种性质决定了BDE是一个相当庞大的东西。使用了BDE的Delphi程序，必须有BDE
才能工作，所以必须同BDE一起发布。这样往往造成这样一种情况：只有几百K的应用程
序，在将整个BDE加入之后，体积将近10M！这对于以轻薄短小为长的文件型数据库，简
直是一个致命的弱点。而且由于BDE要兼容太多的数据库，本身也有不稳定的毛病，往
往出现令人头疼的问题。同时，通过安装程序安装BDE驱动和设置数据库别名也是一件
很麻烦的事情，这一切使得BDE在Delphi程序员中很不受欢迎。在网上的Delphi技术论
坛里，经常可以看到对BDE的一片咒骂之声……那么，有什么办法可以绕过BDE吗？
　　有的。目前来说，至少有以下三种方法：
　　(1) 使用第三方构件。
　　Inprise自己也很早就意识到了BDE的问题，虽然他们不肯放弃BDE，但是从Delphi3
起，仍然对程序员提供了一个不错的选择：创建自定义的DataSet构件。Delphi的开发
者们把所有有关BDE的东西从TDataSet类中移走，放入了新的TBDEDataSet类
（TBDEDataSet类是TDataSet类的子类）。TDataSet类被重新构造，其核心功能被虚拟
化。因此，你只需要从TDataSet类派生一个自己的新类，并重载一些指定的虚拟方法
（用以访问具体的数据库），你就可以得到一个自己的DataSet构件。它与BDE完全无
关，但可以象Delphi自己的DataSet构件一样被使用，例如，访问其Fields属性，乃至
与Delphi的Data-Aware构件一起工作！

　　于是出现了大量的第三方构件，它们可以访问某种特定的数据库。下面是一些比较
常见的访问文件型数据库或ODBC的第三方构件：
　　
　　
　　表2

名称 　支持的数据库类型
Diamond 　Access
Halcyon 　DBase/Foxpro
Apollo 　DBase/Foxpro
mODBC 　任何ODBC数据库
ODBC Express 任何ODBC数据库


　　这些控件被广泛使用，在国内，就作者所知，财智家庭理财软件使用了Diamond，
而“追捕”（一个显示指定IP的地址位置的共享软件）使用了Halcyon。在使用这些第
三方构件之后，软件终于可以“轻装上阵”，再也不用为BDE头疼了。
　　(2) 使用ADO。
　　在Delphi5中，Inprise终于提供了一个比较彻底的解决方法，那就是ADO构件。从
原理上来说，ADO与上述的第三方构件并无多大区别，只是它是Inprise官方开发的；同
时，它连接的不是某个具体的数据库，而是微软提供的ADO对象。
　　ADO（ActiveX Data Object，ActiveX数据对象）是微软提出的新标准，从理论上
来，能够支持任何类型的数据库（甚至包括流式数据）。微软力图将它树为新的统一数
据库接口，吹嘘了它的许多优点。Inprise一直是微软不共戴天的竞争对手，对微软的
标准嗤之以鼻（BDE即是一例），但是由于种种原因，Inprise终于承认了ADO。平心而
论，用ADO来取代BDE的确是一个不错的解决方案，而且在Delphi中使用ADO也相当方
便。从形势看，ADO应该是未来的方向。但是，ADO本身也是相当大的。
　　(3) 从最底层开发一个完整的数据库引擎。
　　这是最彻底的办法。彻底抛弃Delphi的数据库支持，从字节开始，开发自己的数据
库。这种方法有其好处：第一，不用考虑兼容性问题，例如不用去考虑用户的数据库文
件是Access 97格式还是Access 2000格式的；第二，可以在性能上达到最充分的优化，
因为不需要通过任何通用接口，而是直接对磁盘文件进行操作，这对于一些对性能要求
苛刻的程序是很有用的；第三，能够最大限度地减少冗余代码，因为这种数据库往往是
特定格式的，而且只需要执行一些特定的操作，访问代码当然要比通用数据库精简得
多。但这种方法的负面问题也显而易见，那就是庞大的工作量。再简单的数据库也是相
当复杂的，从最底层实现一个完整的数据库引擎，往往需要几千行代码，以及耐心和经
验。
　　虽然听起来有些极端，但这样做的也不乏其人。著名的Foxmail就是使用了自定义
的数据库格式来储存信件、地址本等有关信息。另一个共享软件“电子书库”也使用了
自定义的.srm格式。作者开发的iCompanion（网络伴侣）也是使用自定义格式来储存网
络记录的。
　　限于篇幅，这里就不再对具体的程序进行详细的分析了。要补充的一点是，作者曾
使用Diamond开发过Rich Explorer，这是一个专门用于浏览著名的大富翁论坛的离线数
据库（Access格式）的阅读器。在作者的主页上，可以找到Rich Explorer的全部源代
码，它完整地展示了一个使用第三方构件访问特定数据库的程序（没有使用Data-Aware
控件），代码也比较简单，适合于初学者分析，有心的读者不妨作为参考。
　　
　　2.2 C/S型数据库
　　C/S（Client/Server，客户机/服务器）型数据库是当前数据库应用的主流。
　　与文件型数据库不同的是，C/S型数据库应用程序由两个部分组成：服务器和客户
机。服务器指数据库管理系统（Database Manage System，DBMS），用于描述、管理和
维护数据库的程序系统，是数据库系统核心组成部分，对数据库进行统一的管理和控
制。客户机则将用户的需求送交到服务器，再从服务器返回数据给用户。
　　C/S型数据库非常适合于网络应用，可以同时被多个用户所访问，并赋予不同的用
户以不同的安全权限。C/S型数据库支持的数据量一般比文件型数据库大得多，还支持
分布式的数据库（即同一数据库的数据库位于多台服务器上）。同时，C/S型数据库一
般都能完善地支持SQL语言（所以也被称作SQL数据库）。这些特性决定了C/S型数据库
适合于高端应用。

　　常见的C/S型数据库有著名的Oracle, Sybase, Informix, 微软的Microsoft
SQLserver, IEM的DB2，以及Delphi自带的InterBase，等等。
　　C/S型数据库涉及到非常多的高级特性，是Delphi中，也是整个计算机领域中最大
的应用之一。由于本期附录中已有专文讨论，本文就不拟详细介绍了。
　　随着技术的不断更新，C/S型的结构也开始逐渐被多层（Multi-Tiered）数据库模
型所取代。
　　上面说到，C/S型数据库程序由服务器和客户机两个部分组成，因此被称为双层
（two-tiered）模型。文件型数据库程序则被称为单层（single-tiered）模型。单层
模型是最原始的数据库模型。后来程序员们将数据库转移到一个强大的中央服务器上，
让它为多个功能较弱的客户机提供服务，这样双层模型出现了。双层模型在金融、电
力、通信等领域被广泛使用，极大地推动了网络数据库的发展。但是，双层模型也逐渐
暴露出其不足的一面。在这种情况下，出现了三层模型：应用程序中的数据模块部分被
分离出来，转移到一个单独的服务器上，成为独立的一层。三层和三层以上的模型，统
称为多层模型。
　　` 简言之，三层模型由以下三个层次组成：
　　
　　客户机-应用程序服务器-数据库服务器
　　
　　用户的请求首先通过客户机向应用程序服务器发出，应用程序服务器再向数据库服
务器发出具体的数据访问命令（一般是SQL），数据库服务器返回的数据被应用程序服
务器重新组织之后返回给客户机。
　　可以看出，三层模型是双层模型的扩展。目前我们无需了解三层模型的所有技术细
节，以及它对于双层模型的优势，只需要大致理解这个模型的结构就可以了。
　　B/S模型无疑是当前最为流行的多层数据库模型之一。也许你已经听说过B/S这个名
词，它是Brower/Server（浏览器/服务器）的缩写。Brower是指IE/Netscape这样的浏
览器，Server包括数据库服务器和应用程序服务器。用户通过浏览器发出某个请求，通
过应用程序服务器-数据库服务器之间一系列复杂的操作之后，返回相应的Html页面给
浏览器。
　　是不是觉得十分熟悉？对了，其实这就是大家再熟悉不过的Internet上的WEB数据
库，当然它也可以用于局域网。它实际上可以说是一种最常见的多层模型。
　　在对数据库的发展进行回顾之后，我们终于赶上了最流行的步伐。但是，也许有人
在这里却感到泄气了。因为他听说现在的WEB数据库编程，是Perl、ASP、PHP、JAVA这
些语言的天下。难道我们一直忠实追随的Delphi，在面对当代最流行的Web数据库的时
候，竟然面临淘汰的命运？
　　不，不是的。其实Delphi对Web数据库的开发提供了非常良好的支持，特别是依据
强大的数据库支持和可视化编视的特点，它有着其他语言不可比拟的优势。
　　下面的内容将集中于用Delphi开发Web数据库。
　　首先要从Web本身讲起。平时我们浏览的Web页面，一般可以分为两种。一种是静态
页面，这种页面是文本格式的html文件。但是，要响应用户的不同需求，从而反馈给用
户不同的页面，就必须使用动态页面技术了。例如，根据用户输入的名字，迅速在数据
库中查找到相应的数据，并动态生成一个页面返回给用户。
　　怎样实现动态页面技术呢？最早的一种方法是CGI（Common Gateway Interface，
通用网关接口）。这种接口允许浏览器发送和接收数据，并且基于应用程序的命令行进
行输入和输出。当浏览器发出指向应用程序的请求时，Web服务器会自动启动该程序，
并在浏览器和应用程序之间传递输入和输出的数据。实现CGI的语言有很多种，其中比
较流行的是Perl。另外，还有一种特殊的WinCGI。WinCGI与普通CGI的区别是，它通过
INI文件来代替命令行参数作为输入输出，这主要是为Visual Basic设计的，因为VB不
能访问环境变量。Delphi对这两种CGI都提供了很好的支持，可以编写出非常复杂的CGI
程序。
　　第二种方法是使用Web服务器内置的API接口。用这种接口编写出来的Dll文件，被
Web服务器装载到自己的内存空间中，当服务器接收到相应的页面请求时，它将启动一
个新的线程来执行Dll中的相应代码。由于不需要执行外部的EXE文件，这种程序的速度
非常快。这种API主要有ISAPI（Internet Server API）和NSAPI（Netscape Server
API），其中前者已经成为事实上的标准。Delphi对这两种API也提供了很好的支持。提
得一提的是，Delphi的C/S版提供了一个通用的类框架，消除了CGI、WinCGI和ISAPI之
间的区别，这样，我们可以轻松地将一个应用程序在这三者之间转换。
　　还有一种是Web服务器内置的脚本语言，可以被简单地嵌入html文件，通过Web服务
器的解释执行来产生动态页面。著名的ASP、PHP、JSP都属于此类。这看起来和Delphi
没有什么关系，但事实上，Delphi也能提供对ASP的强力支持！ASP的初学者可能会把注
意力都集中在它的脚本语言上，其实ASP是由三部分组成的：脚本、组件和html。光是
掌握脚本和ASP原有的组件特性是远远不够的，只有自行开发组件，才能实现真正复
杂、高效的应用。
　　Delphi就非常适合开发这种组件。国内著名大富翁论坛，就是基于Delphi+ASP的成
功例子，同时它还公布了所有的源代码，可供借。
　　让我们先建立一个程序。这个程序和以往的Delphi不同，要求删除所有的窗体和多
余的代码，最后只剩下这么一段：
　　
　　program CgiDate;
　　
　　{$APPTYPE CONSOLE} //这行编译器指令表示这是一个控制台程序，不需要窗体，
在终端窗口中输出
　　
　　uses
　　　sysutils;
　　
　　begin
　　　writeln('HTTP/1.0 200 OK');
　　　writeln('CONTENT-TYPE: TEXT/HTML');
　　　writeln;
　　　writeln('<html> <head>');
　　　writeln(' <title>Time</title>');
　　　writeln('</head><body>');
　　　writeln('<h1>Time at this site</h1>');
　　　writeln('<hr>');
　　　writeln('<h3>');
　　　writeln(formatdatatime('"Today is " dddd,mmmm d,yyyy,' + '"<br> and
the time is "hh:mm:ss AM/PM',now));
　　　writeln('<h3>');
　　　writeln('<hr>');
　　　writeln('</body></html>');
　　end;
　　
　　编译后，将该程序置于Web服务器下的有scripts权限的子目录中，并用浏览器访问
它，就可以得到一个关于当前时间和日期的页面。
　　分析一下这段代码。格式很简单，都是用writeln生成标准输出。首先的两行生成
html的描述，中间空一行，接下来的代码生成了一个完整的html文件。这个文件被返回
给浏览器并显示出来。与静态页面不同是，有一行html文本是通过formatdatatime函数
动态生成的，因此根据当前时间的不同会有不同的显示。
　　这就是一个最简单的CGI程序。虽然简单，但已经可以看出CGI程序的基本工作原理
：通过标准输入输出产生动态的html页面。
　　在这个基础之上，可以方便地实现对数据库的访问，并生成相应的html。
　　下面是一个例子：
　　
　　var:
　　　Table1:TTable;
　　Begin
　　　Showheader; // Showheader过程生成html文件的头部，代码与上例相似
　　　Table1 := TTable.create(nil);
　　　Try
　　　　Table1.Databasename := 'DBDEMOS';
　　　　Table1.tablename := 'Employee.db';
　　　　Table1.indexname := 'Byname';
　　　　Table1.open;
　　　　ShowTabindex; //显示表中的列
　　　Finally
　　　　Table1.close;
　　　　Table1.free;
　　　End;
　　　Writeln('</body></html>');
　　End;
　　
　　这段代码动态建立了一个Table对象，并将它与DBDEMOS数据库中的表Employee.db
相连（当然这些必须先在BDE中设置）。ShowTabindex过程显示了该表中的两个列：
　　
　　procedure ShowTabindex;
　　begin
　　　table1.frist;
　　　writeln('<ul>');
　　　while not table1.eof do
　　　begin
　　　　writeln(format('<li>s%s%',[table1.fieldbyname('FirstName').AsString,
table1.fieldbyname('LastName').AsString]);
　　　　Table1.Next;
　　　End;
　　　Writeln('</ul>');
　　End;
　　
　　ShowTabindex函数遍历了整个表，并将所有的FirstName和LastName字段打印出
来。

　　在此基础之上，可以产生复杂的动态页面，实现对数据库的各种操作。当然，实践
中的问题决不仅仅这么简单，例如，读取有关的环境变量，要使用特殊的
GetEnvironmentVariable变量，生成相应的URL，需要相应的http知识，产生供用户提
交请求的页面，需要了解html表单的格式……但是，本文的目的不在于探讨技术细节，
而是着重于基本概念和原理的了解，因此不再详述，请读者自己深入学习。
　　上面已经说过，在Delphi中可以轻松地将一个应用程序在CGI、WinCGI和ISAPI之间
转换。上面这两个例子生成的是EXE文件，因此是CGI（或WinCGI，取决于使用环境变量
还是INI文件）程序。如果要改成ISAPI方式，除了要编译成DLL文件之外，输入输出的
部分也需要进行修改，实现三个特殊的函数：
　　GetExtensionversion
　　TerminateExtension
　　HttpExtensionProc
　　Web服务器在装载DLL、卸载DLL和请求DLL时会分别调用这三个函数，程序可以通过
它们与浏览器进行交互。具体的实现，这里也不详述了。
　　
　　
　　通过以上几个专题的学习，相信读者对Delphi的了解更深了一层。本文旨在帮助读
者理解一些相对比较高级的概念和原理，很多地方只是介绍了最基础的东西，没有展
开。如果深入下去，将会产生很多章庞大的内容。因此，读者在入门之后，需要更多的
自己的努力。