Les méthodes - LabUnixlabunix.uqam.ca/~lord_mel/INF1120/site/notesCours/4.methodes/Note... · appel à d’autres méthodes pour accomplir sa tâche. Ces « autres méthodes » peuvent

Notes de cours Programmation I

INF1120

Version 1.1 11 octobre 2015

Les méthodes partie 1

Mélanie Lord UQAM

Programmation I - INF1120 Les méthodes – partie 1

Mélanie Lord [email protected]

2

Table des matières

1.INTRODUCTION 3

2.CONCEPTIONDEMÉTHODES 4

3.UTILISATIONDEMÉTHODES 93.1APPELSDEMÉTHODESETUTILISATIONDESRÉSULTATSRETOURNÉS 93.2NOTESSURLESDIFFÉRENTSMODESDEPASSAGEDESPARAMÈTRES 11

4.VISIBILITÉDESVARIABLESETCONSTANTES 124.1VARIABLE/CONSTANTEGLOBALEETLOCALE 124.2EXEMPLEVISIBILITÉ(PORTÉE)DESVARIABLES 13

5.PRINCIPESDECONCEPTIOND'UNEBONNEMÉTHODE 14

6.OBJECTIFSDEL'UTILISATIONDEMÉTHODES 166.1DÉCOUPAGED'UNPROBLÈMEENPETITSSOUS-PROBLÈMES 166.2RÉUTILISATIONDUCODE:ÉVITERLARÉPÉTITIONDECODE 21

7.BONNESPRATIQUESDEPROGRAMMATION 22

8.EXERCICES 238.1EXERCICESSURLADÉFINITIONDEMÉTHODES 238.2EXERCICESSURL’UTILISATIONDEMÉTHODES 248.3CRÉATIOND’UNPROGRAMMEAVECMÉTHODES 25

9.SOLUTIONSDESEXERCICES 269.1SOLUTIONSDESEXERCICESDELASECTION8.1 269.2SOLUTIONSDESEXERCICESDELASECTION8.2 28



3

1. Introduction Les méthodes permettent de découper un gros problème en petits sous-problèmes, chaque petit sous-problème étant résolu par un sous-programme (une méthode) différent. Ce partitionnement du problème général en plus petits sous-problèmes rend celui-ci beaucoup plus facile à aborder en nous permettant de résoudre un petit sous-problème à la fois. Une méthode est donc un petit programme en soi qui effectue une tâche spécifique (spécialisée). Les méthodes communiquent entre elles par l'intermédiaire d'entrées / sorties. Exemple illustratif : La vente de nouvelles de maisons se fait en plusieurs étapes, par exemple :

1. Conception des plans architecturaux pour la nouvelle maison 2. Construction de la maison selon les plans architecturaux 3. Vente ($$$) de la nouvelle maison.

Pour chaque étape, on fait appel à un spécialiste (voir fig. 1). De plus, pour qu’un spécialiste puisse accomplir sa tâche et nous fournir ce qu’on attend de lui, il a souvent besoin qu’on lui fournisse de l’information.

Figure 1

Pour construire et vendre des maisons, on fait appel à plusieurs spécialistes (architecte, entrepreneur et agent d’immeuble). Chaque spécialiste reçoit de l’information pour accomplir la tâche qu’on attend de lui et nous retourne ensuite le résultat de la tâche accomplie.



4

Une méthode est comme un spécialiste : un petit programme spécialisé dans une tâche bien spécifique. Une méthode a parfois besoin d’informations externes pour accomplir sa tâche, c’est ce qu’on appelle les entrées. Après avoir effectué sa tâche, la méthode retourne le résultat de la tâche effectuée, c’est ce qu’on appelle la (ou les) sortie(s). Les méthodes communiquent donc entre elles par l’intermédiaire d’entrées et de sorties. Dans l’exemple montré à la figure 1, on pourrait dire que le programme principal (la méthode principale) dont la tâche est de construire et vendre des maisons fait appel à 3 sous-programmes spécialisés (méthodes) :

1) l’architecte (concevoir plans) Entrée : les spécifications de la maison à construire Sortie : les plans de la maison

2) l’entrepreneur (bâtir maison) Entrée : les plans de la maison à construire Sortie : la maison construite, prête pour la vente

3) l’agent d’immeuble (vendre maison)

Entrée : la maison à vendre Sortie : montant de la vente

La méthode principale d’un programme Java est la méthode main. Celle-ci peut cependant faire appel à d’autres méthodes pour accomplir sa tâche. Ces « autres méthodes » peuvent elles-mêmes faire appel à d’autres méthodes, et ainsi de suite. Il existe déjà un grand nombre de méthodes offertes par les différentes classes du JDK (on verra sous peu les méthodes de la classe Math et de la classe String). Cependant, il est aussi possible de définir ses propres méthodes. La section suivante explique comment le faire.

2. Conception de méthodes Dans cette section, nous voyons ce qu’on appelle les méthodes de classe. Lorsque nous aborderons la partie “ objet ” du langage Java, nous verrons la distinction entre une méthode de classe et une méthode d’instance. Pour le moment, sachez qu’une méthode de classe doit toujours contenir le mot static dans son entête. De plus, nous verrons aussi, plus tard, ce que signifie le mot public dans l’entête de la méthode. Pour le moment, toutes vos méthodes doivent commencer par public static. Entête et corps d’une méthode de classe (static):

