Visionnez cette vidéo pour comprendre le concept de cours généraux et plus spécialisés.
Héritage - La relation "Est A"
Dans la modélisation, on parle de spécialisation. L'implémentation de cette relation dans un langage de programmation utilise le concept d'héritage, dans lequel une nouvelle classe (la sous-classe) est dérivée d'une classe existante (la surclasse). Un test fiable pour voir s'il existe une véritable relation d'héritage entre deux classes est d'essayer de dire "une sous-classe est une surclasse". Si cela est clairement vrai, vous avez une relation de transmission de données. Si ce n'est clairement pas vrai, ou même semble un peu étrange, vous n'avez pas de relation d'héritage et ne devez pas en mettre en œuvre car cela causera probablement des problèmes plus loin dans la ligne. Lors de l'essai de notre modèle, nous pouvons certainement dire qu'"un avion cargo est un avion" et "un avion de passagers est un avion".
Une classe qui hérite d'une surclasse contient automatiquement tous les membres de la surclasse. Ainsi, par exemple, la classe avion de transport de passagers a un constructeur et un type comme le fait un avion. Cela ne devrait pas être surprenant, car un avion de passagers est un avion. Ce qui peut d'abord apparaître supranéité, c'est que la classe d'avion de passagers ne peut pas accéder à son propre constructeur et type. En effet, il s'agit d'attributs privés de la surclasse et, en tant que tels, ils ne sont pas accessibles à la sous-classe. Plus tard, vous apprendrez une façon de permettre à une sous-classe d'accéder aux composants d'une surclasse sans les rendre entièrement publics.
Définition de la relation de transmission de données
Dans ABAP, vous implémentez l'héritage à l'aide de l'option INHERITING FROM dans l'instruction de définition de classe. Dans cet exemple, la classe avion passager est définie comme une sous-classe de la classe plane. Notez que la sous-classe connaît sa surclasse, mais la classe avion n'a aucune idée de ses sous-classes (le cas échéant).
Une sous-classe ne peut avoir qu'une seule surclasse directe.
Une surclasse - N'importe quel nombre de sous-classes
La classe plane peut avoir n'importe quel nombre de sous-classes, mais elle n'en connaît aucune.
Chaque sous-classe a une seule superclasse directe. Il connaît sa superclasse, mais ne connaît aucune classe frère (d'autres classes qui sont dérivées de la même surclasse). Dans notre exemple, la classe d'avion de passagers n'a aucune connaissance de la classe d'avion de fret.
Extension d'une sous-classe
Une fois que vous avez déclaré une sous-classe, vous devez y ajouter de nouveaux composants ou modifier les composants existants. C'est ce qui transforme la simple copie de la classe d'avion en avion de passagers ou en avion cargo. Grâce à l'héritage, vous n'avez pas besoin d'implémenter la classe à partir de zéro, vous l'étendez simplement aux nouveaux composants dont elle a besoin.
Il existe trois façons de procéder :
Ajouter de nouveaux composants : vous pouvez déclarer de nouveaux attributs, types, constantes et méthodes dans la classe. Leurs noms ne doivent pas entrer en conflit avec d'autres noms qui ont déjà été utilisés pour déclarer des membres dans la surclasse. Vous devez également vous assurer que les nouveaux composants sont pertinents uniquement pour la sous-classe et non pour toutes les spécialisations de la surclasse. Si vous déclarez un nouvel attribut ou une nouvelle méthode qui est généralement pertinent(e), vous devez le/la déplacer dans la surclasse.
Redéfinir les méthodes : lorsque vous appelez une méthode héritée, le système d'exécution exécute l'implémentation de la méthode à partir de la surclasse. Cependant, cette implémentation ne peut pas prendre en compte les nouveaux composants que vous avez déclarés dans la sous-classe. Dans ce cas, vous pouvez redéfinir la méthode. Cela signifie que vous pouvez lui affecter une nouvelle implémentation pertinente pour la sous-classe.
Ajouter un nouveau constructeur : Les constructeurs s'assurent que les nouvelles instances de la classe sont correctement initialisées. Lorsque vous créez une instance d'une sous-classe, le système d'exécution exécute toujours le constructeur de la surclasse. Ceci garantit, par example, qu'un avion de tourisme a un constructeur et un type de la même manière que n'importe quel autre avion. Cependant, le constructeur de la surclasse ne peut pas initialiser les attributs de la sous-classe, car il ne sait pas qu'ils existent. Pour cette raison, vous pouvez définir un nouveau constructeur pour la sous-classe.
Déclarer de nouveaux composants
Vous pouvez étendre une sous-classe en déclarant de nouveaux composants. Celles-ci sont visibles pour la classe elle-même mais pas pour la surclasse, et aussi pour aucune autre classe qui hérite de la même surclasse. Vous devez donc déterminer si les nouveaux composants sont pertinents uniquement dans la classe actuelle ou s'ils doivent réellement être déclarés dans la surclasse.
Composants protégés
Même si une sous-classe contient tous les attributs de sa surclasse, elle n'est pas autorisée à accéder directement aux composants privés. Parfois, cela est nécessaire, mais il y a d'autres moments où une surclasse doit laisser ses sous-classes accéder à des attributs ou méthodes particuliers sans les rendre entièrement publiques. Il peut le faire en les déclarant dans la section protégée. Les composants protégés sont visibles au sein même de la classe mais aussi pour toutes les sous-classes.
Dans la définition de classe, vous introduisez la section protégée à l'aide de l'instruction PROTECTED SECTION. Vous devez toujours déclarer les sections de visibilité dans la séquence SECTION PUBLIC - SECTION PROTÉGÉE - SECTION PRIVÉE.
Vous pouvez déplacer un composant existant d'une classe à l'aide d'un correctif rapide. Pour ce faire, placez le curseur sur le nom du composant dans ADT et appuyez sur Ctrl + 1, puis sélectionnez le correctif rapide Définir <élément> comme protégé.
Le déplacement d'un composant privé vers la section protégée est une modification compatible - vous avez élargi la visibilité du composant. Cependant, la protection d'un composant public est une modification incompatible et peut entraîner des erreurs de syntaxe. En effet, vous avez limité la visibilité du composant, qui a peut-être déjà été utilisé en dehors de la hiérarchie d'héritage.
Redéfinition des méthodes
Les surclasses contiennent souvent des méthodes que vous voulez utiliser dans une sous-classe, mais leurs implémentations ne conviennent pas car elles ne prennent pas en compte la nature particulière de la sous-classe. Par exemple, la méthode get_attributes de la classe plane ne peut pas retourner des attributs définis dans la classe avion passager. Cependant, la classe d'avion de transport de passagers a encore besoin d'une méthode get_Attributes.
Dans ABAP, vous pouvez résoudre ce problème en redéfinissant la méthode d'instance get_Attributes. Lorsque vous redéfinissez une méthode, vous écrivez une nouvelle implémentation pour celle-ci dans la sous-classe qui prend en compte les éléments que seule la sous-classe peut connaître. Cependant, la définition de la méthode reste exactement la même. Vous devez suivre ces règles :
- La méthode conserve le même nom.
- Vous indiquez que vous voulez redéfinir la méthode en la déclarant dans la sous-classe avec l'option REDEFINITION.
- La méthode a la même visibilité que dans la surclasse.
- Vous ne devez pas modifier la signature de la méthode.
Vous ne pouvez pas redéfinir une méthode statique.
Implémentation de la redéfinition
Lorsque vous implémentez la redéfinition d'une méthode, vous pouvez appeler l'implémentation dans la surclasse. Pour ce faire, utilisez la référence d'objet implicite super, qui pointe vers la surclasse dans l'instance actuelle. De cette façon, vous pouvez réutiliser l'implémentation de méthode de la surclasse, puis l'ajouter dans votre propre implémentation.
Vous n'avez pas besoin de déclarer la variable de référence super. Il est automatiquement disponible dans l'implémentation des méthodes redéfinies.
L'appel de la méthode dans la surclasse de cette manière est facultatif. Parfois ce sera une bonne idée, parfois il n'y a rien à y gagner.
Nouvelle définition de constructeur
Dans une sous-classe, vous pouvez définir un nouveau constructeur. Contrairement aux redéfinitions de méthodes, un constructeur peut avoir sa propre signature. La signature d'un constructeur contiendra souvent les mêmes paramètres que le constructeur de la superclasse, plus de nouveaux paramètres qui lui sont propres. En effet, le nouveau constructeur d'instance a deux tâches - d'abord d'appeler le constructeur de la superclasse, puis de s'occuper d'initialiser ses propres attributs qui sont spécifiques à la sous-classe.
En plus de définir un nouveau constructeur, vous pouvez également définir un nouveau constructeur statique dans une sous-classe.
Rôle du constructeur
Le constructeur d'une sous-classe a deux fonctions : il doit s'assurer que les membres de la surclasse sont correctement initialisés, et ensuite, il peut définir les valeurs initiales des attributs de la sous-classe.
Dans notre exemple, étant donné qu'un avion de transport de passagers est un avion, il ne peut y avoir d'instance d'avion de passagers que si le constructeur de la classe d'avion a réussi à régler le constructeur et le type du nouvel avion de transport de passagers. Ce n'est qu'après cela que la classe d'avion de passagers peut définir ses propres attributs.
Le constructeur de la sous-classe doit donc être capable de définir non seulement ses propres attributs, mais aussi de transmettre les valeurs requises au constructeur de la surclasse. C'est pourquoi la signature du constructeur dans la sous-classe contient souvent toute la signature du constructeur qu'il est nécessaire d'appeler.
Séquence de l'implémentation du nouveau constructeur
Dans l'implémentation du nouveau constructeur, il existe une séquence particulière d'opérations que vous devez observer. L'événement le plus important est l'appel au constructeur de la surclasse. Cela est obligatoire et vous appelez la méthode à l'aide de la référence implicite super, comme vous le pouvez lors de l'appel de l'implémentation d'origine d'une méthode redéfinie. Encore une fois, vous n'avez pas besoin de déclarer explicitement super.
Avant d'avoir appelé le constructeur de la surclasse, vous ne devez adresser aucun composant d'instance de l'instance en cours de construction. Vous pouvez adresser des composants statiques de la classe et vérifier l'exactitude des paramètres d'importation du constructeur. S'ils ne sont pas corrects, déclenchez une exception.
Une fois le constructeur de la surclasse exécuté avec succès, vous pouvez vous adresser aux composants d'instance de votre nouvelle instance.
Séquence d'appels de constructeur
La figure illustre la séquence dans laquelle les constructeurs statiques et d'instance sont appelés. L'exemple suppose qu'un programme souhaite instancier la classe avion passager et que la classe avion n'a pas été adressée précédemment.
Lorsque le programme tente de créer une instance de la classe avion passager, le système d'exécution appelle automatiquement les constructeurs statiques de manière séquentielle, en commençant par le haut de la hiérarchie d'héritage. Une fois que tous les constructeurs statiques ont été exécutés, le système d'exécution appelle le constructeur d'instance de la sous-classe, qui appelle à son tour le constructeur d'instance de la surclasse.
