Introduction
Application des techniques et concepts de base
Utilisation des classes locales
Lecture des données de la base de données
Utilisation d'objets de données structurés
Utilisation de tables internes complexes
Implémentation de mises à jour de base de données à l'aide d'objets de gestion
Description du modèle de programmation d'applications ABAP RESTful

Définition et appel de méthodes

Objective

After completing this lesson, you will be able to définissez et appelez des méthodes.

Définition de méthode

Dans la partie définition d'une classe, vous utilisez METHODS pour définir une méthode d'instance et CLASS-METHODS pour définir une méthode statique. Le nom de la méthode est suivi de la signature de la méthode, c'est-à-dire de l'ensemble de valeurs que la méthode échange avec son appelant et des exceptions qui peuvent survenir au cours de la méthode.

La signature d'une méthode se compose de paramètres et d'exceptions. Chaque paramètre a un nom et un type.

ABAP connaît les types de paramètres suivants :

Paramètres d'importation

Les paramètres d'importation sont des valeurs que la méthode reçoit de l'appelant. Une méthode peut avoir un nombre quelconque de paramètres d'importation.

Par défaut, les paramètres d'import sont obligatoires, mais il existe deux façons de les rendre facultatifs :

  • Utilisation de l'option FACULTATIF. Le paramètre est facultatif et sa valeur par défaut est la valeur initiale appropriée au type du paramètre.
  • À l'aide de l'option DEFAULT <val>. Le paramètre est facultatif et sa valeur par défaut est la valeur que vous avez indiquée comme <val>.

Dans une méthode, vous ne pouvez pas modifier les paramètres d'importation. Si vous tentez de le faire, vous provoquerez une erreur de syntaxe.

Paramètres d'exportation

Les paramètres d'exportation sont des résultats renvoyés par la méthode. Une méthode peut avoir un nombre quelconque de paramètres d'exportation. Tous les paramètres d'exportation sont facultatifs - un programme appelant utilise uniquement les valeurs dont il a réellement besoin.

Paramètres de modification

Les paramètres de modification sont des valeurs que la méthode reçoit de l'appelant. Contrairement aux paramètres d'importation, la méthode peut modifier les valeurs de ces paramètres. Ils sont ensuite renvoyés à l'appelant sous le même nom. Une méthode peut avoir un nombre quelconque de paramètres de modification. Les paramètres de modification sont obligatoires par défaut. Vous pouvez les rendre facultatifs de la même manière que les paramètres d'importation.

Paramètres de retour

Un paramètre de retour est un résultat de méthode qui peut être utilisé directement dans une expression. Une méthode ne peut avoir qu'un seul paramètre de retour. Les paramètres de retour doivent utiliser une forme spéciale de passage de paramètre, appelée passage par valeur. Cette forme de passage de paramètre est définie en encadrant le nom du paramètre entre parenthèses (aucun espace !). et le précédant avec le mot-clé VALUE.

Le mot-clé RAISING est utilisé pour répertorier les exceptions que la méthode peut déclencher pour indiquer une situation d'erreur. Le programme appelant peut alors réagir à l'erreur.

Par exemple, ajoutez deux méthodes à notre classe lcl_connection.

Une méthode set_attributes( ) pour définir les valeurs de l'attribut carrier_id et connection_id et une méthode get_attributes( ) pour retourner les valeurs de ces attributs. Lorsque set_attributes( ) a besoin de deux paramètres d'importation, un pour chaque attribut, la méthode get_attributes( ) a besoin de deux paramètres d'exportation.

Pour chaque méthode que vous définissez, vous devez également créer une implémentation dans la partie implémentation de la classe. Tant que vous ne le faites pas, vous voyez des erreurs de syntaxe dans votre classe ; le contrôle syntaxique vous indique que l'implémentation de la méthode est manquante.

Astuce

ADT propose un correctif rapide pour ajouter l'implémentation manquante. Pour utiliser ce correctif rapide, procédez comme suit :
  1. Positionnez le curseur dans une instruction METHODS avec une erreur et appuyez sur Ctrl + 1.
  2. Dans la liste des correctifs rapides possibles, sélectionnez Ajouter implémentation pour … et appuyez sur Entrée. Si l'implémentation est manquante pour plusieurs méthodes, le titre du correctif rapide indique Ajouter … méthodes non implémentées.

