| Description |
The Constructor keyword defines a constructor procedure Name for a class.
When creating an object, you call a Constructor method of the class, not the object:
objectName := ClassName.Create(parms);
The Name for the constructor is normally Create, but is not restricted to this. It is very wise to keep to this name.
An object may be constructed with or without arguments (see the example).
Constructors may be defined in the public or published sections of the class definition.
You may have multiple constructors, but by doing so, you can only define one of these as Published. With multiple constructors, each must be suffixed with the Overload directive, as required by delphi.
When implementing the constructor procedure, normally called Create, you should make it a habit of calling the parent constructor, for example
constructor Create;
inherited;
...
This ensures that the resulting object is a safe instantiated instance of this parent class, even if the parent is TObject, which does nothing in its constructor. The sample code illustrates this plain variety of Inherited plus the version where the parent constructor has arguments.
|
|
| Related commands |
| Class |
|
Starts the declaration of a type of object class |
| Destructor |
|
Defines the method used to destroy an object |
| Function |
|
Defines a subroutine that returns a value |
| Inherited |
|
Used to call the parent class constructor or destructor method |
| Object |
|
Allows a subroutine data type to refer to an object method |
| Procedure |
|
Defines a subroutine that does not return a value |
| TObject |
|
The base class type that is ancestor to all other classes |
|
|
|
| Example code : Examples of constructors with and without arguments |
// Full Unit code.
// -----------------------------------------------------------
// You must store this code in a unit called Unit1 with a form
// called Form1 that has an OnCreate event called FormCreate.
unit Unit1;
interface
uses
Forms, Dialogs, Classes, Controls, StdCtrls;
type
// Define a parent class, base on TObject by default
TFruit = class
public
name : string;
Constructor Create; overload; // This constructor uses defaults
Constructor Create(name : string); overload;
end;
// Define a descendant types
TApple = class(TFruit)
public
diameter : Integer;
published
Constructor Create(name : string; diameter : Integer);
end;
// The class for the form used by this unit
TForm1 = class(TForm)
procedure FormCreate(Sender: TObject);
end;
var
Form1: TForm1;
implementation
{$R *.dfm} // Include form definitions
// Create a fruit object - parameterless version
constructor TFruit.Create;
begin
// Execute the parent (TObject) constructor first
inherited; // Call the parent Create method
// Now set a default fruit name
self.name := 'Fruit';
end;
// Create a fruit object - parameterised version
constructor TFruit.Create(name: string);
begin
// Cannot execute the parent constructor - parms differ
// And save the fruit name
self.name := name;
end;
// Create an apple object
constructor TApple.Create(name: string; diameter : Integer);
begin
// Execute the parent (TFruit) constructor first
inherited Create(name); // Call the parent method
// Now save the passed apple diameter
self.diameter := diameter;
end;
// Main line code
procedure TForm1.FormCreate(Sender: TObject);
var
fruit : TFruit;
banana : TFruit;
apple : TApple;
begin
// Create 3 different fruit objects
fruit := TFruit.Create;
banana := TFruit.Create('Banana');
apple := TApple.Create('Pink Lady', 12);
// See which of our objects are fruits
if fruit Is TFruit then ShowMessage(fruit.name +' is a fruit');
if banana Is TFruit then ShowMessage(banana.name +' is a fruit');
if apple Is TFruit then ShowMessage(apple.name +' is a fruit');
// See which objects are apples
if fruit Is TApple then ShowMessage(fruit.name +' is an apple');
if banana Is TApple then ShowMessage(banana.name +' is an apple');
if apple Is TApple then ShowMessage(apple.name +' is an apple');
end;
end.
|
Fruit is a fruit
Banana is a fruit
Pink Lady is a fruit
Pink Lady is an apple
|
|