Another way to cast an object reference is to use the name of the target class in a conventional type cast, similar to a function call. This style of type cast does not check that the cast is valid, so use it only if you know it is safe, as shown in Example 2-3.
Example 2-3: Using Static Type Casts
var
Account: TAccount;
Checking: TCheckingAccount;
begin
Account := Checking; // Allowed
Checking := Account; // Compile-time error
Checking := Account as TCheckingAccount; // Okay
Account as TForm; // Raises a runtime error
Checking := TCheckingAccount(Account); // Okay, but not recommended
if Account is TCheckingAccount then // Better
Checking := TCheckingAccount(Account)
else
Checking := nil;
Fields
A field is a variable that is part of an object. A class can declare any number of fields, and each object has its own copy of every field declared in its class and in every ancestor class. In other languages, a field might be called a data member, an instance variable, or an attribute. Delphi does not have class variables, class instance variables, static data members, or the equivalent (that is, variables that are shared among all objects of the same class). Instead, you can usually use unit-level variables for a similar effect.
A field can be of any type unless the field is published. In a published section, a field must have a class type, and the class must have runtime type information (that is, the class or an ancestor class must use the $M directive). See Chapter 3 for more information.
When Delphi first creates an object, all of the fields start out empty, that is, pointers are initialized to nil, strings and dynamic arrays are empty, numbers have the value zero, Boolean fields are False, and Variants are set to Unassigned. (See NewInstance and InitInstance in Chapter 5 for details.)
A derived class can declare a field with the same name as a field in an ancestor class. The derived class''''s field hides the field of the same name in the ancestor class. Methods in the derived class refer to the derived class''''s field, and methods in the ancestor class refer to the ancestor''''s field.
Methods
Methods are functions and procedures that apply only to objects of a particular class and its descendants. In C , methods are called "member functions." Methods differ from ordinary procedures and functions in that every method has an implicit parameter called Self, which refers to the object that is the subject of the method call. Self is similar to this in C and Java. Call a method the same way you would call a function or procedure, but preface the method name with an object reference, for example:
Object.Method(Argument);
A class method applies to a class and its descendants. In a class method, Self refers not to an object but to the class. The C term for a class method is "static member function."
You can call a method that is declared in an object''''s class or in any of its ancestor classes. If the same method is declared in an ancestor class and in a derived class, Delphi calls the most-derived method, as shown in Example 2-4.
Example 2-4: Binding Static Methods
type
TAccount = class
public
procedure Withdraw(Amount: Currency);
end;
TSavingsAccount = class(TAccount)
public
procedure Withdraw(Amount: Currency);
end;
var
Savings: TSavingsAccount;
Account: TAccount;
begin
...
Savings.Withdraw(1000.00); // Calls TSavingsAccount.Withdraw
Account.Withdraw(1000.00); // Calls TAccount.Withdraw
An ordinary method is called a static method because the compiler binds the method call directly to a method implementation. In other words, the binding is static. In C this is an ordinary member function, and in Java it''''s called a "final method." Most Delphi programmers refrain from using the term static method, preferring the simple term, method or even non-virtual method.
A virtual method is a method that is bound at runtime instead of at compile time. At compile time, Delphi uses the declared type of an object reference to determine which methods you are allowed to call. Instead of compiling a direct reference to any specific method, the compiler stores an indirect method reference that depends on the object''''s actual class. At runtime, Delphi looks up the method in the class''''s runtime tables (specifically, the VMT), and calls the method for the actual class. The object''''s true class might be the compile-time declared class, or it might be a derived class--it doesn''''t matter because the VMT provides the pointer to the correct method.
To declare a virtual method, use the virtual directive in the base class, and use the override directive to provide a new definition of the method in a derived class. Unlike in Java, methods are static by default, and you must use the virtual directive to declare a virtual method. Unlike in C , you must use the override directive to override a virtual method in a derived class.
文章整理：西部数码--专业提供域名注册、虚拟主机服务
http://www.west263.com
以上信息与文章正文是不可分割的一部分,如果您要转载本文章,请保留以上信息，谢谢!