Comment définir des méthodes

Implémentation de méthode

Vous devez implémenter chaque méthode que vous définissez. Pour ce faire, ajoutez une paire d'instructions METHOD <nom méthode> et ENDMETHOD dans la partie implémentation de la classe.

L'implémentation de méthode contient des instructions ABAP qui peuvent accéder aux paramètres de la méthode (vous n'êtes pas autorisé à modifier les paramètres d'importation) et à tous les types, attributs et constantes que vous avez déclarés dans la classe, indépendamment de leur visibilité. Les méthodes d'instance peuvent accéder à la fois aux attributs d'instance et aux attributs statiques. Les méthodes statiques ne peuvent accéder qu'aux composants statiques.

Dans la partie implémentation d'une classe, vous pouvez accéder aux attributs de cette classe sans variable de référence et "->" (ou le nom de classe et "=>", dans le cas d'attributs statiques).

ABAP propose la variable intégrée ME uniquement dans l'implémentation des méthodes d'instance. ME est une variable de référence, catégorisée avec la classe actuelle et renseignée au moment de l'exécution avec l'adresse de l'instance actuelle. L'utilisation de ME est facultative et doit être évitée, sauf si le nom d'un attribut entre en conflit avec le nom d'un autre objet de données, par exemple un nom de paramètre.

Dans l'exemple, les paramètres d'import de la méthode set_attributes( ) ont les mêmes noms que les attributs correspondants. Dans une telle situation, le nom lui-même désigne le paramètre. Ce n'est qu'en mettant me-> en face qu'il est clair qu'un attribut de l'instance actuelle doit être appelé.

Si une erreur survient lors de l'exécution d'une méthode, la méthode peut déclencher une exception à l'aide de l'instruction RAISE EXCEPTION TYPE, suivie du nom de l'exception.

Remarque

Techniquement, les noms d'exception sont les noms de classes ABAP spéciales et l'instruction RAISE EXCEPTION TYPE crée une instance de la classe référencée. L'instance est appelée objet d'exception et les classes ABAP spéciales sont appelées classes d'exception.

Lorsqu'une exception est déclenchée, l'exécution de la méthode est interrompue.

Le contrôle est renvoyé au programme appelant si toutes les conditions préalables sont remplies. Sinon, l'ensemble du programme s'interrompt avec une erreur d'exécution.

Les conditions préalables à la poursuite du programme sont les suivantes :

  • L'exception déclenchée est déclarée dans la clause RAISING de la signature de méthode.
  • L'appel de méthode est entouré d'une structure de contrôle TRY … ENDTRY
  • La structure de pilotage TRY … ENDTRY contient un bloc CATCH pour l'exception.

Remarque

Pour certaines exceptions, l'éditeur ABAP affiche un avertissement syntaxique avec un correctif rapide lorsque vous déclenchez une exception qui n'est pas encore déclarée dans la clause RAISING de la méthode.

Comment implémenter des méthodes

Appels de méthodes

Vous appelez une méthode d'instance à l'aide d'une variable de référence et du sélecteur de composant d'instance (->). Le sélecteur de composants est suivi du nom de la méthode que vous voulez appeler. Pour les méthodes statiques, vous utilisez le nom de classe et le sélecteur de composant statique (=>). Dans les deux cas, le passage des paramètres s'effectue dans une paire de parenthèses. Les parenthèses sont nécessaires dans tous les cas. Elles restent vides si aucun paramètre ne doit être transféré.

Remarque

Aucun espace n'est autorisé entre le nom de la méthode et le parenthèse ouvrante. D'autre part, vous avez besoin d'au moins un espace après la parenthèse ouvrante et avant la parenthèse fermante.

Les paramètres d'import sont répertoriés après le mot-clé EXPORTING car les valeurs importées par la méthode appelée sont exportées par le programme appelant. Les noms de paramètres sont répertoriés à gauche d'un signe égal (=) et d'une expression à droite. Cette expression peut être aussi simple qu'un littéral, une constante ou une variable, mais toute autre expression est également autorisée tant que le type de l'expression correspond au type du paramètre.

