{"id":47,"date":"2021-05-29T13:43:42","date_gmt":"2021-05-29T13:43:42","guid":{"rendered":"https:\/\/www.louismarchand.me\/?page_id=47"},"modified":"2022-01-26T19:19:19","modified_gmt":"2022-01-26T19:19:19","slug":"les-routines","status":"publish","type":"page","link":"https:\/\/www.louismarchand.me\/index.php\/les-routines\/","title":{"rendered":"Les routines"},"content":{"rendered":"

D\u00e9finitions<\/h2>\n

La routine<\/h3>\n

On appel routine<\/strong> (ou sous-routine<\/strong> ou sous-programme<\/strong>) permet d’encapsuler une portion de code (ou s\u00e9rie d’instructions) effectuant un travail bien pr\u00e9cis. La routine<\/strong> est identifi\u00e9e et peut \u00eatre ex\u00e9cut\u00e9e une multitude de fois \u00e0 plusieurs endroits dans le code d’un programme.<\/p>\n

Appel de routine<\/h3>\n

Lorsqu’une premi\u00e8re routine ex\u00e9cute une autre routine, on dit que la premi\u00e8re routine effectue un appel<\/strong> de routine (ou que la premi\u00e8re routine appel<\/strong>le l’autre routine.<\/p>\n

Par exemple, si j’ai la routine A et la routine B; je peux dire que A appel B si al routine A lance l’ex\u00e9cution de la routine B.<\/p>\n

\u00c9galement, lorsqu’une routine A appel une routine B, on dit que la routine A est la routine appelante<\/strong> et que la routine B est la routine appel\u00e9e<\/strong>.<\/p>\n

\n
public<\/span> void<\/span> maRoutineA<\/span>(){<\/span>\r\n    ...<\/span>\r\n    maRoutineB<\/span>();<\/span>\r\n    ...<\/span>\r\n}<\/span>\r\n\r\npublic<\/span> void<\/span> maRoutineB<\/span>(){<\/span>\r\n    ...<\/span>\r\n}<\/span>\r\n<\/pre>\n<\/div>\n
Les variables locales<\/h2>\n
Les routines peuvent utiliser des variables locales afin de lui permettre d’effectuer un travail plus complexe et d’avoir un code plus propre. Il est par contre important de noter que ces variables locales ne sont accessibles qu’\u00e0 l’int\u00e9rieur de la routine et les valeurs plac\u00e9es dans ces variables locales ne restent pas sauvegard\u00e9es entre les diff\u00e9rents appels de routine. En d’autres mots, ces variables sont cr\u00e9\u00e9es au d\u00e9but de l’ex\u00e9cution d’une routine et sont d\u00e9truites \u00e0 la fin de l’ex\u00e9cution de cette derni\u00e8re. Par exemple:<\/p>\n
\n
public<\/span> void<\/span> salutation<\/span>()<\/span> {<\/span>\r\n    Scanner<\/span> lScanner<\/span> =<\/span> new<\/span> Scanner<\/span>(<\/span>System<\/span>.<\/span>in<\/span>);<\/span>\r\n    String<\/span> lPrenom<\/span>,<\/span> lNom<\/span>;<\/span>\r\n    System<\/span>.<\/span>out<\/span>.<\/span>print<\/span>(<\/span>\"Veuillez entrer votre prenom: \"<\/span>);<\/span>\r\n    lPrenom<\/span> =<\/span> lScanner<\/span>.<\/span>nextLine<\/span>();<\/span>\r\n    System<\/span>.<\/span>out<\/span>.<\/span>print<\/span>(<\/span>\"Veuillez entrer votre nom: \"<\/span>);<\/span>\r\n    lNom<\/span> =<\/span> lScanner<\/span>.<\/span>nextLine<\/span>();<\/span>\r\n    System<\/span>.<\/span>out<\/span>.<\/span>println<\/span>(<\/span>\"Bonjour \"<\/span> +<\/span> lPrenom<\/span> +<\/span> \" \"<\/span> +<\/span> lNom<\/span>);<\/span>\r\n}<\/span>\r\n<\/pre>\n<\/div>\n
Dans cet exemple, la routine \u00ab\u00a0salutation\u00a0\u00bb poss\u00e8de 3 variables locales: \u00ab\u00a0lScanner\u00a0\u00bb, \u00ab\u00a0lPrenom\u00a0\u00bb et \u00ab\u00a0lNom\u00a0\u00bb.<\/p>\n
Les arguments<\/h2>\n
Il est parfois n\u00e9cessaire, pour une routine, d’avoir acc\u00e8s \u00e0 certaines valeurs afin de bien faire le travail qu’elle doit ex\u00e9cuter. Afin que la routine appelante puisse transmettre ces valeurs vers la routine appel\u00e9e, on utilise g\u00e9n\u00e9ralement des arguments<\/strong>. La routine appel\u00e9e doit sp\u00e9cifier les arguments<\/strong> qu’elle n\u00e9cessite dans sa signature et la routine appel\u00e9e doit passer ces arguments<\/strong> dans son appel de routine.<\/p>\n
\n
public<\/span> void<\/span> salutation<\/span>(<\/span>String<\/span> aPrenom<\/span>,<\/span> String<\/span> aNom<\/span>){<\/span>\r\n    System<\/span>.<\/span>out<\/span>.<\/span>println<\/span>(<\/span>\"Bonjour \"<\/span> +<\/span> aPrenom<\/span> +<\/span> \" \"<\/span> +<\/span> aNom<\/span>);<\/span>\r\n}<\/span>\r\n\r\npublic<\/span> void<\/span> programme<\/span>(){<\/span>\r\n    Scanner<\/span> lScanner<\/span> =<\/span> new<\/span> Scanner<\/span>(<\/span>System<\/span>.<\/span>in<\/span>);<\/span>\r\n    String<\/span> lPrenom<\/span>,<\/span> lNom<\/span>;<\/span>\r\n    System<\/span>.<\/span>out<\/span>.<\/span>print<\/span>(<\/span>\"Entrez votre prenom: \"<\/span>);<\/span>\r\n    lPrenom<\/span> =<\/span> lScanner<\/span>.<\/span>nextLine<\/span>();<\/span>\r\n    System<\/span>.<\/span>out<\/span>.<\/span>print<\/span>(<\/span>\"Entrez votre nom: \"<\/span>);<\/span>\r\n    lNom<\/span> =<\/span> lScanner<\/span>.<\/span>nextLine<\/span>();<\/span>\r\n    salutation<\/span>(<\/span>lPrenom<\/span>,<\/span> lNom<\/span>);<\/span>\r\n}<\/span>\r\n<\/pre>\n<\/div>\n
Dans cet exemple, la routine \u00ab\u00a0programme\u00a0\u00bb appel la routine \u00ab\u00a0salutation\u00a0\u00bb avec deux (2) arguments: le pr\u00e9nom (aPrenom) et le nom (aNom).<\/p>\n
Valeur de retour<\/h2>\n
Il est possible que nous veuillions qu’une routine appel\u00e9e retourne une valeur \u00e0 une routine appelante. Il y a plusieurs mani\u00e8res pour faire ce type de retour, mais la plus utilis\u00e9e (et celle qui devrait \u00eatre privil\u00e9gi\u00e9e) est la valeur de retour.<\/p>\n
Pour sp\u00e9cifier une valeur de retour, il faut d\u00e9buter par sp\u00e9cifier le type de cette valeur dans la signature de la routine. Par exemple:<\/p>\n
\n
public<\/span> String<\/span> maRoutine<\/span>()<\/span>\r\n<\/pre>\n<\/div>\n
Dans cette routine, maRoutine retourne une valeur de type \u00ab\u00a0String\u00a0\u00bb aux routines appelantes.<\/p>\n
Pour retourner une valeur en particulier, il faut utiliser l’instruction return<\/strong>. Afin de s’assurer de ne pas briser de structure de contr\u00f4le, il est une bonne pratique de mettre l’instruction return<\/strong> une seule fois dans une routine, \u00e0 la derni\u00e8re ligne de la routine.<\/p>\n
\n
public<\/span> int<\/span> somme<\/span>(<\/span>List<\/span><<\/span>Integer<\/span>><\/span> aListe<\/span>)<\/span> {<\/span>\r\n    int<\/span> lResultat<\/span> =<\/span> 0<\/span>;<\/span>\r\n    for<\/span> (<\/span>Integer<\/span> element<\/span> :<\/span> aListe<\/span>)<\/span> {<\/span>\r\n        lResultat<\/span> =<\/span> lResultat<\/span> +<\/span> element<\/span>.<\/span>intValue<\/span>();<\/span>\r\n    }<\/span>\r\n    return<\/span> lResultat<\/span>;<\/span>\r\n}<\/span>\r\n<\/pre>\n<\/div>\n
Modification sur place d’argument<\/h2>\n
Une routine appel\u00e9e peut \u00e9galement utiliser un autre m\u00e9canisme pour retourner une valeur \u00e0 la routine appelante. La routine appel\u00e9e peut modifier un des arguments. On appelle ce m\u00e9canisme modification sur place d’argument<\/strong>. Par exemple:<\/p>\n
\n
public<\/span> void<\/span> versMajuscule<\/span>(<\/span>List<\/span><<\/span>String<\/span>><\/span> aListe<\/span>)<\/span> {<\/span>\r\n    int<\/span> i<\/span>;<\/span>\r\n    for<\/span> (<\/span>i<\/span> =<\/span> 0<\/span>;<\/span> i<\/span> <<\/span> aListe<\/span>.<\/span>size<\/span>();<\/span> i<\/span> =<\/span> i<\/span> +<\/span> 1<\/span>)<\/span> {<\/span>\r\n        aListe<\/span>.<\/span>set<\/span>(<\/span>i<\/span>,<\/span> aListe<\/span>.<\/span>get<\/span>(<\/span>i<\/span>).<\/span>toUpperCase<\/span>());<\/span>\r\n    }<\/span>\r\n}<\/span>\r\n<\/pre>\n<\/div>\n
On voit que la m\u00e9thode \u00ab\u00a0versMajuscule\u00a0\u00bb modifie directement l’argument \u00ab\u00a0aListe\u00a0\u00bb en effectuant des \u00ab\u00a0set\u00a0\u00bb.<\/p>\n
Par contre, pour effectuer ce m\u00e9canisme, nous ne pouvons pas assigner l’argument avec un nouvel objet. En d’autres mots, vous ne devez pas faire de \u00ab\u00a0=\u00a0\u00bb. Par exemple, l’exemple suivant ne fonctionnera pas<\/strong>:<\/p>\n
\n
public<\/span> void<\/span> versMajuscule<\/span>(<\/span>List<\/span><<\/span>String<\/span>><\/span> aListe<\/span>)<\/span> {<\/span>\r\n    ArrayList<\/span><<\/span>String<\/span>><\/span> lListe<\/span> =<\/span> new<\/span> ArrayList<\/span><<\/span>String<\/span>><\/span>(<\/span>aListe<\/span>.<\/span>size<\/span>());<\/span>\r\n    for<\/span> (<\/span>String<\/span> element<\/span>:<\/span> aListe<\/span>)<\/span> {<\/span>\r\n        lListe<\/span>.<\/span>add<\/span>(<\/span>element<\/span>.<\/span>toUpperCase<\/span>());<\/span>\r\n    }<\/span>\r\n    aListe<\/span> =<\/span> lListe<\/span>;<\/span>\r\n}<\/span>\r\n<\/pre>\n<\/div>\n
Pour comprendre la raison pour laquelle cette modification ne fonctionne pas, il faut comprendre comment un argument fonctionne. Voici un sch\u00e9ma repr\u00e9sentant un passage d’argument lors de l’appel d’une routine.<\/p>\n
\"\"<\/p>\n
On voit que chaque routine stock chacun une copie du pointeur qui pointe vers le m\u00eame objet en m\u00e9moire. En effet, si une modification sur place<\/strong> est faite sur a liste, puisqu’il s’agit de la m\u00eame liste, la modification s’effectue pour les deux (2) routines. Par contre, lorsque nous cr\u00e9ons une autre liste et que nous faisons une assignation \u00ab\u00a0=\u00a0\u00bb, voici ce que devient le sch\u00e9ma.<\/p>\n
\"\"<\/p>\n
On voit qu’une nouvelle liste a bel et bien \u00e9t\u00e9 cr\u00e9\u00e9e, mais seule la routine appel\u00e9e y a acc\u00e8s. La routine appelante n’a aucun acc\u00e8s \u00e0 cette nouvelle liste et son pointeur pointe toujours vers la premi\u00e8re liste.<\/p>\n
Les effets de bord<\/h2>\n
On a un effet de bord<\/strong> lorsqu’une routine modifie l’\u00e9tat du syst\u00e8me (par syst\u00e8me, j\u2019entends le programme au sens large). La meilleure fa\u00e7on de savoir si une routine fait un effet de bord<\/strong>, c’est de regarder si tout est identique dans le programme entre avant l’appel de la routine et apr\u00e8s l’appel de la routine.<\/p>\n
Il y a diff\u00e9rents effets de bord:<\/p>\n
    \n
  • \n
      \n
    • Effectuer une entr\u00e9e ou sortie:\n
        \n
      • \u00ab\u00a0Print\u00a0\u00bb,<\/li>\n
      • \u00ab\u00a0Scanner\u00a0\u00bb,<\/li>\n
      • Valeur dans une fen\u00eatre,<\/li>\n
      • Cr\u00e9ation, modification, suppression de fichiers,<\/li>\n
      • Modification de base de donn\u00e9es,<\/li>\n
      • etc.<\/li>\n<\/ul>\n<\/li>\n
      • Modifier une valeur de:\n
          \n
        • Variable globale,<\/li>\n
        • Attribut,<\/li>\n
        • Argument de la m\u00e9thode (modification sur place),<\/li>\n
        • etc.<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n
          Voici quelques exemples:<\/p>\n
          \n
          public<\/span> void<\/span> salutation<\/span>(<\/span>String<\/span> aPrenom<\/span>,<\/span> String<\/span> aNom<\/span>){<\/span>\r\n    System<\/span>.<\/span>out<\/span>.<\/span>println<\/span>(<\/span>\"Bonjour \"<\/span> +<\/span> aPrenom<\/span> +<\/span> \" \"<\/span> +<\/span> aNom<\/span>);<\/span>\r\n}<\/span>\r\n<\/pre>\n<\/div>\n
          La m\u00e9thode \u00ab\u00a0salutation\u00a0\u00bb de l’exemple pr\u00e9c\u00e9dent effectue un effet de bord<\/strong> puisqu’il inscrit un texte dans la console, ce qui change l’\u00e9tat du programme en cours.<\/p>\n
          \n
          public<\/span> String<\/span> lireChaine<\/span>(){<\/span>\r\n    Scanner<\/span> lScanner<\/span> =<\/span> new<\/span> Scanner<\/span>(<\/span>System<\/span>.<\/span>in<\/span>);<\/span>\r\n    return<\/span> lScanner<\/span>.<\/span>nextLine<\/span>();<\/span>\r\n}<\/span>\r\n<\/pre>\n<\/div>\n
          La m\u00e9thode \u00ab\u00a0lireChaine\u00a0\u00bb de l’exemple pr\u00e9c\u00e9dent effectue un effet de bord<\/strong> puisqu’il lit de l’information au clavier, ce qui change l’\u00e9tat du programme en cours.<\/p>\n
          \n
          public<\/span> void<\/span> versMajuscule<\/span>(<\/span>List<\/span><<\/span>String<\/span>><\/span> aListe<\/span>)<\/span> {<\/span>\r\n    int<\/span> i<\/span>;<\/span>\r\n    for<\/span> (<\/span>i<\/span> =<\/span> 0<\/span>;<\/span> i<\/span> <<\/span> aListe<\/span>.<\/span>size<\/span>();<\/span> i<\/span> =<\/span> i<\/span> +<\/span> 1<\/span>)<\/span> {<\/span>\r\n        aListe<\/span>.<\/span>set<\/span>(<\/span>i<\/span>,<\/span> aListe<\/span>.<\/span>get<\/span>(<\/span>i<\/span>).<\/span>toUpperCase<\/span>());<\/span>\r\n    }<\/span>\r\n}<\/span>\r\n<\/pre>\n<\/div>\n
          La routine \u00ab\u00a0versMajuscule\u00a0\u00bb ci-dessus effectue un effet de bord puisqu’elle modifie le contenu de la liste re\u00e7ue en argument.<\/p>\n
          Voici maintenant un exemple sans effet de bord:<\/p>\n
          \n
          public<\/span> int<\/span> moyenne<\/span>(<\/span>List<\/span><<\/span>Integer<\/span>><\/span> aListe<\/span>)<\/span> {<\/span>\r\n    int<\/span> lSomme<\/span> =<\/span> 0<\/span>;<\/span>\r\n    for<\/span> (<\/span>Integer<\/span> element<\/span> :<\/span> aListe<\/span>)<\/span> {<\/span>\r\n        lSomme<\/span> =<\/span> lSomme<\/span> +<\/span> element<\/span>.<\/span>intValue<\/span>();<\/span>\r\n    }<\/span>\r\n    return<\/span> lSomme<\/span> =<\/span> lSomme<\/span> \/<\/span> aListe<\/span>.<\/span>size<\/span>();<\/span>\r\n}<\/span>\r\n<\/pre>\n<\/div>\n
          La routine \u00ab\u00a0moyenne\u00a0\u00bb dans cet exemple n’a pas d’effet de bord<\/strong> puisqu’elle ne modifie aucune valeur autre que dans ses propres variables locales et ne fait aucune entr\u00e9e\/sortie.<\/p>\n
          Les diff\u00e9rents types de routines<\/h2>\n
          Le terme routine<\/strong> est un terme tr\u00e8s g\u00e9n\u00e9ral. Il y a deux types diff\u00e9rents de routine qui ont des utilit\u00e9s assez diff\u00e9rentes. On les appelle les proc\u00e9dures<\/strong> et les fonctions<\/strong>. Il est tr\u00e8s important de bien comprendre la diff\u00e9rence entre ces deux types de routines, car ils seront utilis\u00e9s diff\u00e9remment dans un contexte objet.<\/p>\n
          Les proc\u00e9dures<\/h3>\n
          Une proc\u00e9dure<\/strong> est une routine qui ne retourne aucune valeur \u00e0 l’utilisateur. Ce type de routine est g\u00e9n\u00e9ralement utilis\u00e9 afin d’effectuer des effets de bord.<\/p>\n
          En java, une proc\u00e9dure est une routine dont la valeur de retour est \u00ab\u00a0void\u00a0\u00bb.<\/p>\n
          Les fonctions<\/h3>\n
          Une fonction<\/strong> est une routine qui retourne une valeur \u00e0 la routine appelante par la m\u00e9canique de la valeur de retour. Ce type de routine sert g\u00e9n\u00e9ralement \u00e0 calculer une valeur ou bien \u00e0 retourner une valeur n’\u00e9tant pas accessible par la routine appelante.<\/p>\n
          Les fonctions pures<\/h4>\n
          On dit qu’une fonction est pure<\/strong> dans le cas ou elle ne cause pas d’effet de bord. En g\u00e9n\u00e9ral, lorsque nous cr\u00e9ons des fonctions, nous essayons au maximum de cr\u00e9er des fonctions pures. Lorsque ce n’est pas possible ou qu’il y a un gros avantage \u00e0 faire une fonction qui n’est pas pure, il est important de bien sp\u00e9cifier dans la documentation de la fonction qu’il y a un effet de bord ainsi que la port\u00e9e de cet effet.<\/p>\n
          R\u00e9cursivit\u00e9<\/h2>\n
          Certaines routines peuvent s’appeler elles-m\u00eames afin d’effectuer leurs travaux. On appelle ces routines des routines r\u00e9cursives<\/strong>.<\/p>\n
          En g\u00e9n\u00e9ral, les routines r\u00e9cursives sont construites de la mani\u00e8re suivante:<\/p>\n
            \n
          • \n
              \n
            • Base:\n
                \n
              • La valeur la plus minimaliste.<\/li>\n<\/ul>\n<\/li>\n
              • R\u00e9cursion:\n
                  \n
                • Le calcul de la prochaine valeur<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n
                  Par exemple, on d\u00e9finit la factorielle d’un \u00ab\u00a0nombre\u00a0\u00bb comme \u00e9tant le produit de toutes les valeurs pr\u00e9c\u00e8dent le \u00ab\u00a0nombre\u00a0\u00bb.<\/p>\n
                  Par exemple, la factorielle de 10 = 10 * 9 * 8 * 7 * 6 * 5 * 4 * 3 * 2 * 1 = 3628800<\/p>\n
                  Voici le code Java de la m\u00e9thode \u00ab\u00a0factorielle\u00a0\u00bb qui calcul la factorielle d’un nombre:<\/p>\n
                  \n
                  public<\/span> int<\/span> factorielle<\/span>(<\/span>int<\/span> aValeur<\/span>)<\/span> {<\/span>\r\n    int<\/span> lResultat<\/span>;<\/span>\r\n    if<\/span> (<\/span>aValeur<\/span> ==<\/span> 0<\/span>)<\/span> {<\/span>\r\n        lResultat<\/span> =<\/span> 1<\/span>;<\/span>\r\n    }<\/span> else<\/span> {<\/span>\r\n        lResultat<\/span> =<\/span> aValeur<\/span> *<\/span> factorielle<\/span>(<\/span>aValeur<\/span> -<\/span> 1<\/span>);<\/span>\r\n    }<\/span>\r\n    return<\/span> lResultat<\/span>;<\/span>\r\n}<\/span>\r\n<\/pre>\n<\/div>\n
                  On voit que, selon l’algorithme, la base est Factorielle(0) qui donne 1; Ensuite, Factorielle(1) = 1 * Factorielle(0) = 1; Ensuite, Factorielle(2) = 2 * Factorielle(1) = 2; etc.<\/p>\n
                  Gestion des erreurs<\/h2>\n
                  Lorsqu’une routine est cr\u00e9\u00e9e, il est important de bien sp\u00e9cifier le travail, la port\u00e9e et les limites de cette routine. En effet, il faut \u00e9viter de cr\u00e9er des routines qui g\u00e8rent trop de choses et se limiter au travail que cette derni\u00e8re est cens\u00e9e faire. Dans le cas o\u00f9 l’\u00e9tat de l’appel de routine est probl\u00e9matique (par exemple arguments ou attributs des objets non valides), la routine ne doit pas se terminer normalement. Une exception doit \u00eatre lanc\u00e9e afin d’informer la routine appelante de la probl\u00e9matique.<\/p>\n
                  Les exceptions<\/h3>\n
                  Si une routine lance une exception, il faut que cette exception soit d\u00e9clar\u00e9e dans la signature de la routine. On sp\u00e9cifie cette exception en ajoutant le mot cl\u00e9 throw<\/strong>, suivie du type d’Exception \u00e0 la signature de la routine. \u00c9galement, pour lancer une exception dans le code, il faut utiliser l’instruction throw<\/strong> en y sp\u00e9cifiant un objet de type Exception<\/strong>. Voici un exemple:<\/p>\n
                  \n
                  \/**<\/span>\r\n * Additionne les \u00e9l\u00e9ments de `aListe1` et de `aListe2`.<\/span>\r\n *<\/span>\r\n * Noter que les deux listes doivent \u00eatre de la m\u00eame taille.<\/span>\r\n * @param aListe1 La premi\u00e8re liste \u00e0 additionner<\/span>\r\n * @param aListe2 La seconde liste \u00e0 additionner<\/span>\r\n * @return Liste contenant la somme des deux listes.<\/span>\r\n * @exception Exception Les listes ne sont pas de la m\u00eame taille.<\/span>\r\n **\/<\/span>\r\npublic<\/span> List<\/span><<\/span>Integer<\/span>><\/span> additionne<\/span>(<\/span>List<\/span><<\/span>Integer<\/span>><\/span> aListe1<\/span>,<\/span>\r\n        List<\/span><<\/span>Integer<\/span>><\/span> aListe2<\/span>)<\/span> throws<\/span> Exception<\/span> {<\/span>\r\n    ArrayList<\/span><<\/span>Integer<\/span>><\/span> lResultat<\/span> =<\/span> new<\/span> ArrayList<\/span><<\/span>Integer<\/span>><\/span>(<\/span>aListe1<\/span>.<\/span>size<\/span>());<\/span>\r\n    int<\/span> i<\/span>;<\/span>\r\n    if<\/span> (<\/span>aListe1<\/span>.<\/span>size<\/span>()<\/span> ==<\/span> aListe2<\/span>.<\/span>size<\/span>())<\/span> {<\/span>\r\n        for<\/span> (<\/span>i<\/span> =<\/span> 0<\/span>;<\/span> i<\/span> <<\/span> aListe1<\/span>.<\/span>size<\/span>();<\/span> i<\/span> =<\/span> i<\/span> +<\/span> 1<\/span>)<\/span> {<\/span>\r\n            lResultat<\/span>.<\/span>add<\/span>(<\/span>Integer<\/span>.<\/span>valueOf<\/span>(<\/span>aListe1<\/span>.<\/span>get<\/span>(<\/span>i<\/span>).<\/span>intValue<\/span>()<\/span> +<\/span>\r\n                        aListe2<\/span>.<\/span>get<\/span>(<\/span>i<\/span>).<\/span>intValue<\/span>()));<\/span>\r\n        }<\/span>\r\n    }<\/span> else<\/span> {<\/span>\r\n        throw<\/span> new<\/span> Exception<\/span>(<\/span>\"Les listes doivent \u00eatre de la m\u00eame taille\"<\/span>);<\/span>\r\n    }<\/span>\r\n    return<\/span> lResultat<\/span>;<\/span>\r\n}<\/span>\r\n<\/pre>\n<\/div>\n
                  On voit que cette m\u00e9thode doit recevoir deux (2) listes contenant le m\u00eame nombre d’\u00e9l\u00e9ments. Dans le cas o\u00f9 ce ne serait pas le cas, la routine lance une exception de type Exception<\/strong>. Lorsque nous verrons l’h\u00e9ritage, nous verrons que nous pouvons cr\u00e9er des types plus pr\u00e9cis d’exceptions. Pour l’instant, vous pouvez cr\u00e9er toutes vos exceptions en instanciant la classe Exception<\/strong>, comme dans l’exemple.<\/p>\n
                  Il est \u00e9galement \u00e0 noter que l’instruction throw<\/strong> termine directement l’ex\u00e9cution de la routine. Malgr\u00e9 cela, il est une bonne pratique de vous assurer de respecter une bonne logique au niveau de vos structures de contr\u00f4le. Par exemple, l’exemple pr\u00e9c\u00e9dent est correct, mais la forme ci-dessous ne devrait pas \u00eatre utilis\u00e9e<\/strong>:<\/p>\n
                  \n
                  \/**<\/span>\r\n * Additionne les \u00e9l\u00e9ments de `aListe1` et de `aListe2`.<\/span>\r\n *<\/span>\r\n * Noter que les deux listes doivent \u00eatre de la m\u00eame taille.<\/span>\r\n * @param aListe1 La premi\u00e8re liste \u00e0 additionner<\/span>\r\n * @param aListe2 La seconde liste \u00e0 additionner<\/span>\r\n * @return Liste contenant la somme des deux listes.<\/span>\r\n * @exception Exception Les listes ne sont pas de la m\u00eame taille.<\/span>\r\n **\/<\/span>\r\npublic<\/span> List<\/span><<\/span>Integer<\/span>><\/span> additionne<\/span>(<\/span>List<\/span><<\/span>Integer<\/span>><\/span> aListe1<\/span>,<\/span>\r\n        List<\/span><<\/span>Integer<\/span>><\/span> aListe2<\/span>)<\/span> throws<\/span> Exception<\/span> {<\/span>\r\n    ArrayList<\/span><<\/span>Integer<\/span>><\/span> lResultat<\/span> =<\/span> new<\/span> ArrayList<\/span><<\/span>Integer<\/span>><\/span>(<\/span>aListe1<\/span>.<\/span>size<\/span>());<\/span>\r\n    int<\/span> i<\/span>;<\/span>\r\n    if<\/span> (<\/span>aListe1<\/span>.<\/span>size<\/span>()<\/span> !=<\/span> aListe2<\/span>.<\/span>size<\/span>())<\/span> {<\/span>\r\n        throw<\/span> new<\/span> Exception<\/span>(<\/span>\"Les listes doivent \u00eatre de la m\u00eame taille\"<\/span>);<\/span>\r\n    }<\/span>\r\n    for<\/span> (<\/span>i<\/span> =<\/span> 0<\/span>;<\/span> i<\/span> <<\/span> aListe1<\/span>.<\/span>size<\/span>();<\/span> i<\/span> =<\/span> i<\/span> +<\/span> 1<\/span>)<\/span> {<\/span>\r\n        lResultat<\/span>.<\/span>add<\/span>(<\/span>Integer<\/span>.<\/span>valueOf<\/span>(<\/span>aListe1<\/span>.<\/span>get<\/span>(<\/span>i<\/span>).<\/span>intValue<\/span>()<\/span> +<\/span>\r\n                    aListe2<\/span>.<\/span>get<\/span>(<\/span>i<\/span>).<\/span>intValue<\/span>()));<\/span>\r\n    }<\/span>\r\n    return<\/span> lResultat<\/span>;<\/span>\r\n}<\/span>\r\n<\/pre>\n<\/div>\n
                  Malgr\u00e9 qu’elle est fonctionnelle et qu’elle peut m\u00eame para\u00eetre, \u00e0 premi\u00e8re vue, plus simple, les structures de contr\u00f4le de cette version peuvent causer des incompr\u00e9hensions et des ambigu\u00eft\u00e9s \u00e0 la lecture. Par exemple, quelqu’un pourrait ne pas remarquer qu’il y a un \u00ab\u00a0throw\u00a0\u00bb dans le \u00ab\u00a0if\u00a0\u00bb et se demander pourquoi la boucle \u00ab\u00a0for\u00a0\u00bb ne s’ex\u00e9cute pas, malgr\u00e9 ce cette derni\u00e8re n’est dans aucune structure de contr\u00f4le conditionnelle (\u00ab\u00a0if\u00a0\u00bb). Cette ambigu\u00eft\u00e9 pourrait donc avoir des effets dangereux dans un contexte de l’entretien \u00e0 long terme du logiciel.<\/p>\n
                  Gestion des exceptions<\/h3>\n
                  Du c\u00f4t\u00e9 de la m\u00e9thode appelante, il est important de g\u00e9rer les exceptions des m\u00e9thodes appel\u00e9es avec une structure try\/catch<\/strong>. Voici un exemple d’utilisation d’un try\/catch<\/strong>:<\/p>\n
                  \n
                  ArrayList<\/span><<\/span>Integer<\/span>><\/span> lListe1<\/span> =<\/span> new<\/span> ArrayList<\/span><<\/span>Integer<\/span>><\/span>(<\/span>5<\/span>);<\/span>\r\nArrayList<\/span><<\/span>Integer<\/span>><\/span> lListe2<\/span> =<\/span> new<\/span> ArrayList<\/span><<\/span>Integer<\/span>><\/span>(<\/span>5<\/span>);<\/span>\r\nlListe1<\/span>.<\/span>add<\/span>(<\/span>Integer<\/span>.<\/span>valueOf<\/span>(<\/span>5<\/span>));<\/span>\r\nlListe1<\/span>.<\/span>add<\/span>(<\/span>Integer<\/span>.<\/span>valueOf<\/span>(<\/span>10<\/span>));<\/span>\r\nlListe1<\/span>.<\/span>add<\/span>(<\/span>Integer<\/span>.<\/span>valueOf<\/span>(<\/span>15<\/span>));<\/span>\r\nlListe1<\/span>.<\/span>add<\/span>(<\/span>Integer<\/span>.<\/span>valueOf<\/span>(<\/span>20<\/span>));<\/span>\r\nlListe1<\/span>.<\/span>add<\/span>(<\/span>Integer<\/span>.<\/span>valueOf<\/span>(<\/span>25<\/span>));<\/span>\r\nlListe2<\/span>.<\/span>add<\/span>(<\/span>Integer<\/span>.<\/span>valueOf<\/span>(<\/span>5<\/span>));<\/span>\r\nlListe2<\/span>.<\/span>add<\/span>(<\/span>Integer<\/span>.<\/span>valueOf<\/span>(<\/span>10<\/span>));<\/span>\r\nlListe2<\/span>.<\/span>add<\/span>(<\/span>Integer<\/span>.<\/span>valueOf<\/span>(<\/span>15<\/span>));<\/span>\r\nlListe2<\/span>.<\/span>add<\/span>(<\/span>Integer<\/span>.<\/span>valueOf<\/span>(<\/span>20<\/span>));<\/span>\r\nlListe2<\/span>.<\/span>add<\/span>(<\/span>Integer<\/span>.<\/span>valueOf<\/span>(<\/span>25<\/span>));<\/span>\r\ntry<\/span> {<\/span>\r\n    List<\/span><<\/span>Integer<\/span>><\/span> lResultat<\/span> =<\/span> additionne<\/span>(<\/span>lListe1<\/span>,<\/span> lListe2<\/span>);<\/span>\r\n    for<\/span> (<\/span>Integer<\/span> element<\/span> :<\/span> lResultat<\/span>)<\/span> {<\/span>\r\n        System<\/span>.<\/span>out<\/span>.<\/span>println<\/span>(<\/span>element<\/span>);<\/span>\r\n    }<\/span>\r\n}<\/span>catch<\/span> (<\/span>Exception<\/span> exception<\/span>)<\/span> {<\/span>\r\n    System<\/span>.<\/span>out<\/span>.<\/span>println<\/span>(<\/span>\"Il manque une valeur \u00e0 la liste.\"<\/span>);<\/span>\r\n}<\/span>\r\n<\/pre>\n<\/div>\n
                  Avec l’exemple pr\u00e9c\u00e9dent, regardez ce qui arrive lorsque vous retirez une des instructions \u00ab\u00a0add\u00a0\u00bb. Normalement, le message d’erreur devrait appara\u00eetre.<\/p>\n
                  Il est \u00e9galement \u00e0 noter qu’il est possible de mettre plus d’une clause catch<\/strong> dans le cas ou le la routine appel\u00e9e peut lancer plus d’un type d’exception.<\/p>\n
                  Exceptions de type \u00ab\u00a0RuntimeException\u00a0\u00bb<\/h3>\n
                  Comme nous l’avons vu plus haut, lorsqu’une exception de type \u00ab\u00a0Exception\u00a0\u00bb est lanc\u00e9e avec un \u00ab\u00a0throw\u00a0\u00bb, il est obligatoire d’indiquer l’exception dans la signature de la m\u00e9thode et il est \u00e9galement obligatoire pour le client de g\u00e9rer cette exception avec un \u00ab\u00a0try\u00a0\u00bb.<\/p>\n
                  Par contre, il existe \u00e9galement un type d’exception qui a comme particularit\u00e9 qu’il n’exige pas d’\u00eatre g\u00e9r\u00e9. Ce type d’exception se nomme les \u00ab\u00a0RuntimeException\u00a0\u00bb.<\/p>\n
                  Prenons par exemple, une nouvelle m\u00e9thode \u00ab\u00a0duplique\u00a0\u00bb, qui retourne une liste contenant les \u00e9l\u00e9ments d’une liste multipli\u00e9s par 2. Afin d’\u00e9viter la duplication de code, nous allons utiliser la m\u00e9thode \u00ab\u00a0additionne\u00a0\u00bb que nous avons utilis\u00e9 plus haut:<\/p>\n
                  \n
                  \/**<\/span>\r\n * Multiplie par 2 les \u00e9l\u00e9ments de `aListe`.<\/span>\r\n *<\/span>\r\n * @param aListe La liste \u00e0 multiplier par 2.<\/span>\r\n * @return Liste contenant la multiplication par 2 des \u00e9l\u00e9ments de `aListe`.<\/span>\r\n **\/<\/span>\r\npublic<\/span> List<\/span><<\/span>Integer<\/span>><\/span> duplique<\/span>(<\/span>List<\/span><<\/span>Integer<\/span>><\/span> aListe<\/span>)<\/span> {<\/span>\r\n    return<\/span> additionne<\/span>(<\/span>aListe<\/span>,<\/span> aListe<\/span>);<\/span>\r\n}<\/span>\r\n<\/pre>\n<\/div>\n
                  Si on essaie de compiler cette m\u00e9thode, le compilateur nous obligera \u00e0 utiliser un \u00ab\u00a0try…catch\u00a0\u00bb afin de g\u00e9rer l’exception de la m\u00e9thode \u00ab\u00a0additionne\u00a0\u00bb (ou bien d\u00e9clarer l’exception dans la signature de la m\u00e9thode \u00ab\u00a0duplique\u00a0\u00bb, ce qui obligera le client \u00e0 g\u00e9rer l’exception avec un \u00ab\u00a0try…catch\u00a0\u00bb).<\/p>\n
                  Le probl\u00e8me, c’est qu’ici, l’exception est compl\u00e8tement illogique. Puisqu’il est impossible qu’une liste n’ait pas la m\u00eame taille qu’elle-m\u00eame, il est impossible que l’exception survienne. Nous ne devrions donc pas retourner d’exception dans la m\u00e9thode \u00ab\u00a0duplique\u00a0\u00bb. Instinctivement, nous pourrions \u00eatre tent\u00e9s de ne rien mettre dans le \u00ab\u00a0catch\u00a0\u00bb du \u00ab\u00a0try…catch\u00a0\u00bb. Comme ceci (noter qu’il s’agit d’un exemple \u00e0 ne pas reproduire<\/strong>):<\/p>\n
                  \n
                  \/**<\/span>\r\n * Multiplie par 2 les \u00e9l\u00e9ments de `aListe`.<\/span>\r\n *<\/span>\r\n * @param aListe La liste \u00e0 multiplier par 2.<\/span>\r\n * @return Liste contenant la multiplication par 2 des \u00e9l\u00e9ments de `aListe`.<\/span>\r\n **\/<\/span>\r\npublic<\/span> List<\/span><<\/span>Integer<\/span>><\/span> duplique<\/span>(<\/span>List<\/span><<\/span>Integer<\/span>><\/span> aListe<\/span>)<\/span> {<\/span>\r\n    List<\/span><<\/span>Integer<\/span>><\/span> lResultat<\/span>;<\/span>\r\n    try<\/span> {<\/span>\r\n        lResultat<\/span> =<\/span> additionne<\/span>(<\/span>aListe<\/span>,<\/span> aListe<\/span>);<\/span>\r\n    }<\/span> catch<\/span>(<\/span>Exception<\/span> laException<\/span>)<\/span> {<\/span>\r\n        \/\/ Que faire ici<\/span>\r\n    }<\/span>\r\n    return<\/span> lResultat<\/span>;<\/span>\r\n}<\/span>\r\n<\/pre>\n<\/div>\n
                  Par contre, il est une mauvaise pratique en programmation de ne rien mettre dans un \u00ab\u00a0catch\u00a0\u00bb. Apr\u00e8s tout, il est possible que nous ayons mal pens\u00e9 notre logique et qu’une exception arrive tout de m\u00eame. Donc, afin d’\u00e9viter d’avoir un \u00ab\u00a0catch\u00a0\u00bb vide et afin d’\u00e9viter que le client soit oblig\u00e9 de mettre inutilement un \u00ab\u00a0try..catch\u00a0\u00bb, on peut utiliser un \u00ab\u00a0RuntimeException\u00a0\u00bb. Comme ceci:<\/p>\n
                  \n
                  \/**<\/span>\r\n * Multiplie par 2 les \u00e9l\u00e9ments de `aListe`.<\/span>\r\n *<\/span>\r\n * @param aListe La liste \u00e0 multiplier par 2.<\/span>\r\n * @return Liste contenant la multiplication par 2 des \u00e9l\u00e9ments de `aListe`.<\/span>\r\n **\/<\/span>\r\npublic<\/span> List<\/span><<\/span>Integer<\/span>><\/span> duplique<\/span>(<\/span>List<\/span><<\/span>Integer<\/span>><\/span> aListe<\/span>)<\/span> {<\/span>\r\n    List<\/span><<\/span>Integer<\/span>><\/span> lResultat<\/span>;<\/span>\r\n    try<\/span> {<\/span>\r\n        lResultat<\/span> =<\/span> additionne<\/span>(<\/span>aListe<\/span>,<\/span> aListe<\/span>);<\/span>\r\n    }<\/span> catch<\/span>(<\/span>Exception<\/span> laException<\/span>)<\/span> {<\/span>\r\n        throw<\/span> new<\/span> RuntimeException<\/span>(<\/span>\"Un erreur interne s'est produit.\"<\/span>);<\/span>\r\n    }<\/span>\r\n    return<\/span> lResultat<\/span>;<\/span>\r\n}<\/span>\r\n<\/pre>\n<\/div>\n
                  Noter qu’il est recommand\u00e9 d’utiliser le moins possible les \u00ab\u00a0RuntimeException\u00a0\u00bb. En d’autres mots, utilisez seulement le \u00ab\u00a0RuntimeException\u00a0\u00bb lorsque cette exception ne devrait jamais \u00eatre lanc\u00e9e (et que si elle est lanc\u00e9e, il s’agit du bogue de la m\u00e9thode en tant que tel, et non celui du client).<\/p>\n
                  Les suites de tests<\/h2>\n
                  Il est important de bien tester vos routines lorsque vous en cr\u00e9ez. Il n’y a, bien entendu aucune surprise ici. Mais que veut dire \u00ab\u00a0bien tester une routine\u00a0\u00bb?<\/p>\n
                  Pour bien tester une routine, il faut valider les \u00e9l\u00e9ments suivants:<\/p>\n
                    \n
                  • \n
                      \n
                    • Que la routine fait le travail qu’elle doit faire;<\/li>\n
                    • Que la routine fait TOUT le travail qu’elle doit faire;<\/li>\n
                    • Quel la routine ne fait pas le travail qu’elle n’est pas cens\u00e9e faire.<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n
                      Ce qui nous am\u00e8ne aux diff\u00e9rents types de cas de tests:<\/p>\n
                        \n
                      • \n
                          \n
                        • Les cas normaux:\n
                            \n
                          • Valide des valeurs qui devraient valider le travail standard de la routine,<\/li>\n
                          • Souvent les seuls tests effectu\u00e9s par les programmeurs;<\/li>\n<\/ul>\n<\/li>\n
                          • Les cas erron\u00e9s:\n
                              \n
                            • Valide que des valeurs non valides lancent des exceptions,<\/li>\n
                            • Les routines n’ont pas toutes des cas erron\u00e9s;<\/li>\n<\/ul>\n<\/li>\n
                            • Les cas limites:\n
                                \n
                              • Valide que les cas aux limites normaux et erron\u00e9s sont valides,<\/li>\n
                              • Il est possible qu’il n’y ait pas de cas limite.<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n
                                Il est \u00e0 noter qu’une s\u00e9rie de tests doit g\u00e9n\u00e9ralement \u00eatre \u00ab\u00a0arrang\u00e9e avec le gars des vues\u00a0\u00bb. C’est-\u00e0-dire que les valeurs sont pr\u00e9alablement choisies et inscrites dans le code. Il n’est pas n\u00e9cessaire de faire des tests avec des valeurs al\u00e9atoires.<\/p>\n
                                Voici une classe contenant une s\u00e9rie de tests pour la routine \u00ab\u00a0additionne\u00a0\u00bb pr\u00e9sent\u00e9e plus t\u00f4t:<\/p>\n
                                \n
                                import<\/span> java.util.ArrayList<\/span>;<\/span>\r\nimport<\/span> java.util.List<\/span>;<\/span>\r\n\r\n\/**<\/span>\r\n * Programme de pour montrer la cr\u00e9ation de tests.<\/span>\r\n * <\/span>\r\n * @author Louis Marchand<\/span>\r\n * @version %I%, %G%<\/span>\r\n * <\/span>\r\n * Distribu\u00e9 sous licence MIT.<\/span>\r\n *\/<\/span>\r\n\r\npublic<\/span> class<\/span> Programme<\/span>\r\n{<\/span>\r\n\r\n    \/**<\/span>\r\n     * Additionne les \u00e9l\u00e9ments de `aListe1` et de `aListe2`.<\/span>\r\n     *<\/span>\r\n     * Noter que les deux listes doivent \u00eatre de la m\u00eame taille.<\/span>\r\n     * @param aListe1 La premi\u00e8re liste \u00e0 additionner<\/span>\r\n     * @param aListe2 La seconde liste \u00e0 additionner<\/span>\r\n     * @return Liste contenant la somme des deux listes.<\/span>\r\n     * @exception Exception Les listes ne sont pas de la m\u00eame taille.<\/span>\r\n     **\/<\/span>\r\n    public<\/span> List<\/span><<\/span>Integer<\/span>><\/span> additionne<\/span>(<\/span>List<\/span><<\/span>Integer<\/span>><\/span> aListe1<\/span>,<\/span>\r\n            List<\/span><<\/span>Integer<\/span>><\/span> aListe2<\/span>)<\/span> throws<\/span> Exception<\/span> {<\/span>\r\n        ArrayList<\/span><<\/span>Integer<\/span>><\/span> lResultat<\/span> =<\/span> new<\/span> ArrayList<\/span><<\/span>Integer<\/span>><\/span>(<\/span>aListe1<\/span>.<\/span>size<\/span>());<\/span>\r\n        int<\/span> i<\/span>;<\/span>\r\n        if<\/span> (<\/span>aListe1<\/span>.<\/span>size<\/span>()<\/span> ==<\/span> aListe2<\/span>.<\/span>size<\/span>())<\/span> {<\/span>\r\n            for<\/span> (<\/span>i<\/span> =<\/span> 0<\/span>;<\/span> i<\/span> <<\/span> aListe1<\/span>.<\/span>size<\/span>();<\/span> i<\/span> =<\/span> i<\/span> +<\/span> 1<\/span>)<\/span> {<\/span>\r\n                lResultat<\/span>.<\/span>add<\/span>(<\/span>Integer<\/span>.<\/span>valueOf<\/span>(<\/span>aListe1<\/span>.<\/span>get<\/span>(<\/span>i<\/span>).<\/span>intValue<\/span>()<\/span> +<\/span>\r\n                            aListe2<\/span>.<\/span>get<\/span>(<\/span>i<\/span>).<\/span>intValue<\/span>()));<\/span>\r\n            }<\/span>\r\n        }<\/span> else<\/span> {<\/span>\r\n            throw<\/span> new<\/span> Exception<\/span>(<\/span>\"Les listes doivent \u00eatre de la m\u00eame taille\"<\/span>);<\/span>\r\n        }<\/span>\r\n        return<\/span> lResultat<\/span>;<\/span>\r\n    }<\/span>\r\n\r\n    \/**<\/span>\r\n     * Suite de tests de la routine `additionne`.<\/span>\r\n     **\/<\/span>\r\n    public<\/span> void<\/span> testAdditionne<\/span>()<\/span> {<\/span>\r\n        testAdditionneNormal<\/span>();<\/span>\r\n        testAdditionneErrone<\/span>();<\/span>\r\n        testAdditionneLimite<\/span>();<\/span>\r\n    }<\/span>\r\n\r\n    \/**<\/span>\r\n     * Cas normal de la suite de tests de la routine `additionne`.<\/span>\r\n     **\/<\/span>\r\n    public<\/span> void<\/span> testAdditionneNormal<\/span>()<\/span> {<\/span>\r\n        ArrayList<\/span><<\/span>Integer<\/span>><\/span> lListe1<\/span> =<\/span> new<\/span> ArrayList<\/span><<\/span>Integer<\/span>><\/span>(<\/span>5<\/span>);<\/span>\r\n        ArrayList<\/span><<\/span>Integer<\/span>><\/span> lListe2<\/span> =<\/span> new<\/span> ArrayList<\/span><<\/span>Integer<\/span>><\/span>(<\/span>5<\/span>);<\/span>\r\n        List<\/span><<\/span>Integer<\/span>><\/span> lResultat<\/span>;<\/span>\r\n        lListe1<\/span>.<\/span>add<\/span>(<\/span>Integer<\/span>.<\/span>valueOf<\/span>(<\/span>5<\/span>));<\/span>\r\n        lListe1<\/span>.<\/span>add<\/span>(<\/span>Integer<\/span>.<\/span>valueOf<\/span>(<\/span>10<\/span>));<\/span>\r\n        lListe1<\/span>.<\/span>add<\/span>(<\/span>Integer<\/span>.<\/span>valueOf<\/span>(<\/span>15<\/span>));<\/span>\r\n        lListe2<\/span>.<\/span>add<\/span>(<\/span>Integer<\/span>.<\/span>valueOf<\/span>(<\/span>10<\/span>));<\/span>\r\n        lListe2<\/span>.<\/span>add<\/span>(<\/span>Integer<\/span>.<\/span>valueOf<\/span>(<\/span>20<\/span>));<\/span>\r\n        lListe2<\/span>.<\/span>add<\/span>(<\/span>Integer<\/span>.<\/span>valueOf<\/span>(<\/span>30<\/span>));<\/span>\r\n        try<\/span> {<\/span>\r\n            lResultat<\/span> =<\/span> additionne<\/span>(<\/span>lListe1<\/span>,<\/span> lListe2<\/span>);<\/span>\r\n            if<\/span> (<\/span>lResultat<\/span>.<\/span>size<\/span>()<\/span> !=<\/span> 3<\/span> ||<\/span>\r\n                    lResultat<\/span>.<\/span>get<\/span>(<\/span>1<\/span>).<\/span>intValue<\/span>()<\/span> !=<\/span> 15<\/span> ||<\/span>\r\n                    lResultat<\/span>.<\/span>get<\/span>(<\/span>2<\/span>).<\/span>intValue<\/span>()<\/span> !=<\/span> 30<\/span> ||<\/span> \r\n                    lResultat<\/span>.<\/span>get<\/span>(<\/span>3<\/span>).<\/span>intValue<\/span>()<\/span> !=<\/span> 45<\/span>)<\/span> {<\/span>\r\n                System<\/span>.<\/span>out<\/span>.<\/span>println<\/span>(<\/span>\"Cas normal non valide.\"<\/span>);<\/span>\r\n            }<\/span>\r\n        }<\/span>catch<\/span> (<\/span>Exception<\/span> exception<\/span>)<\/span> {<\/span>\r\n            System<\/span>.<\/span>out<\/span>.<\/span>println<\/span>(<\/span>\"Cas normal non valide.\"<\/span>);<\/span>\r\n        }<\/span>\r\n    }<\/span>\r\n\r\n    \/**<\/span>\r\n     * Cas erron\u00e9 de la suite de tests de la routine `additionne`.<\/span>\r\n     **\/<\/span>\r\n    public<\/span> void<\/span> testAdditionneErrone<\/span>()<\/span> {<\/span>\r\n        ArrayList<\/span><<\/span>Integer<\/span>><\/span> lListe1<\/span> =<\/span> new<\/span> ArrayList<\/span><<\/span>Integer<\/span>><\/span>(<\/span>5<\/span>);<\/span>\r\n        ArrayList<\/span><<\/span>Integer<\/span>><\/span> lListe2<\/span> =<\/span> new<\/span> ArrayList<\/span><<\/span>Integer<\/span>><\/span>(<\/span>5<\/span>);<\/span>\r\n        List<\/span><<\/span>Integer<\/span>><\/span> lResultat<\/span>;<\/span>\r\n        lListe1<\/span>.<\/span>add<\/span>(<\/span>Integer<\/span>.<\/span>valueOf<\/span>(<\/span>5<\/span>));<\/span>\r\n        lListe1<\/span>.<\/span>add<\/span>(<\/span>Integer<\/span>.<\/span>valueOf<\/span>(<\/span>10<\/span>));<\/span>\r\n        lListe1<\/span>.<\/span>add<\/span>(<\/span>Integer<\/span>.<\/span>valueOf<\/span>(<\/span>15<\/span>));<\/span>\r\n        lListe2<\/span>.<\/span>add<\/span>(<\/span>Integer<\/span>.<\/span>valueOf<\/span>(<\/span>10<\/span>));<\/span>\r\n        lListe2<\/span>.<\/span>add<\/span>(<\/span>Integer<\/span>.<\/span>valueOf<\/span>(<\/span>20<\/span>));<\/span>\r\n        try<\/span> {<\/span>\r\n            lResultat<\/span> =<\/span> additionne<\/span>(<\/span>lListe1<\/span>,<\/span> lListe2<\/span>);<\/span>\r\n            System<\/span>.<\/span>out<\/span>.<\/span>println<\/span>(<\/span>\"Cas erron\u00e9 non valide.\"<\/span>);<\/span>\r\n        }<\/span>catch<\/span> (<\/span>Exception<\/span> exception<\/span>)<\/span> {}<\/span>\r\n    }<\/span>\r\n\r\n    \/**<\/span>\r\n     * Cas limite de la suite de tests de la routine `additionne`.<\/span>\r\n     **\/<\/span>\r\n    public<\/span> void<\/span> testAdditionneLimite<\/span>()<\/span> {<\/span>\r\n        ArrayList<\/span><<\/span>Integer<\/span>><\/span> lListe1<\/span> =<\/span> new<\/span> ArrayList<\/span><<\/span>Integer<\/span>><\/span>(<\/span>5<\/span>);<\/span>\r\n        ArrayList<\/span><<\/span>Integer<\/span>><\/span> lListe2<\/span> =<\/span> new<\/span> ArrayList<\/span><<\/span>Integer<\/span>><\/span>(<\/span>5<\/span>);<\/span>\r\n        try<\/span> {<\/span>\r\n            List<\/span><<\/span>Integer<\/span>><\/span> lResultat<\/span> =<\/span> additionne<\/span>(<\/span>lListe1<\/span>,<\/span> lListe2<\/span>);<\/span>\r\n            if<\/span> (<\/span>lResultat<\/span>.<\/span>size<\/span>()<\/span> !=<\/span> 0<\/span>)<\/span> {<\/span>\r\n                System<\/span>.<\/span>out<\/span>.<\/span>println<\/span>(<\/span>\"Cas limite non valide.\"<\/span>);<\/span>\r\n            }<\/span>\r\n        }<\/span>catch<\/span> (<\/span>Exception<\/span> exception<\/span>)<\/span> {<\/span>\r\n            System<\/span>.<\/span>out<\/span>.<\/span>println<\/span>(<\/span>\"Cas limite non valide.\"<\/span>);<\/span>\r\n        }<\/span>\r\n    }<\/span>\r\n\r\n    \/**<\/span>\r\n     * Ex\u00e9cution du programme<\/span>\r\n     **\/<\/span>\r\n    public<\/span> static<\/span> void<\/span> main<\/span>(<\/span>String<\/span>[]<\/span> arguments<\/span>)<\/span> {<\/span>\r\n        Programme<\/span> programme<\/span> =<\/span> new<\/span> Programme<\/span>();<\/span>\r\n        programme<\/span>.<\/span>testAdditionne<\/span>();<\/span>\r\n    }<\/span>\r\n\r\n}<\/span>\r\n<\/pre>\n<\/div>\n
                                Retour<\/a><\/p>\n
                                 <\/p>\n
                                \n
                                Auteur: Louis Marchand
                                \n                                \"Creative<\/a>
                                \nSauf pour les sections sp\u00e9cifi\u00e9es autrement, ce travail est sous licence                                 Creative Commons Attribution 4.0 International<\/a>.<\/p>\n","protected":false},"excerpt":{"rendered":"
                                D\u00e9finitions La routine On appel routine (ou sous-routine ou sous-programme) permet d’encapsuler une portion de code (ou s\u00e9rie d’instructions) effectuant un travail bien pr\u00e9cis. La routine est identifi\u00e9e et peut \u00eatre ex\u00e9cut\u00e9e une multitude de fois \u00e0 plusieurs endroits dans le code d’un programme. Appel de routine Lorsqu’une premi\u00e8re routine ex\u00e9cute une autre routine, on… Continue reading Les routines<\/span><\/a><\/p>\n","protected":false},"author":1,"featured_media":0,"parent":0,"menu_order":0,"comment_status":"closed","ping_status":"closed","template":"","meta":{"footnotes":""},"class_list":["post-47","page","type-page","status-publish","hentry","entry"],"_links":{"self":[{"href":"https:\/\/www.louismarchand.me\/index.php\/wp-json\/wp\/v2\/pages\/47","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.louismarchand.me\/index.php\/wp-json\/wp\/v2\/pages"}],"about":[{"href":"https:\/\/www.louismarchand.me\/index.php\/wp-json\/wp\/v2\/types\/page"}],"author":[{"embeddable":true,"href":"https:\/\/www.louismarchand.me\/index.php\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.louismarchand.me\/index.php\/wp-json\/wp\/v2\/comments?post=47"}],"version-history":[{"count":8,"href":"https:\/\/www.louismarchand.me\/index.php\/wp-json\/wp\/v2\/pages\/47\/revisions"}],"predecessor-version":[{"id":560,"href":"https:\/\/www.louismarchand.me\/index.php\/wp-json\/wp\/v2\/pages\/47\/revisions\/560"}],"wp:attachment":[{"href":"https:\/\/www.louismarchand.me\/index.php\/wp-json\/wp\/v2\/media?parent=47"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}