public static <typeRetour> <nomMéthode> ([liste paramètres formels]) { //déclaration constantes locales //déclaration de variables locales //instructions //retour d’une valeur du même type que typeRetour si typeRetour //n’égale pas void (return… termine l’exécution de la méthode) }



5

typeRetour : § N’importe quel type de Java § typeRetour = void si aucun retour

§ Si typeRetour n'est pas void, la méthode doit absolument toujours retourner un résultat avec l’instruction return (ne compile pas sinon).

nomMéthode :

§ Nom significatif qui rappelle ce que fait la méthode

liste paramètres formels (entrées) :

§ Zéro, un ou plusieurs (une méthode peut n'avoir aucun paramètre) § Les paramètres sont séparés par des virgules lorsqu'il y en a plusieurs § Pour chaque paramètre, on indique le type puis le nom du paramètre

valeur retournée (sortie):

§ seulement si typeRetour est différent de void § Une seule valeur peut être retournée (en Java)

§ La valeur retournée doit être du même type que celui indiqué par typeRetour (ou un type compatible par affectation)

§ On retourne une valeur avec l'instruction return

§ Une méthode termine son exécution lorsqu'elle rencontre une instruction return.

Bonne pratique de programmation :

§ Ne mettre qu'une seule instruction return dans le corps d'une méthode. § Commenter chaque méthode avec les commentaires de documentation (Javadoc) /** */. Style Java : Le nom d'une méthode s'écrit en lettres minuscules, sauf pour la première lettre du second mot et des mots subséquents qui forment le nom (comme le nom des variables). Exemples de méthodes sans paramètres ni type de retour /** * Cette methode affiche un menu de 3 options. */ public static void afficherMenu() { System.out.println("1. Option 1"); System.out.println("2. Option 2"); System.out.println("3. Option 3"); }



6

/** * Cette methode marque une pause en demandant a * l'utilisateur d'appuyer sur la touche * [ENTREE] pour continuer. */ public static void pause() { System.out.print("Appuyer sur <ENTREE> pour" + " continuer...\n\n" ); Clavier.lireFinLigne(); } Exemples de méthodes avec un paramètre, mais sans type de retour /** * Cette methode affiche nbr lignes blanches a l'ecran. * @param nbr le nombre de lignes blanches a afficher a * l'ecran. */ public static void sautLignes (int nbr) { for (int i = 0 ; i < nbr ; i++) { System.out.println(); } } /** * Cette methode affiche les résultats d'un nombre donne de * lances successifs d'un de. * Chaque lance donne un nombre entre 1 et 6. * @param nbr le nombre de lances que l'on veut effectuer. */ public static void lancerDe (int nbr) { int de; for (int i = 1 ; i <= nbr ; i++) { de = (int) (Math.random() * (6 - 1) + 1.5); System.out.println ("Lance # " + i + " : " + de); } } Exemples de méthodes sans paramètre, mais avec un type de retour /** * Cette methode calcule la somme des nombres entiers de * 1 a 10. * @return la somme des entiers de 1 a 10. */ public static int sommeUnADix () { int somme = 0; for (int i = 1 ; i <= 10 ; i++) { somme = somme + i; } return somme; }



7

/** * Cette methode tire un nombre entier au hasard, entre 1 * et 6. * @return un nombre tire au hasard entre 1 et 6. */ public static int lancerDe () { int de = (int) (Math.random() * (6 - 1) + 1.5); return de; } Exemples de méthodes avec paramètre(s) et type de retour /** * Cette methode retourne vrai si l'annee est bissextile, * faux sinon. * @param annee l'annee dont on doit determiner si elle est * bissextile ou non. * @return true si l'annee est bissextile, false * sinon. */ public static boolean estBissextile (int annee) { //vrai si l'annee est bissextile, faux sinon boolean bissex = false; if (annee % 400 == 0 || (annee % 4 == 0 && annee % 100 != 0)) { bissex = true; } return bissex; } Meilleure solution :

public static boolean estBissextile (int annee) { boolean bissex = annee % 400 == 0 || (annee % 4 == 0 && annee % 100 != 0); return bissex; }

/** * Cette methode calcule le perimetre d'un rectangle (2 * * base + 2 * hauteur). * @param base la base du rectangle. * @param hauteur la hauteur du rectangle. * @return le perimetre du rectangle (2 * base + 2 * * hauteur). */ public static double perimetreRectangle (double base, double hauteur) { return (2 * base + 2 * hauteur); }



8

/** * Cette methode saisit et valide le choix de l'utilisateur * entre borneInf et borneSup. * @param msgSoll le message de sollicitation pour le choix * de l'utilisateur. * @param msgErr le message d'erreur lorsqu'un choix est * invalide. * @param borneInf la borne inferieure pour un choix * valide. * @param borneSup la borne superieure pour un choix * valide. * @return le choix valide de l'utilisateur, entre * borneInf et borneSup. */ public static char validerChoixMenu (String msgSoll, String msgErr, char borneInf, char borneSup) { char choixMenu; System.out.print ("\n" + msgSoll); choixMenu = Clavier.lireCharLn(); while (choixMenu < borneInf || choixMenu > borneSup) { System.out.println(msgErr); System.out.print (msgSoll); choixMenu = Clavier.lireCharLn(); } return choixMenu; } Une bonne pratique de programmation consiste à n'écrire qu'un seul return dans le corps d'une méthode. Cependant, il arrive parfois qu'une méthode doive retourner différents résultats selon différentes conditions. Dans ce cas, on déclare une variable locale à laquelle on affecte la valeur de retour selon chaque condition et c'est cette variable qu'on retourne une seule fois, à la fin de la méthode. Par exemple : public static double salaire (double nbrHeures, double tauxHoraire) { if (nbrHeures <= 40) { return (nbrHeures * tauxHoraire); } else { return ((nbrHeures - 40) * tauxHoraire * 1.5 + 40 * tauxHoraire); } } peut être modifié comme suit :



9

public static double salaire (double nbrHeures, double tauxHoraire) { double salaireHebdo; if (nbrHeures <= 40) { salaireHebdo = nbrHeures * tauxHoraire; } else { salaireHebdo = (nbrHeures - 40) * tauxHoraire * 1.5 + 40 * tauxHoraire; } return salaireHebdo; //un seul return } Notes : § Une seule instruction return évite d'en oublier lorsqu'il y a de nombreuses conditions (et parfois

imbriquées les unes dans les autres). De plus, le code est plus facile à comprendre lorsqu'on n'a qu'un seul retour de méthode, à la fin de celle-ci – on sait que la méthode ne se terminera pas quelque part au milieu du code, mais bien à la fin de la méthode.

§ En Java, une méthode (avec type de retour différent de void) qui n'assure pas un retour dans tous

les cas provoque une erreur de compilation (d'autres langages provoquent parfois une erreur à l'exécution).

3. Utilisation de méthodes

3.1 Appels de méthodes et utilisation des résultats retournés Si la méthode qu'on appelle possède un ou des paramètres formels, à l'appel (l'utilisation) de cette méthode, on doit fournir un paramètre effectif pour chaque paramètre formel défini dans l'entête de la méthode (dans le même ordre). Les paramètres effectifs ne doivent pas nécessairement avoir le même nom que les paramètres formels. Lors d'un appel de méthode, chaque paramètre formel prend la valeur de son paramètre effectif correspondant (la valeur du paramètre effectif est affectée au paramètre formel correspondant) et le corps de la méthode s'exécute avec ces valeurs effectives lors de l’appel. Le paramètre effectif doit être d'un type compatible par affectation au paramètre formel : parametreFormel = paramEffectif (doit être légal sinon ne compile pas)

Conversions implicites légales pour l’affectation (rappel)

byte -> short -> int -> long -> float -> double

ou char -> int -> long -> float -> double



10

Exemples d'appels de méthodes (voir méthodes définies dans la section 2) short nbr = 10; double nbrReel = 12.3; boolean bissex; char choix; int nombre; char min = '1'; char max = '4'; afficherMenu(); pause(); sautLignes (24); lancerDe (nbr); //short compatible par affectation à un

//int

lancerDe (nbrReel); //Ne compile pas (un double n'est pas //compatible par affectation à un int => on ne //peut pas mettre un double dans un int. Les méthodes avec un type de retour autre que void peuvent être utilisées dans des expressions, comme des valeurs du type de retour de la méthode. Exemples : int somme = sommeUnADix (); System.out.println(sommeUnADix()); nombre = sommeUnADix() + lancerDe(); while (lancerDe() <= 3) { System.out.println("Plus petit ou egal a trois."); } bissex = estBissextile (2012); if (bissex) { ... } ou directement : if (estBissextile(2012)) { ... } System.out.println (estBissextile (1998 + lancerDe())); nbrReel = perimetreRectangle (13.2, 9);



11

choix = validerChoixMenu ("Entrez votre choix : ", "Erreur, vous devez entrer une valeur entre " + min + " et " + max + ". Recommencez...\n", min, max); Lors de la conception d'une méthode, on peut aussi utiliser (appeler) d'autres méthodes : /** * Cette methode presente le logiciel. */ public static void presenterLogiciel () { System.out.println("Ce programme permet de ... \n"); pause(); //appel d'une methode dans le corps d'une //autre methode }

3.2 Notes sur les différents modes de passage des paramètres Passage de paramètre par valeur

§ C'est la valeur du paramètre effectif qui affecté au paramètre formel lors de l'appel d'une méthode.

Passage de paramètre par référence (adresse mémoire)

§ C'est la référence (l'adresse mémoire) du paramètre effectif qui est affecté au paramètre formel lors de l'appel d'une méthode.

En Java, les paramètres sont passés par valeur. Par conséquent, on ne peut pas modifier la valeur d'un paramètre effectif de type primitif à l'intérieur d'une méthode. Par exemple : public class Test { public static void testPassageParam (int entier) { entier = entier - 2; } public static void main (String [] params) { int unEntier = 6; testPassageParam (unEntier); System.out.println (unEntier); //6 sera affiché ici } }

Pour obtenir la nouvelle valeur calculée par la méthode testPassageParam, on doit lui ajouter un type de retour, comme ceci :



12

public class Test { public static int testPassageParam (int entier) { int unAutreEntier = entier - 2; return unAutreEntier; } public static void main (String [] params) { int unEntier = 6; unEntier = testPassageParam (unEntier); System.out.println (unEntier); //4 sera affiché ici } }

4. Visibilité des variables et constantes Rappel : une variable est visible (existe) à l'intérieur du bloc (et tous ses sous-blocs) dans lequel elle a été déclarée. En Java, un bloc est délimité par une accolade ouvrante et une accolade fermante. Une classe est un bloc, délimitée par une accolade ouvrante et fermante. Une méthode est aussi un bloc, délimitée par une accolade ouvrante et fermante.

4.1 Variable/constante globale et locale Une variable/constante globale est une variable ou constante déclarée dans le bloc de la classe. Puisque toutes les méthodes d'une classe sont elles-mêmes déclarées dans le bloc de la classe, les variables/constantes globales sont aussi visibles (existent) dans toutes les méthodes de cette classe. Les variables/constantes globales peuvent donc être utilisées (consultées ou modifiées dans le cas de variables) par toutes les méthodes sans avoir été transmises préalablement en paramètres. Une variable/constante locale est une variable ou constante déclarée dans le bloc d'une méthode et n'est visible qu'à l'intérieur de cette méthode.



13

4.2 Exemple visibilité (portée) des variables public class Coiffure { //variable globale (visible dans toute la classe) - A PROSCRIRE public static String postiche = ""; //constante globale (visible dans toute la classe) public final static int MOUMOUTTE = 10; public static String couper (int cheveuxACouper) { //constante locale final String MSG_MOUMOUTTE_1 = "Procurez-vous un toupet !"; final String MSG_MOUMOUTTE_2 = "Une perruque serait un luxe !"; //variable locale String perruque = ""; //pas assez de cheveux a couper if (cheveuxACouper < MOUMOUTTE) { //constante globale perruque = MSG_MOUMOUTTE_1; } else { perruque = MSG_MOUMOUTTE_2; } return perruque; } //fin couper public static void main (String [] args) { //constantes locales final String MSG_NBR_CHEVEUX = "Entrez le nombre de cheveux a couper: "; //variables locales int poils; System.out.println(MSG_NBR_CHEVEUX); poils = Clavier.lireInt (); //modification de la variable globale postiche postiche = couper (poils); //consultation et affichage de la variable globale postiche System.out.println (postiche); } //fin main } //fin classe



14

Bonne pratique de programmation : Principe de localité : toute variable devrait, en tout temps, être déclarée aussi localement que possible. Si l'utilisation d'une variable est locale, cela a du sens de la déclarer localement. Il est considéré comme une bonne pratique de programmation d'éviter, autant que possible, l'utilisation de variables globales. Dans le cadre de ce cours, ÉVITER OBLIGATOIREMENT l'utilisation de VARIABLES GLOBALES. Lorsqu'une variable doit être utilisée par plusieurs méthodes, on la passe en paramètre. Pourquoi éviter les variables globales ? 1. L'utilisation de variables globales rend plus difficiles la compréhension, le débogage et la

modification d'un programme : § Débogage : lorsqu'une variable globale se retrouve avec une valeur erronée, la source

de l'erreur est beaucoup plus ardue à déceler, car cette variable a pu être modifiée par n'importe quelles méthodes dans le programme.

§ Modification : il est beaucoup plus difficile de modifier le traitement d'une variable

globale, car il faut avoir une vision globale du programme original en comprenant bien dans quelle(s) méthode(s) et sous quelles conditions cette variable globale est utilisée et modifiée.

2. Rend difficile la réutilisation des méthodes

Une méthode qui utilise une variable globale devient dépendante du comportement des autres méthodes qui utilisent (consultation, modification) aussi cette même variable globale. Elle devient donc difficilement réutilisable, de manière autonome, dans un autre contexte (couplage fort).

3. Gestion concurrente de la mémoire (multi-threading)

Plusieurs tâches s'exécutant en parallèle et ayant accès à une même variable globale peuvent provoquer des incohérences de la valeur de cette variable en cours d'exécution (en l'absence de verrous appropriés).

En ce qui concerne les constantes, étant donné que celles-ci ne sont pas modifiées en cours d'exécution, on peut les déclarer globalement sans subir les inconvénients reliés aux variables globales.

5. Principes de conception d'une bonne méthode Couplage faible : Un couplage faible permet aux méthodes de conserver leur autonomie et facilite la réutilisation. L'échange d'informations entre les méthodes par l'intermédiaire de paramètres (paramétrisation) permet un couplage beaucoup plus faible que par l'intermédiaire de variables globales.



15

Cohésion forte : Une méthode doit être dédiée à une seule et unique tâche bien spécifique (spécialisation). Ceci facilite la réutilisation dans d'autres contextes. Par exemple, une méthode qui affiche l'aire et le périmètre d'un rectangle ne pourra pas être réutilisée dans un contexte où l'on ne désire que l'affichage de l'aire. Il vaudrait mieux, en ce cas, faire deux méthodes, une qui calcule le périmètre et une qui calcule l'aire. Robustesse : Une méthode doit prévoir et gérer efficacement, selon le contexte, les différents cas d'erreurs possibles et ainsi ne devrait jamais provoquer d'erreurs à l'exécution. Exemple robustesse Qu'est-ce qui risque de provoquer une erreur à l'exécution dans la méthode suivante (à part le fait d'entrer autre chose que des entiers) ?

public static int calculerMoyenneEntiere () { int somme = 0; int nbr; int cpt = 0; do { System.out.print ("Entrez un nombre (0 pour terminer) :"); nbr = Clavier.lireIntLn(); if (nbr != 0) { somme = somme + nbr; cpt++; } } while (nbr != 0); return (somme / cpt); } Pour rendre cette méthode plus robuste, on devrait gérer la possibilité d'une division par zéro :

public static int calculerMoyenneEntiere () { int somme = 0; int nbr; int cpt = 0; int moyenne = 0; do { System.out.print ("Entrez un nombre (0 pour terminer) :"); nbr = Clavier.lireIntLn(); if (nbr != 0) { somme = somme + nbr; cpt++; } } while (nbr != 0); if (somme != 0) { moyenne = somme / cpt; } return moyenne; }



16

Commentaires : Pour aider à la compréhension du code (et donc faciliter l’utilisation, les modifications et le débogage) :

§ Toutes les méthodes doivent être bien documentées à l’aide des commentaires de documentation (Javadoc).

§ Le code dans le corps d'une méthode doit être commenté lorsque pertinent. § Les variables et constantes doivent être commentées (dire ce qu’elles contiennent).

/** * Cette methode retourne vrai si l'annee est bissextile, * faux sinon. * @param annee l'annee dont on doit déterminer si elle * est bissextile ou non. * @return boolean true si l'annee est bissextile, false * sinon. */ public static boolean estBissextile (int annee) { //vrai si l'annee est bissextile, faux sinon boolean bissex = false; if (annee % 400 == 0 || (annee % 4 == 0 && annee % 100 != 0)) { bissex = true; } return bissex; }

6. Objectifs de l'utilisation de méthodes

6.1 Découpage d'un problème en petits sous-problèmes L’utilisation de méthodes nous permet de formuler une solution globale complexe en résolvant plusieurs petits sous-problèmes plus simples, un à la fois. Exemple : Par exemple, pour le problème du calcul du salaire hebdomadaire selon le nombre d’heures travaillées et le taux salarial horaire entrés par un utilisateur, on peut découper ce problème en petits sous-problèmes plus simples à résoudre : 1. Présenter le logiciel

o Pauser le programme 2. Saisir et valider le nombre d’heures travaillées 3. Saisir et valider le taux horaire 4. Calculer le salaire 5. Afficher le salaire 6. Afficher fin du programme



17

On peut ensuite faire une méthode (sous-programme) pour résoudre chacun de ces petits sous-problèmes.

Figure 2. Diagramme hiérarchique du programme calculer salaire hebdomadaire En Java … public class CalculerSalaireAvecMethodesV1 { // ------------ // CONSTANTES // ------------ //le taux salarial horaire maximum public static final double TAUX_MAX = 17.35; //le taux salarial horaire minimum public static final double TAUX_MIN = 8.55; //Le nombre max valide d'heures travaillees public static final double NBR_HR_MAX = 80; //Le nombre min valide d'heures travaillees public static final double NBR_HR_MIN = 0; //le nombre d'heures normal pour une semaine public static final double NBR_HR_NORMAL = 40; //facteur multiplicatif du salaire pour les heures sup. public static final double TEMPS_SUP = 1.5; //message de sollicitation du taux horaire public static final String MSG_SOL_TAUX_HORAIRE = "Entrez le taux horaire : "; //message de sollicitation du nombre d'heures travaillees public static final String MSG_SOL_NBR_HEURES = "Entrez le nombre d’heures " + "travaillées : ";



18

//message d'erreur pour un taux horaire invalide public static final String MSG_ERR_TAUX_HORAIRE = "Erreur. Le taux horaire " + "doit se trouver entre " + TAUX_MIN + " et " + TAUX_MAX + " inclusivement.\n"; //message d'erreur pour un nombre d'heures invalide public static final String MSG_ERR_NBR_HEURES = "Erreur. Le nombre d'heures " + "doit se trouver entre " + NBR_HR_MIN + " et " + NBR_HR_MAX + " inclusivement.\n"; //message de présentation du logiciel public static final String MSG_PRESENTATION = "Ce logiciel permet de " + "calculer les salaires\nhebdomadaires des employes d'une " + "entreprise.\n\n\n"; //message de fin du programme public static final String MSG_FIN = "\n\n\n\n\nFin normale du programme."; // ------------ // METHODES // ------------ /** * Provoque l'arret du programme et demande d'entrer un * ENTER pour continuer. */ public static void pause () { System.out.print("Taper ENTER pour continuer..."); Clavier.lireFinLigne(); System.out.println("\n"); } /** * Affiche une breve presentation du logiciel. */ public static void presenterLogiciel () { System.out.println(MSG_PRESENTATION); pause(); //appel de la methode pause() } /** * Valide un nombre d'heures entre NBR_HR_MIN et * NBR_HR_MAX puis retourne le nombre saisi et valide. * @return un nombre d'heures valide. */ public static double validerNbrHeures() { double nbrHr; //le nbr heures saisi //saisir et valider le nombre d'heures travaillees System.out.print(MSG_SOL_NBR_HEURES); nbrHr = Clavier.lireDouble(); while (nbrHr < NBR_HR_MIN || nbrHr > NBR_HR_MAX) { System.out.println(MSG_ERR_NBR_HEURES); System.out.print(MSG_SOL_NBR_HEURES); nbrHr = Clavier.lireDouble(); } return nbrHr; }



19

/** * Valide un taux salarial horaire entre TAUX_MIN et * TAUX_MAX puis retourne le taux saisi et valide. * @return un taux horaire valide */ public static double validerTauxHoraire () { double tauxHr; //le taux salarial horaire saisi //saisir et valider le taux salarial horaire System.out.print(MSG_SOL_TAUX_HORAIRE); tauxHr = Clavier.lireDouble(); while (tauxHr < TAUX_MIN || tauxHr > TAUX_MAX) { System.out.println(MSG_ERR_TAUX_HORAIRE); System.out.print(MSG_SOL_TAUX_HORAIRE); tauxHr = Clavier.lireDouble(); } return tauxHr; } /** * Calcule le salaire hebdomadaire selon le nombre d'heures * travaillees et le taux salarial horaire donnes. Les heures * travaillees apres NBR_HR_NORMAL heures sont calculees a temps * et demi. * @param nbrHr le nombre d'heures travaillees. * @param tauxHr le taux salarial horaire. * @return le salaire hebdomadaire. */ public static double calculerSalaireHebdo (double nbrHr, double tauxHr) { double salaire; //le salaire hebdo calcule //calcul du salaire selon que le nombre d'heures depasse ou non //NBR_HR_NORMAL. if (nbrHr <= NBR_HR_NORMAL) { salaire = nbrHr * tauxHr; } else { salaire = (nbrHr - NBR_HR_NORMAL) * tauxHr * TEMPS_SUP + NBR_HR_NORMAL * tauxHr; } return salaire; } /** * Affiche le salaire hebdomadaire donne (arrondi a 2 decimales). * @param salaireHebdo le salaire a afficher. */ public static void afficherSalaireHebdo (double salaireHebdo) { System.out.printf("\nSalaire hebdomadaire : %10.2f $\n\n", salaireHebdo); } /** * Affiche un message de fin du programme. */ public static void afficherFinProg () { System.out.println(MSG_FIN); }



20

/** * Application de calcul de salaires hebdomadaires. * @param params (tableau vide) */ public static void main(String[] params) { //declarations des variables double nbrHeures; //le nombre d'heures travaillees double tauxHoraire; //le taux salariale horaire double salaireHebdo; //le salaire hebdomadaire //presenter le logiciel presenterLogiciel(); //saisir et valider le nbr d'heures travaillees nbrHeures = validerNbrHeures(); while (nbrHeures != NBR_HR_MIN) { //saisir et valider le taux horaire tauxHoraire = validerTauxHoraire(); //Calculer le salaire hebdo salaireHebdo = calculerSalaireHebdo (nbrHeures, tauxHoraire); //afficher le salaire hebdo afficherSalaireHebdo(salaireHebdo); //saisir et valider le nbr d'heures travaillees nbrHeures = validerNbrHeures(); } //fin tant que //afficher la fin du programme afficherFinProg(); } //fin main } //fin classe



21

6.2 Réutilisation du code : éviter la répétition de code Exemple : Soit les deux bouts de code suivants pour saisir et valider une année (entre 1980 et 2007) et un mois (entre 1 et 12).

int annee; System.out.print("Entrez l'annee : "); annee = Clavier.lireInt(); while (annee < 1980 || annee > 2007) { System.out.println("Annee invalide... recommencez!"); System.out.print("Entrez l'annee : "); annee = Clavier.lireInt(); }

int mois; System.out.print("Entrez le mois : "); mois = Clavier.lireInt(); while (mois < 1 || mois > 12) { System.out.println("Mois invalide... recommencez!"); System.out.print("Entrez le mois : "); mois = Clavier.lireInt(); }

On remarque que le code est très similaire pour les deux validations. Seul les messages et les valeur minimum et maximum pour la validation changent. On pourrait donc faire une seule méthode, validerEntier, qui prend en paramètres les valeurs qui varient d’une validation à l’autre.

public static int validerEntier(String msgSoll, String msgErr, int min, int max) { int unEntier; //entier valide a retourner do { System.out.print(msgSoll); unEntier = Clavier.lireInt(); if (unEntier < min || unEntier > max) { System.out.println("\n" + msgErr); } } while (unEntier < min || unEntier > max); return unEntier; }

On peut alors réutiliser cette méthode pour valider et l’année, et le mois.



22

public static void main (String [] params) { int annee; int mois; //utilisation d'une seule méthode pour saisir et valider //l'annee ainsi que le mois annee = validerEntier("Entrez l'annee : ", "Erreur, l'annee doit etre entre 1980 et 2007", 1980, 2007); mois = validerEntier("Entrez le mois : ", "Erreur, le mois doit etre entre 1 et 12", 1, 12);

}

Note : Voir aussi un autre exemple dans la classe CalculerSalaireAvecMethodesV2.java, où l’on utilise la méthode validerReel pour saisir et valider le nombre d’heures travaillées et le taux salarial horaire (réutilisation de code).

7. Bonnes pratiques de programmation

Déclarer les constantes/variables locales au début de la méthode. Ne mettre qu'une seule instruction return dans le corps d'une méthode (s’il y a lieu). Commenter chaque méthode avec les commentaires de documentation (Javadoc) . Principe de localité : toute variable devrait être déclarée aussi localement que possible. Éviter les variables globales (éviter le couplage fort). Une méthode devrait être fortement cohésive (spécialisée) et robuste.



23

8. Exercices

8.1 Exercices sur la définition de méthodes Exercice 1 La méthode suivante ne compile pas. Dites pourquoi et donnez une correction possible. public static double rabais (double prix) { if (prix > 500) { return 0.5 * prix; } else if (prix > 200) { return 0.25 * prix; } else if (prix <= 50) { return 0.1 * prix; } } Exercice 2 Vous devez écrire une méthode qui calcule la note finale d’un cours pour un étudiant à partir de la note de ses deux examens (par exemple, l’intra et le final) et du pourcentage alloué pour chacun des deux examen. La méthode prend donc 4 paramètres (note examen 1, note examen 2, pourcentage examen1 et pourcentage examen 2, et doit retourner la note finale sous forme de caractère, selon le barème suivant :

'A' : [90 - 100] 'B' : [80 - 90[ 'C' : [70 - 80[ 'D' : [60 - 70[ 'E' : < 60 Si la note de l’examen 1 ou la note de l’examen 2 ou le pourcentage de l’examen 1 ou le pourcentage de l’examen 2 ne sont pas entre 0 et 100 inclusivement, la méthode doit retourner le caractère '*'. Si la somme du pourcentage de l’examen 1 et du pourcentage de l’examen 2 n’égale pas 100, la méthode retourne aussi le caractère '*'. Les notes des examens sont des nombres réels et les pourcentages alloués sont des nombres entiers. Écrivez la Javadoc de votre méthode (commentaires de documentation)



24

8.2 Exercices sur l’utilisation de méthodes Exercice 1 Supposons les deux méthodes suivantes : /** * Cette méthode tire au hasard un nombre entier entre 1 et 6 et * retourne ce nombre. De plus, elle affiche le résultat obtenu * ainsi que le nom du joueur qui a obtenu ce résultat. * Par exemple, supposons cet appel de méthode : * int de = lancerDe("Marc"); * si le résultat retourné est 5, la méthode affichera : * "Marc obtient un 5" * * @param nomJoueur le nom affiché par la méthode * @return int un nombre tiré au hasard entre 1 et 6 */ public static int lancerDe (String nomJoueur){...} /** * Cette méthode retourne vrai si le nombreTire est égal à 6, * faux sinon. * @param nombreTire entier entre 1 et 6 * @return boolean true si nombreTire == 6, false sinon. */ public static boolean partieGagnante (int nombreTire) {...} Il s’agit d’écrire un programme (une méthode main) qui demande à l’utilisateur d’entrer le nom d’un premier joueur puis d’un deuxième joueur. Ensuite, le programme lance un dé pour le premier joueur, et affiche le résultat à l’écran. Puis il lance un dé pour le deuxième joueur, et affiche le résultat à l’écran, et ainsi de suite jusqu’à ce qu’un des deux joueurs obtienne un 6. Dans ce cas, la partie se termine et le programme affiche le joueur gagnant (celui qui a eu un 6). Vous devez utiliser les deux méthodes lancerDe et partieGagnante dans votre programme. Supposez qu’elles existent. Exemples d’exécution

Entrez le nom du premier joueur : mel Entrez le nom du deuxième joueur : julio mel obtient un 4 julio obtient un 2 mel obtient un 2 julio obtient un 6 julio a gagné la partie!

Entrez le nom du premier joueur : mel Entrez le nom du deuxième joueur : julio mel obtient un 3 julio obtient un 2 mel obtient un 2 julio obtient un 4 mel obtient un 6 mel a gagné la partie!



25

Exercice 2 Cette méthode main ne compile pas. Trouvez l’erreur et suggérez une correction. public static void main (String [] params) { int entier; System.out.println("Entrez un entier : "); Clavier.lireInt(); System.out.println(entier); }

Exercice 3 Étant donné les déclarations et les méthodes suivantes : int i = 0; float j = 0f; boolean b = true; String caractere = "k"; double d = 0; byte e = 8; public static boolean estUneLettreMajuscule(char c) {...} public static int validerEntier(int min, int max) {...} public static double max (float nbr1, double nbr2, int nbr3, byte nbr4, long nbr5) {...} Dites si les instructions suivantes compilent ou non. Pour celles qui ne compilent pas, donnez-en la raison et une correction possible.

a) if (estUneLettreMajuscule('d')) {} b) j = validerEntier(1, 4); c) d = max (2, 3, 89, 34, 0); d) validerEntier ((byte)4, (int)d); e) b = estUnelettreMajuscule('M'); f) j = max((float)2, d, i, (byte)34, (long)i); g) i = validerEntier (i, int(d)); h) d = validerEntier('a', 'c'); i) b = estUneLettreMajuscule(caractere); j) d = max ((float)validerEntier(5, 8), 5.0, 7, e, i); k)

8.3 Création d’un programme avec méthodes Reprenez le problème de votre TP1, et divisez-le en sous-problèmes. Vous pouvez vous aider d’un diagramme hiérarchique pour ce faire. Ensuite, codez votre solution en Java, dans laquelle chaque sous-problème est résolu par une méthode spécifique. Inspirez-vous de l’exemple avec calculer salaire (classe CalculerSalaireAvecMethodesV1.java) Testez votre programme avec la stratégie de vérification que vous avez conçue dans le cadre du TP1.



26

9.Solutions des exercices

9.1 Solutions des exercices de la section 8.1 Exercice 1 //correction : public static double rabais (double prix) { if (prix > 500) { return 0.5 * prix; } else if (prix > 200) { return 0.25 * prix; } else if (prix <= 50) { return 0.1 * prix; } else { return 0; } } //Autre correction possible : public static double rabais2 (double prix) { double rabais = 0; if (prix > 500) { rabais = 0.5 * prix; } else if (prix > 200) { rabais = 0.25 * prix; } else if (prix <= 50) { rabais = 0.1 * prix; } return rabais; }

Exercice 2 /** * Calcule la note finale (A, B, C, D ou E) d'un etudiant a partir de la * note de ses deux examens et du pourcentage alloue pour chacun des examens. * Le bareme utilise est le suivant: * A : [90 - 100] * B : [80 - 90[ * C : [70 -80[ * D : [60 - 70[ * E : < 60 * * @param noteExa1 la note de l'examen 1 sur 100 * @param pourcentExa1 pourcentage de la note finale de l'examen 1 * @param noteExa2 la note de l'examen 2 sur 100 * @param pourcentExa2 pourcentage de de la note finale pour l'examen 2 * @return la note finale en lettre ('A', 'B', 'C', 'D' ou 'E') ou bien, Si * noteExa1 ou noteExa2 ou pourcentExa1 ou pourcentExa2 ne sont pas entre 0 * et 100 inclusivement, retourne le caractere '*'. Si pourcentExa1 + * pourcentExa2 != 100, retourne le caractere '*'. */



27

public static char noteFinaleEnLettre(double noteExa1, int pourcentExa1, double noteExa2, int pourcentExa2) { char noteFinaleEnLettre; double noteFinaleEnNombre; if ((noteExa1 < 0 || noteExa1 > 100) || (noteExa2 < 0 || noteExa2 > 100) || (pourcentExa1 < 0 || pourcentExa1 > 100) || (pourcentExa2 < 0 || pourcentExa2 > 100) || (pourcentExa1 + pourcentExa2) != 100) { noteFinaleEnLettre = '*'; } else { noteFinaleEnNombre = (noteExa1 * pourcentExa1) / 100 + (noteExa2 * pourcentExa2) / 100; if (noteFinaleEnNombre < 60) { noteFinaleEnLettre = 'E'; } else if (noteFinaleEnNombre < 70) { noteFinaleEnLettre = 'D'; } else if (noteFinaleEnNombre < 80) { noteFinaleEnLettre = 'C'; } else if (noteFinaleEnNombre < 90) { noteFinaleEnLettre = 'B'; } else { noteFinaleEnLettre = 'A'; } } return noteFinaleEnLettre; }



28

9.2 Solutions des exercices de la section 8.2 Exercice 1 public static void main (String [] params) { String nom1; String nom2; int de1; int de2 = 0; System.out.print("Entrez le nom du premier joueur : "); nom1 = Clavier.lireString(); System.out.print("Entrez le nom du deuxième joueur : "); nom2 = Clavier.lireString(); do { de1 = lancerDe(nom1); if (!partieGagnante(de1)) { de2 = lancerDe(nom2); } } while (!partieGagnante(de1) && !partieGagnante(de2)); if (partieGagnante(de1)) { System.out.println ("\n" + nom1 + " a gagné la partie!"); } else { System.out.println ("\n" + nom2 + " a gagné la partie!"); } }

Exercices 2 À la ligne System.out.println(entier); on tente d’afficher une variable (entier) qui n’a pas été initialisée, car la valeur retournée par Clavier.lireInt() n’a pas été stockée, par affectation, dans la variable entier. Correction : L’instruction Clavier.lireInt(); devrait être remplacée par entier = Clavier.lireInt(); Exercices 3

a) if (estUneLettreMajuscule('d')) {} compile

b) j = validerEntier(1, 4);

compile

c) d = max (2, 3, 89, 34, 0); ne compile pas parce que le paramètre effectif 34, considéré comme un int, ne peut pas être converti en byte. Solution possible : d = max (2, 3, 89, (byte)34, 0);



29

d) validerEntier ((byte)4, (int)d); compile

e) b = estUnelettreMajuscule('M');

ne compile pas, car cette méthode n’existe pas (elle est mal écrite) Solution possible : b = estUneLettreMajuscule('M');

f) j = max((float)2, d, i, (byte)34, (long)i);

ne compile pas, car j est est de type float et la méthode max retourne un double et un double ne pas être affecté dans une variable de type float.

g) i = validerEntier (i, int(d));

ne compile pas, car int(d) n’est pas une expression valide. Solution possible : i = validerEntier (i, (int)d);

h) d = validerEntier('a', 'c');

compile i) b = estUneLettreMajuscule(caractere);

ne compile pas, car cette méthode prend en paramètre un type char et on lui envoie ici un type String. Solution possible : b = estUneLettreMajuscule('b');

j) d = max ((float)validerEntier(5, 8), 5.0, 7, e, i); compile

Documents

Les méthodes - LabUnixlabunix.uqam.ca/~lord_mel/INF1120/site/notesCours/4.methodes/Note... · appel à d’autres méthodes pour accomplir sa tâche. Ces « autres méthodes » peuvent