9428
Uploader: Stefan Walther
Company: bluestep.com IT-Consulting
Reference: Ray Lischner - O''''Reilly
Question/Problem/Abstract:
Delphi''''s support for object-oriented programming is rich and powerful. In addition to traditional classes and objects, Delphi also has interfaces (similar to those found in COM and Java), exception handling, and multithreaded programming. This chapter covers Delphi''''s object model in depth. You should already be familiar with standard Pascal and general principles of object-oriented programming.
Answer:
Reprinted with permission from O''''Reilly & Associates
Delphi in a Nutshell
By Ray Lischner
1st Edition March 2000
1-56592-659-5, Order Number: 6595
600 pages, $24.95
Get the book at amazon.com
Classes and Objects
Think of a class as a record on steroids. Like a record, a class describes a type that comprises any number of parts, called fields. Unlike a record, a class can also contain functions and procedures (called methods), and properties. A class can inherit from another class, in which case it inherits all the fields, methods, and properties of the ancestor class.
An object is a dynamic instance of a class. An object is always allocated dynamically, on the heap, so an object reference is like a pointer (but without the usual Pascal caret operator). When you assign an object reference to a variable, Delphi copies only the pointer, not the entire object. When your program finishes using an object, it must explicitly free the object. Delphi does not have any automatic garbage collection (but see the section "Interfaces," later in this chapter).
For the sake of brevity, the term object reference is often shortened to object, but in precise terms, the object is the chunk of memory where Delphi stores the values for all the object''''s fields. An object reference is a pointer to the object. The only way to use an object in Delphi is through an object reference. An object reference usually comes in the form of a variable, but it might also be a function or property that returns an object reference.
A class, too, is a distinct entity (as in Java, but unlike C++). Delphi''''s representation of a class is a read-only table of pointers to virtual methods and lots of information about the class. A class reference is a pointer to the table. (Chapter 3, Runtime Type Information, describes in depth the layout of the class tables.) The most common use for a class reference is to create objects or to test the type of an object reference, but you can use class references in many other situations, including passing class references as routine parameters or returning a class reference from a function. The type of a class reference is called a metaclass.
Example 2-1 shows several class declarations. A class declaration is a type declaration that starts with the keyword class. The class declaration contains field, method, and property declarations, ending with the end keyword. Each method declaration is like a forward declaration: you must implement the method in the same unit (except for abstract methods, which are discussed later in this chapter).
type
TAccount = class
private
fCustomer: string; // name of customer
fNumber: Cardinal; // account number
fBalance: Currency; // current account balance
end;
TSavingsAccount = class(TAccount)
private
fInterestRate: Integer; // annual percentage rate, scaled by 1000
end;
TCheckingAccount = class(TAccount)
private
fReturnChecks: Boolean;
end;
TCertificateOfDeposit = class(TSavingsAccount)
private
fTerm: Cardinal; // CD maturation term, in days
end;
var
CD1, CD2: TAccount;
begin
CD1 := TCertificateOfDeposit.Create;
CD2 := TCertificateOfDeposit.Create;
...
Figure 2-1 depicts the memory layout of the objects and classes from Example 2-1. The variables and their associated objects reside in read-write memory. Classes reside in read-only memory, along with the program code.
Figure 2.1
Delphi''''s object model is similar to those in other object-oriented languages, such as C++ and Java. Table 2-1 shows a quick comparison between Delphi and several other popular programming languages.
Table 2-1: Delphi Versus the World
Language Feature |
Delphi |
Java |
C++ |
Visual Basic |
Inheritance
Multiple inheritance
Interfaces
[1]
Single root class
Metaclasses
Class (static) fields
Virtual methods
Abstract (pure) virtual methods
Class (static) methods
Dynamic methods
Garbage collection
[2]
[2]
Variant
types
OLE automation
Static type-checking
[1] [2] [3] [4] [5] 下一页
[系统软件]InstallShield Express for delphi制作安装程序定… [系统软件]The GRETA Regular Expression Template Archive
[系统软件]OLE with the internet explorer [系统软件]14.5.10.1 Object creation expressions
[常用软件]InstallShield Express制作Delphi数据库安装程序 [常用软件]Firefox: What’s the next step?
[VB.NET程序]VB.Net中文教程(8) 对象(Object)基本概念 [VB.NET程序]The UDPChat Source(VB.NET)
[Delphi程序]为什么选择Delphi.Net ? [Delphi程序]《关于VisiBroker For Delphi的使用》(4)