Les paramètres d'export sont répertoriés après le mot-clé IMPORTING. Notez que pour le paramètre d'export, le nom du paramètre est également répertorié à gauche du signe égal. La variable à droite doit avoir le même type que le paramètre.

Les paramètres de modification sont répertoriés après le mot-clé CHANGING. Le type de la variable à droite doit correspondre au type du paramètre sur le côté gauche.

L'exemple illustre l'appel des méthodes d'instance set_attributes( ) et get_attributes( ). Les noms de paramètres se trouvent toujours à gauche du signe égal (=).

Astuce

Vous pouvez utiliser la saisie semi-automatique du code source dans ADT pour générer l'appel de méthode, y compris le transfert de paramètres. Pour ce faire, procédez comme suit :

  1. Saisissez la variable de référence (ou le nom de classe) et le sélecteur de composant.
  2. Une fois que vous avez saisi le sélecteur de composants, appuyez sur Ctrl + Espace pour afficher une liste des composants que vous pouvez traiter.
  3. Sélectionnez une méthode et appuyez sur Maj + Entrée pour insérer le nom de la méthode et sa signature complète dans votre code. Les paramètres facultatifs sont répertoriés dans les lignes de commentaire.

Lors de l'appel d'une méthode, le mot-clé IMPORTING est toujours nécessaire pour recevoir la valeur des paramètres d'exportation. Cependant, le mot-clé EXPORTING devient facultatif si vous voulez uniquement fournir des paramètres d'importation.

Pour les méthodes avec un seul paramètre d'importation obligatoire, vous pouvez même ignorer l'affectation explicite des paramètres. Dans l'exemple, le paramètre i_carrier_id est facultatif avec la valeur par défaut "LH". Par conséquent, la valeur entre les crochets est affectée au paramètre d'importation obligatoire restant i_connection_id.

Comment appeler des méthodes

Gestion des exceptions

Dans une section précédente de ce cours, vous avez appris à gérer les erreurs d'exécution avec les structures de contrôle TRY … ENDTRY.

Les exceptions déclarées dans la clause RAISING d'une définition de méthode sont traitées exactement de la même manière :

  • Placez l'appel de méthode dans le bloc TRY de la structure de contrôle TRY … ENDTRY.
  • Définissez un bloc CATCH avec le nom de l'exception que vous voulez traiter.

Remarque

S'il existe un code que vous voulez ignorer en cas d'échec de l'appel de méthode, vous pouvez placer ce code dans le bloc TRY, après l'appel de la méthode.

Essayer : appels de méthode et gestion des exceptions

  1. Comme dans le premier exercice de ce cours, créez une nouvelle classe globale qui implémente l'interface IF_OO_ADT_CLASSRUN.
  2. Copiez l'extrait de code suivant dans la partie implémentation de la méthode if_oo_adt_classrun~main( ) :
    Code Snippet
    123456789101112131415161718192021222324252627282930
    CONSTANTS c_carrier_id TYPE /dmo/carrier_id VALUE 'LH'. CONSTANTS c_connection_id TYPE /dmo/connection_id VALUE '0400'. DATA connection TYPE REF TO lcl_connection. DATA connections TYPE TABLE OF REF TO lcl_connection. * Create Instance ********************************************************************** connection = NEW #( ). * Call Method and Handle Exception ********************************************************************** out->write( |i_carrier_id = '{ c_carrier_id }' | ). out->write( |i_connection_id = '{ c_connection_id }'| ). TRY. connection->set_attributes( EXPORTING i_carrier_id = c_carrier_id i_connection_id = c_connection_id ). APPEND connection TO connections. out->write( `Method call successful` ). CATCH cx_abap_invalid_value. out->write( `Method call failed` ). ENDTRY.
  3. Accédez à l'onglet Types locaux et insérez l'extrait de code suivant :
    Code Snippet
    12345678910111213141516171819202122232425262728293031323334
    CLASS lcl_connection DEFINITION. PUBLIC SECTION. * Attributes DATA carrier_id TYPE /dmo/carrier_id. DATA connection_id TYPE /dmo/connection_id. * Methods METHODS set_attributes IMPORTING i_carrier_id TYPE /dmo/carrier_id DEFAULT 'LH' i_Connection_id TYPE /dmo/connection_id RAISING cx_abap_invalid_value. ENDCLASS. CLASS lcl_connection IMPLEMENTATION. METHOD set_attributes. IF i_carrier_id IS INITIAL OR i_connection_id IS INITIAL. RAISE EXCEPTION TYPE cx_abap_invalid_value. ENDIF. carrier_id = i_carrier_id. connection_id = i_connection_id. ENDMETHOD. ENDCLASS.
  4. Appuyez sur CTRL + F3 pour activer la classe et SUR F9 pour l'exécuter en tant qu'application console.
  5. Analysez la sortie de la console. Déboguer le programme, jouer avec le code source pour se familiariser avec les concepts. En particulier, modifiez les valeurs des deux constantes pour déboguer le déclenchement de l'exception.

