Anzeigen: Object Pascal C++
Anzeigeeinstellungen

Verschachtelte Typdeklarationen

Aus Appmethod Topics
Wechseln zu: Navigation, Suche

Nach oben zu Klassen und Objekte - Index

Typdeklarationen können in Klassendeklarationen verschachtelt werden. Verschachtelte Typen sind sowohl im .NET Framework als auch bei der objektorientierten Programmierung gebräuchlich. Mit ihrer Hilfe lassen sich Typen, die eng miteinander verwandt sind, in Gruppen zusammenfassen und Namenskollisionen vermeiden. Diese Syntax zur Deklaration von verschachtelten Typen kann auch für den Win32-Object Pascal-Compiler verwendet werden.

Verschachtelte Typen deklarieren

VerschachtelteTypdeklaration entspricht der unter Typdeklaration beschriebenen Syntax zum Deklarieren von Typen.

type
  Klassenname = class [abstract | sealed] (Vorfahrtyp)
      Elementliste

      type
         VerschachtelteTypdeklaration

      Elementliste
  end;

Der Deklarationsabschnitt für einen verschachtelten Typ wird durch das nächste Token, das kein Bezeichner ist (z. B. procedure, class oder type), oder durch ein beliebiges Sichtbarkeitsattribut abgeschlossen.

Für verschachtelte Typen und ihre Containertypen gelten die normalen Zugriffsregeln. Ein verschachtelter Typ kann auf eine Instanzvariable (Feld, Eigenschaft oder Methode) seiner Containerklasse zugreifen, benötigt dazu allerdings eine Objektreferenz. Der Zugriff auf Klassenfelder, Klasseneigenschaften und klassenstatische Methoden ist ohne Objektreferenz möglich, es gelten aber die normalen Sichtbarkeitsregeln von Object Pascal.

Die Größe der Containerklasse erhöht sich durch verschachtelte Typen nicht. Bei der Erstellung einer Instanz der Containerklasse wird keine Instanz eines verschachtelten Typs erzeugt. Verschachtelte Typen sind mit ihren Containerklassen nur über den Kontext der Deklaration verknüpft.

Verschachtelte Klassen deklarieren und verwenden

Das folgende Beispiel veranschaulicht, wie man Felder und Methoden einer verschachtelten Klasse deklariert und auf sie zugreift.

type
      TOuterClass = class
       strict private
          myField: Integer;

       public
          type
             TInnerClass = class
              public
                myInnerField: Integer;
                procedure innerProc;
             end;

         procedure outerProc;
       end;

Um die Methode innerProc der inneren Klasse zu implementieren, muss ihr Name mit dem Namen der äußeren Klasse qualifiziert werden. Zum Beispiel:

procedure TOuterClass.TInnerClass.innerProc;
begin
   ...
end;

Der Zugriff auf Elemente des verschachtelten Typs kann wie bei normalen Klassenelementen mittels Punktnotation erfolgen. Zum Beispiel:

var
   x: TOuterClass;
   y: TOuterClass.TInnerClass;

begin
   x := TOuterClass.Create;
   x.outerProc;
   ...
   y := TOuterClass.TInnerClass.Create;
   y.innerProc;

Verschachtelte Konstanten

Konstanten können in Klassentypen auf die gleiche Weise wie verschachtelte Typen deklariert werden. Ein Deklarationsabschnitt für eine verschachtelte Konstante wird wie bei einem verschachtelten Typ durch ein reserviertes Wort oder ein Sichtbarkeitsattribut abgeschlossen. Typisierte Konstanten werden nicht unterstützt. Es können deshalb keine verschachtelten Konstanten eines Werttyps (wie Currency oder Borland.Object Pascal.System.TDateTime) deklariert werden.

Verschachtelte Konstanten können einen beliebigen einfachen Typ haben (ordinal, ordinaler Teilbereich, Aufzählung, String und reell).

Das folgende Beispiel veranschaulicht die Deklaration von verschachtelten Konstanten:

type
   TMyClass = class
        const
             x = 12;
             y = TMyClass.x + 23;
        procedure Hello;
        private
             const
                 s = 'Eine String-Konstante';
    end;

begin
   Writeln(TMyClass.y);   // Schreibt den Wert von y, 35.
end.

Siehe auch

Meine Werkzeuge
In anderen Sprachen