Déclarations de types imbriqués

De Appmethod Topics
Aller à : navigation, rechercher

Remonter à Classes et objets - Index

Les déclarations de types peuvent être imbriquées dans des déclarations de classes. Les types imbriqués sont utilisés dans l'environnement .Net Framework et dans la programmation orientée objet en général. Ils permettent de regrouper des types conceptuellement associés et d'éviter les conflits de noms. Le compilateur Win32 Object Pascal peut utiliser la même syntaxe pour déclarer les types imbriqués.

Déclaration des types imbriqués

nestedTypeDeclaration suit la syntaxe de déclaration de type définie dans la section Déclaration de types.


type
  className = class [abstract | sealed] (ancestorType)
      memberList

      type
         nestedTypeDeclaration

      memberList
  end;

Les déclarations de types imbriqués se terminent par la première occurrence d'un token non identificateur, par exemple procedure, class, type et tous les spécificateurs de portée de visibilité.

Les règles d'accessibilité normales s'appliquent aux types imbriqués et à leurs types conteneurs. Un type imbriqué peut accéder à une variable d'instance (champ, propriété ou méthode) de sa classe conteneur, à condition qu'il dispose d'une référence d'objet. Un type imbriqué peut accéder aux champs de classe, aux propriétés de classe et aux méthodes statiques de classe sans référence d'objet, mais les règles de visibilité Object Pascal normales s'appliquent.

Les types imbriqués n'augmentent pas la taille de la classe conteneur. La création d'une instance de la classe conteneur ne crée pas également d'instance d'un type imbriqué. Les types imbriqués ne sont associés à leurs classes conteneurs que par le contexte de leur déclaration.

Déclaration et accès aux classes imbriquées

L'exemple suivant montre comment déclarer et accéder aux champs et aux méthodes d'une classe imbriquée.


type
      TOuterClass = class
       strict private
          myField: Integer;

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

         procedure outerProc;
       end;

Pour implémenter la méthode innerProc de la classe interne, vous devez qualifier son nom avec le nom de la classe externe. Par exemple :


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

Pour accéder aux membres du type imbriqué, utilisez la même notation par point que pour l'accès aux membres de classes normales. Par exemple :


var
   x: TOuterClass;
   y: TOuterClass.TInnerClass;

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

Constantes imbriquées

Les constantes peuvent être déclarées dans les types de classes de la même manière que les sections de types imbriqués. Les sections de constantes sont terminées par les mêmes tokens que les sections de types imbriqués, en particulier des spécificateurs de visibilité ou des mots réservés. Les constantes typées ne sont pas prises en charge, vous ne pouvez donc pas déclarer des constantes imbriquées de types de valeurs, comme Borland.Object Pascal.System.Currency ou Borland.Object Pascal.System.TDateTime.

Les constantes imbriquées peuvent avoir n'importe quel type simple : scalaire, sous-intervalles scalaires, énumérations, chaînes et réel.

Le code suivant montre la déclaration de constantes imbriquées :


type
   TMyClass = class
        const
             x = 12;
             y = TMyClass.x + 23;
        procedure Hello;
        private
             const
                 s = 'Constante chaîne A';
    end;

begin
   Writeln(TMyClass.y);   // Ecrit la valeur de y, 35.
end.

Voir aussi