Méthodes fonctionnelles

Les méthodes qui ont un paramètre de retour sont appelées méthodes fonctionnelles. Il n'est pas possible de définir plusieurs paramètres de retour pour la même méthode. Vous devez obligatoirement définir le paramètre de retour sous la forme VALUE(<parameter_name>). Outre le paramètre de retour, une méthode fonctionnelle peut avoir n'importe quelle combinaison d'autres paramètres. Cependant, il est plus courant d'ajouter uniquement des paramètres d'importation. En effet, avec les paramètres d'exportation ou de modification supplémentaires, vous perdez le plus grand avantage des méthodes fonctionnelles, à savoir que vous pouvez utiliser le résultat d'une méthode fonctionnelle directement dans d'autres expressions ABAP.

La figure illustre deux exemples d'utilisation des méthodes fonctionnelles dans les expressions ; le premier est un exemple simple dans lequel le paramètre de retour est affecté directement à une variable. Le deuxième exemple montre comment l'appel de la méthode fonctionnelle est utilisé comme entrée pour une autre méthode. Le système exécute la méthode fonctionnelle et utilise ensuite la valeur du paramètre de retour comme entrée pour la méthode write( ).

Essayer : méthodes fonctionnelles

  1. Comme dans le premier exercice de ce cours, créez une nouvelle classe globale qui implémente l'interface IF_OO_ADT_CLASSRUN.
  2. Copiez l'extrait de code suivant dans la partie implémentation de la méthode if_oo_adt_classrun~main( ) :
    Code Snippet
    123456789101112131415161718192021222324252627282930313233343536
    DATA connection TYPE REF TO lcl_connection. DATA connections TYPE TABLE OF REF TO lcl_connection. * Create Instance ********************************************************************** connection = NEW #( ). connection->set_attributes( EXPORTING i_carrier_id = 'LH' i_connection_id = '0400' ). APPEND connection TO connections. * Calling Functional Method ********************************************************************** " in a value assignment (with inline declaration for result) DATA(result) = connection->get_output( ). " in logical expression IF connection->get_output( ) IS NOT INITIAL. " as operand in a statement LOOP AT connection->get_output( ) INTO DATA(line). ENDLOOP. " to supply input parameter of another method out->write( data = connection->get_output( ) name = ` ` ). ENDIF.
  3. Accédez à l'onglet Types locaux et insérez l'extrait de code suivant :
    Code Snippet
    12345678910111213141516171819202122232425262728293031323334353637383940414243
    CLASS lcl_connection DEFINITION. PUBLIC SECTION. * Attributes DATA carrier_id TYPE /dmo/carrier_id. DATA connection_id TYPE /dmo/connection_id. * Methods METHODS set_attributes IMPORTING i_carrier_id TYPE /dmo/carrier_id DEFAULT 'LH' i_Connection_id TYPE /dmo/connection_id. " Functional Method METHODS get_output RETURNING VALUE(r_output) TYPE string_table. * PROTECTED SECTION. * PRIVATE SECTION. ENDCLASS. CLASS lcl_connection IMPLEMENTATION. METHOD set_attributes. carrier_id = i_carrier_id. connection_id = i_connection_id. ENDMETHOD. METHOD get_output. APPEND |------------------------------| TO r_output. APPEND |Carrier: { carrier_id }| TO r_output. APPEND |Connection: { connection_id }| TO r_output. ENDMETHOD. ENDCLASS.
  4. Appuyez sur CTRL + F3 pour activer la classe et SUR F9 pour l'exécuter en tant qu'application console.
  5. Analysez la sortie de la console. Déboguer le programme, jouer avec le code source pour se familiariser avec les concepts. En particulier, déboguez les différents appels de la méthode fonctionnelle get_output( ).

