Inheritance and Constructors
There are special rules governing constructors in inheritance.
Each class has an instance constructor called
constructor. This is an exception
to the rule that states that component names along a path in an inheritance tree must be unique. The instance constructors of the various classes in an inheritance tree, however, are fully independent of one another.
- Instance constructors of superclasses cannot be redefined in subclasses.
- Instance constructors cannot be called explicitly using
constructor( ... ).
This means that no naming conflicts can occur.
The instance constructor is called when an object is created using the command
CREATE OBJECT or with the instance operator
NEW. Since a subclass contains all of the visible attributes of its superclasses,
which can also be set by instance constructors, the instance constructor of a subclass has to ensure
that the instance constructors of all of its superclasses are also called. This requires that the instance constructor of each subclass contains a
super->constructor call of the instance
constructor of the direct superclass even if it is not explicitly declared. The only exception to this rule are direct subclasses of the root node
In superclasses without an explicitly defined instance constructor, the implicit instance constructor is called. This automatically ensures that the instance constructor of the immediate superclass is called.
When instance constructors are called, all of their non-optional input parameters must be populated as follows:
- Population in the case of
Starting from the class of the created objects, the first explicitly defined instance constructor in the associated path of the inheritance tree is respected. This is the instance constructor of the class itself or the first explicitly defined instance constructor of a superclass.
- Population in the case of super->constructor( ...
Starting from the direct superclass, the first explicitly defined instance constructor in the associated path of the inheritance tree is respected.
The interface of the first explicitly defined instance constructor is populated in the same way as with a normal method. This means that:
- If no input parameters exist, no parameters are passed.
- Optional input parameters can be populated using
- Non-optional input parameters must be populated using
If there are no explicitly defined instance constructors in the path of the inheritance tree below the root class
object, no parameters are passed.
CREATE OBJECT or
NEW and super->constructor( ...
), the next available explicit instance constructor must be considered, and, if it has an interface,
values to passed to it. The same applies to exception handling for instance constructors. When working
with inheritances, a precise knowledge of the entire inheritance tree is required. When a class at the
bottom of the inheritance tree is instantiated, it may be necessary to pass parameters to the constructor of a class that is much nearer the root node.
The instance constructor of a subclass is divided into two parts by the call
super->constructor( ... ) (demanded by the syntax). In the statements before the call, the constructor behaves like a
static method, which
means that the self reference
me-> cannot be used and the constructor does
not have access to the instance components of its class.
me-> cannot be used
and instance components addressed until after the call The statements before the call are used to determine the actual parameters for the interface of the instance constructor of the superclass. Only
static attributes or other visible data can be used for this.
When a subclass is instantiated, therefore, a nested call of the instance constructors from the subclass to the superclasses takes place. Here, however, the instance attributes can only be addressed in the lowest nesting level (which is the top superclass). When the constructors of the lower subclasses are revisited, their instance attributes can be addressed there successively too.
The methods of subclasses are not visible in constructors. If an instance constructor calls an instance method of the same class using the implicit self reference me, the method is called as it is implemented in the class of the instance constructor, and not in any redefined form that may occur in the subclass being instantiated. This is an exception to the rule that states that, when instance methods are called, the implementation is called in the class to whose instance the reference points.
Every class has a static
class_constructor. With respect to the namespace within an inheritance tree, the same applies to static constructors as to instance constructors.
The first time a subclass is addressed in a program, the static constructor is called. However, before it can be called, the static constructors of all of its superclasses must already have been executed. A static constructor may only be called once per program. Therefore, when subclass is first addressed, the system looks for the next highest superclass whose static constructor has not yet been called. It calls the static constructor of that class, followed by those of all classes between that class and the subclass addressed.