Définir et appeler des méthodes

Dans cet exercice, vous allez définir et implémenter des méthodes dans votre classe locale lcl_connection. Vous appellerez ensuite ces méthodes à partir de la méthode main( ) de votre classe globale.

Modèle :

  • /LRN/CL_S4D400_CLS_INSTANCES (classe globale)

Solution :

  • /LRN/CL_S4D400_CLS_METHODS (classe globale)

Tâche 1: Copier modèle (facultatif)

Copiez la classe de modèle. Si vous avez terminé l'exercice précédent, vous pouvez ignorer cette tâche et continuer à modifier votre classe ZCL_##_LOCAL_CLASS ou votre classe ZCL_##_INSTANCES.

Étapes

  1. Ouvrez le code source de la classe globale /LRN/CL_S4D400_CLS_INSTANCES dans l'éditeur ABAP.

    1. Dans la barre d'outils Eclipse, sélectionnez Ouvrir ABAP Development Object. Vous pouvez également appuyer sur Ctrl + Maj + A.

    2. Saisissez /LRN/CL_S4D400_CLS comme chaîne de recherche.

    3. Dans la liste des objets de développement, sélectionnez /LRN/CL_S4D400_CLS_INSTANCES, puis cliquez sur OK.

  2. Liez la vue Explorateur de projets à l'aide de l'éditeur.

    1. Dans la barre d'outils Explorateur de projets, recherchez le bouton Lier à l'éditeur. S'il n'est pas encore appuyé, sélectionnez-le. Par conséquent, l'objet de développement, qui est ouvert dans l'éditeur, doit être mis en surbrillance dans l'explorateur de projets.

  3. Copiez la classe /LRN/CL_S4D400_CLS_INSTANCES dans une classe de votre propre package (nom proposé : ZCL_##_METHODS, ## correspondant à votre numéro de groupe).

    1. Dans la vue Explorateur de projets, cliquez avec le bouton droit de la souris sur la classe /LRN/CL_S4D400_CLS_INSTANCES pour ouvrir le menu de contenu.

    2. Dans le menu contextuel, sélectionnez Dupliquer ....

    3. Saisissez le nom de votre package dans la zone Package. Dans la zone Nom, saisissez le nom ZCL_##_METHODS, où ## représente votre numéro de groupe.

    4. Ajustez la description et cliquez sur Suivant.

    5. Confirmez l'ordre de transport et cliquez sur Terminer.

Tâche 2: Définir méthodes

Dans votre classe locale lcl_connection, définissez les méthodes d'instance get_output et set_attributes.

Étapes

  1. Naviguez jusqu'à la définition de la classe locale lcl_connection.

    1. Dans la classe globale, sélectionnez Types locaux.

  2. Ajoutez une méthode get_output à la section publique de la classe. Il doit avoir un paramètre de retour r_output du type de table globale STRING_TABLE.

    Remarque

    Pensez à entourer le nom du paramètre de retour de VALUE( ).
    1. Adaptez le code comme suit :

      Code Snippet
      1234567891011121314
      PUBLIC SECTION. DATA carrier_id TYPE /dmo/carrier_id. DATA connection_id TYPE /DMO/Connection_id. CLASS-DATA conn_counter TYPE i. METHODS get_output returning value(r_output) type string_table. PROTECTED SECTION.

      Remarque

      Pour le moment, ignorez l'erreur de syntaxe Implémentation manquante pour la méthode "GET_OUTPUT".
  3. Ajoutez une méthode set_attributes à la section publique de la classe. Il doit avoir un paramètre d'importation pour chaque attribut d'instance de la classe. Utilisez les mêmes types pour les paramètres que ceux que vous avez utilisés pour saisir les attributs. Pour distinguer les paramètres des attributs, ajoutez le préfixe i_ aux noms des paramètres. En outre, la méthode doit déclencher l'exception CX_ABAP_INVALID_VALUE.

    1. Adaptez le code comme suit :

      Code Snippet
      123456789101112131415161718192021
      PUBLIC SECTION. DATA carrier_id TYPE /dmo/carrier_id. DATA connection_id TYPE /DMO/Connection_id. CLASS-DATA conn_counter TYPE i. METHODS set_attributes IMPORTING i_carrier_id TYPE /dmo/carrier_id i_connection_id TYPE /dmo/connection_id RAISING cx_abap_invalid_value. METHODS get_output returning value(r_output) type string_table. PROTECTED SECTION.

      Remarque

      Pour le moment, ignorez l'erreur de syntaxe Implémentation manquante pour la méthode "SET_ATTRIBUTES".

Tâche 3: Implémenter méthodes

Étapes

  1. Utilisez un correctif rapide pour ajouter les implémentations de méthode à la classe.

    1. Positionnez le curseur sur le nom de l'une des méthodes de l'éditeur et appuyez sur Ctrl + 1.

    2. Double-cliquez sur la suggestion Ajouter 2 méthodes non implémentées.

  2. Implémentez la méthode get_output. Ajoutez des modèles de chaîne au paramètre de retour r_output. Dans les modèles de chaîne, utilisez des expressions intégrées pour ajouter les valeurs des attributs carrier_id et connection_id.

    1. Dans la classe locale, ajoutez le code suivant entre les instructions METHOD get_output. et ENDMETHOD.

      Code Snippet
      12345
      APPEND |------------------------------| TO r_output. APPEND |Carrier: { carrier_id }| TO r_output. APPEND |Connection: { connection_id }| TO r_output.
  3. Implémentez la méthode set_Attributes. Si l'un des deux paramètres d'importation est vide (IS INITIAL), déclenchez l'exception CX_ABAP_INVALID_VALUE. Sinon, renseignez les deux attributs d'instance avec les valeurs des paramètres d'importation.

    1. Adaptez le code comme suit :

      Code Snippet
      123456789101112
      METHOD set_attributes. IF i_carrier_id IS INITIAL OR i_connection_id IS INITIAL. RAISE EXCEPTION TYPE cx_abap_invalid_value. ENDIF. carrier_id = i_carrier_id. connection_id = i_connection_id. ENDMETHOD.
  4. Activez votre classe.

    1. Sélectionnez Ctrl + F3 pour activer la classe.

Tâche 4: Appel d'une méthode fonctionnelle

Dans la méthode principale de votre classe globale, appelez la méthode fonctionnelle get_output.

Étapes

  1. Passez à l'implémentation de la méthode if_oo_adt_classrun~main dans la classe globale.

    1. Dans la classe globale, sélectionnez Classe globale, faites défiler vers le bas jusqu'à l'implémentation de la méthode if_oo_adt_classrun~main.

  2. À la fin de la méthode, ajoutez une boucle sur les connexions de tables internes avec une connexion de variable de référence comme espace de travail.

    1. Ajoutez le code suivant avant ENDMETHOD..

      Code Snippet
      12345
      LOOP AT connections INTO connection. ENDLOOP.
  3. Dans la boucle, appelez la méthode fonctionnelle get_output pour chaque instance et écrivez le résultat dans la console.

    Astuce

    Vous pouvez utiliser l'appel de la méthode get_output directement comme entrée pour out->write( ).
    1. Adaptez le code comme suit :

      Code Snippet
      1234567
      LOOP AT connections INTO connection. out->write( connection->get_output( ) ). ENDLOOP.
  4. Activez la classe. Exécutez-la en tant qu'application de console et analysez la sortie de la console.

    1. Appuyez sur Ctrl + F3 pour activer la classe.

    2. Appuyez sur F9 pour exécuter la classe.

    3. Analysez le résultat dans la fenêtre Console.

Tâche 5: Utiliser l'achèvement du code et gérer les exceptions

Utilisez la saisie semi-automatique du code source pour appeler la méthode set_attributes et gérer l'exception déclenchée par la méthode.

Étapes

  1. Pour la première instance de la classe lcl_connection, remplacez l'accès direct aux attributs carrier_id et connection_id par un appel de la méthode d'instance set_attributes( ). Utilisez la saisie semi-automatique du code source pour insérer la signature complète de la méthode.

    Astuce

    Appuyez sur Ctrl + Espace après avoir saisi le composant select (->) pour afficher une liste des attributs et méthodes disponibles. Sélectionnez la méthode, puis appuyez sur Maj + Entrée pour insérer la signature complète de la méthode.
    1. Positionnez le curseur sur la ligne suivante après la première connection = NEW #( )..

    2. Saisissez connection-> et appuyez sur Ctrl + Espace.

    3. Sélectionnez set_Attributes et appuyez sur Maj + Entrée.

    4. Transmettez les valeurs aux paramètres d'importation. Utilisez les mêmes littéraux que ceux utilisés précédemment pour définir les attributs de cette instance.

    5. Supprimez ou commentez l'accès direct aux attributs d'instance pour cette instance.

  2. Gérez l'exception. Entourez l'appel de méthode avec TRY. et ENDTRY.. Ajoutez un blocage CATCH-Block pour traiter l'exception CX_ABAP_INVALID_VALUE. Assurez-vous que la nouvelle instance n'est ajoutée aux connexions de tables internes que si l'appel de méthode a réussi.

    1. Supprimez les commentaires de la ligne de code générée CATCH cx_abap_invalid_value..

    2. Ajoutez TRY. avant l'appel de la méthode.

    3. Ajoutez ENDTRY. après l'instruction CATCH.

    4. Entre l'instruction CATCH et l'instruction ENDTRY add out->write( `Method call failed` ).

    5. Déplacez l'instruction APPEND vers le haut entre l'appel de méthode et l'instruction CATCH.

    6. L'appel complet de la méthode doit maintenant ressembler à ceci :

      Code Snippet
      1234567891011121314151617
      TRY. connection->set_attributes( EXPORTING i_carrier_id = 'LH' i_connection_id = '0400' ). * connection->carrier_id = 'LH'. * connection->connection_id = '0400'. APPEND connection TO connections. CATCH cx_abap_invalid_value. out->write( `Method call failed` ). ENDTRY.
  3. Répétez l'étape précédente pour les deux autres instances de la classe lcl_connection.

    1. Après cette étape, l'implémentation de la méthode if_oo_adt_classrun~main doit ressembler à ceci :

      Code Snippet
      12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879
      METHOD if_oo_adt_classrun~main. DATA connection TYPE REF TO lcl_connection. DATA connections TYPE TABLE OF REF TO lcl_connection. * First Instance ********************************************************************** connection = NEW #( ). TRY. connection->set_attributes( EXPORTING i_carrier_id = 'LH' i_connection_id = '0400' ). * connection->carrier_id = 'LH'. * connection->connection_id = '0400'. APPEND connection TO connections. CATCH cx_abap_invalid_value. out->write( `Method call failed` ). ENDTRY. * Second instance ********************************************************************** connection = NEW #( ). TRY. connection->set_attributes( EXPORTING i_carrier_id = 'AA' i_connection_id = '0017' ). * connection->carrier_id = 'AA'. * connection->connection_id = '0017'. APPEND connection TO connections. CATCH cx_abap_invalid_value. out->write( `Method call failed` ). ENDTRY. * Third instance ********************************************************************** connection = NEW #( ). TRY. connection->set_attributes( EXPORTING i_carrier_id = 'SQ' i_connection_id = '0001' ). * connection->carrier_id = 'SQ'. * connection->connection_id = '0001'. APPEND connection TO connections. CATCH cx_abap_invalid_value. out->write( `Method call failed` ). ENDTRY. * Output ********************************************************************** LOOP AT connections INTO connection. out->write( connection->get_output( ) ). ENDLOOP. ENDMETHOD.
  4. Activez la classe. Exécutez-la et déboguez les appels de méthode.

    1. Appuyez sur Ctrl + F3 pour activer la classe.

    2. Appuyez sur F9 pour exécuter la classe.