Les méthodes en Java

INF1120 – Programmation I

Mélanie Lord
Université du Québec à Montréal

lord.melanie@uqam.ca
 INF1120 - Programmation I : Les méthodes en Java

Introduction
Une méthode est comme un spécialiste…

2
 INF1120 - Programmation I : Les méthodes en Java

! La méthode principale d’un programme Java est la méthode main.

! main peut faire appel à d’autres méthodes, qui peuvent faire appel à d’autres
méthodes, et ainsi de suite.
! Méthodes existantes et méthodes que vous pouvez définir.

Définition et utilisation de méthodes

Définition d'une méthode
Entête et corps d’une méthode de classe publique (public static)
public static <typeRetour> <nomMéthode> ([paramètres formels]) {

constantes locales

variables locales

instructions

retour d’une valeur de type typeRetour (si pas void)

(return... termine l’exécution de la méthode)
}

3
 INF1120 - Programmation I : Les méthodes en Java

Style Java :
- Nom des méthodes : lettres minuscules, sauf pour la première lettre du second
mot et des mots subséquents qui forment le nom (comme les noms de variables).

- Javadoc : l'entête d'une méthode doit être documenté avec un commentaire de

documentation (/**… */) : on donne une description claire et précise de ce que fait la
méthode, et l'on utilise les étiquettes @param et @return pour documenter les
paramètres et le type de retour (voir exemples plus loin).

Utilisation (appel) d'une méthode

! La définition d'une méthode ne fait rien en soi. Il faut qu'une autre méthode
(la méthode appelante) appelle la méthode (méthode appelée) pour que
cette dernière s'exécute.
o Lors de l'exécution d'un programme, la méthode main est la première appelée (par la JVM).
Ensuite, la méthode main peut appeler d'autres méthodes, qui peuvent à leur tour en appeler
d'autres, et ainsi de suite.

! Pour appeler une méthode, on utilise son nom, et l'on doit lui fournir, entre
les parenthèses, des valeurs (paramètres effectifs) pour chacun des
paramètres formels indiqués dans sa définition (dans le même ordre).

4
 INF1120 - Programmation I : Les méthodes en Java

! S'il n'y a aucun paramètre formel dans la définition, on laisse les parenthèses
vides.
! Chaque paramètre effectif doit être compatible par affectation avec son
paramètre formel correspondant.
Rappel conversions implicites légales pour l’affectation
byte -> short -> int -> long -> float -> double
char -> int -> long -> float -> double
! Si la méthode appelée n'est pas dans la même classe que la méthode
appelante, on doit préfixer l'appel du nom de la classe dans laquelle est
définie la méthode appelée.
! Les méthodes avec un type de retour (autre que void) peuvent être utilisées
dans des expressions, comme des valeurs de ce type.

Exemple d'appel :
//Appel de la méthode lireInt, sans paramètre, qui se
//trouve dans la classe nommée Clavier
int i = Clavier.lireInt();

Les définitions des méthodes suivantes, avec les exemples d'appels, se trouvent dans le
fichier ExemplesUtilisationMethodes.java.
5
 INF1120 - Programmation I : Les méthodes en Java

Exemples de méthodes sans paramètre(s) 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");
}

/**
* 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();
}

6
 INF1120 - Programmation I : Les méthodes en Java

Exemples d'appels :

afficherMenu();

pause();

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();
}
}

7
 INF1120 - Programmation I : Les méthodes en Java

/**
* 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 d'appels :
sautLignes(); //Ne compile pas car il manque un param. effectif

//Ne compile pas car entier n'est pas initialise

int entier;
sautLignes(entier);

8
 INF1120 - Programmation I : Les méthodes en Java

sautLignes(4); //OK, affiche 4 lignes blanches

int nombre = 10;

sautLignes(nombre); //OK, affiche 10 lignes blanches

//OK : short est compatible par affectation au param. formel de

//type int (on peut mettre un short dans un int).
//Affiche 7 lignes blanches
short nbr = 7;
lancerDe(nbr);

//Ne compile pas car un double n'est pas compatible par

//affectation au param. formel de type int (on ne peut pas
//mettre un double dans un int)
double nbrReel = 12.34;
lancerDe (nbrReel);

lancerDe ('!'); //Compile ou non ?

9
 INF1120 - Programmation I : Les méthodes en Java

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;
}

/**
* 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;
}
10
 INF1120 - Programmation I : Les méthodes en Java

Exemples d'appels :

int nombre = sommeUnADix();

System.out.println("Somme : " + sommeUnADix());

nombre = sommeUnADix() * lancerDe();

while (lancerDe() <= 5) {

System.out.println("Plus petit ou egal a cinq.");
}

11
 INF1120 - Programmation I : Les méthodes en Java

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 bissextile.
* @return true si l'annee est bissextile, false sinon.
*/
public static boolean estBissextile (int annee) {
boolean bissex = false;
if (annee % 400 == 0
|| (annee % 4 == 0 && annee % 100 != 0)) {
bissex = true;
}
return bissex;
}

Meilleure solution (sans le if redondant) :

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

12
 INF1120 - Programmation I : Les méthodes en Java

Exemples d'appels :
boolean bissex = estBissextile(2017);

int nombre;
System.out.print("Entrez une annee: ");
nombre = Clavier.lireInt();

if (estBissextile(nombre)) {
System.out.println("bissextile");
} else {
System.out.println("non bissextile");
}

System.out.println (estBissextile (1998 + lancerDe()));

13
 INF1120 - Programmation I : Les méthodes en Java

/**
* 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);
}

Exemples d'appels :

double nbrReel = perimetreRectangle(13.2, 9);

double nbrReel = 6.2;

System.out.println("Perimetre : "
+ perimetreRectangle(3, nbrReel));

14
 INF1120 - Programmation I : Les méthodes en Java

/**
* Cette methode saisit et valide le choix de l'utilisateur
* entre borneInf et borneSup.
* @param msgSoll le msg de sollicitation du choix de l'utilisateur.
* @param msgErr le msg 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;
}

15
 INF1120 - Programmation I : Les méthodes en Java

Exemples d'appels :

final char MIN = '1';

final char MAX = '4';

char choix = validerChoixMenu ("Entrez votre choix : ",

"Erreur, vous devez entrer une valeur entre " + MIN
+ " et " + MAX + ". Recommencez...\n", MIN, MAX);

char choix2 = validerChoixMenu ("Tapez quelque chose : ",

"Erreur, moron !" , 'A', 'Z');

16
 INF1120 - Programmation I : Les méthodes en Java

Soit la méthode suivante qui retourne différents résultats selon différentes conditions…

public static double salaire (double nbrHeures, double tauxHoraire) {

if (nbrHeures <= 40) {
return (nbrHeures * tauxHoraire);
} else {
return ((nbrHeures - 40) * tauxHoraire
* 1.5 + 40 * tauxHoraire);
}
}

Une bonne pratique de programmation consiste à utiliser une seule instruction return,
à la toute fin de la méthode, comme ceci :

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
}

17
 INF1120 - Programmation I : Les méthodes en Java

Exemple d'appel :

double salaire = salaire(37.5, 56.78)

System.out.println(salaire(56, 45.67));

Lors de la définition d'une méthode, on peut 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
}

18
 INF1120 - Programmation I : Les méthodes en Java

Mode de passage des paramètres

Par valeur
! C'est la valeur du paramètre effectif qui est affecté au paramètre formel. On travaille
sur une copie.

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

En Java, les paramètres sont passés par valeur.

! Lorsqu'on modifie la valeur du paramètre à l'intérieur de la méthode, cette modification

est perdue lorsque la méthode se termine, car on travaille sur une copie.

19
 INF1120 - Programmation I : Les méthodes en Java

Exemple :
Soit le code suivant où la méthode main appelle la méthode
testPassageParam :

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
}
}

Étapes lors de l'appel de testPassageParam…

20
 INF1120 - Programmation I : Les méthodes en Java

21
 INF1120 - Programmation I : Les méthodes en Java

22
 INF1120 - Programmation I : Les méthodes en Java

Pour obtenir la nouvelle valeur calculée par la méthode testPassageParam, il

faut ajouter un type de retour.

public class Test {

public static int testPassageParam(int entier) {

entier = entier - 2;
return entier;

//ou
//return entier - 2;
}

public static void main (String [] params) {

int unEntier = 6;
unEntier = testPassageParam (unEntier);
System.out.println (unEntier); //4 sera affiché ici
}

23
 INF1120 - Programmation I : Les méthodes en Java

Visibilité (portée) des variables / constantes

Rappel : Une variable est visible à l'intérieur du bloc { } où elle a été déclarée.
Une classe est un bloc, une méthode est aussi un bloc

Variable / constante globale :

! déclarée dans le bloc de la classe
! Visible dans toutes les méthodes

Variable / constante locale :

! Déclarée dans le bloc d’une méthode (locale à cette méthode)
! Visible qu’à l’intérieur de cette méthode
.

24
 INF1120 - Programmation I : Les méthodes en Java

Éviter l’utilisation de variables globales !

! Rend le programme plus difficile à comprendre / modifier / déboguer

! Rend la réutilisation des méthodes plus difficiles (crée un couplage fort)
! Dangereux lors de la gestion concurrente de la mémoire (multi-threading)

Principe de localité : déclarer les variables aussi localement que possible.

Échanger les données entre méthodes en utilisant les paramètres (entrées) et

la valeur de retour (sortie) des méthodes.

L’utilisation de constantes globales ne pose pas de problème puisque

celles-ci ne peuvent pas être modifiées.

Voir les fichiers ProgAvecVarGlobale.java vs ProgSansVarGlobale.java

25
 INF1120 - Programmation I : Les méthodes en Java

Principes de conception d'une bonne méthode

Cohésion forte (spécialisation) => facilite la réutilisation
Robustesse : prise en charge de tous les cas d’erreurs. Une méthode ne
devrait jamais créer une erreur à l’exécution.
Exemple :
Qu'est-ce qui risque de provoquer une erreur à l'exécution dans la méthode suivante ?

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);
}

26
 INF1120 - Programmation I : Les méthodes en Java

Pour rendre la méthode plus robuste : gérer la 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 (cpt != 0) {
moyenne = somme / cpt;
}
return moyenne;
}

Commentaires => facilite compréhension / modification / débogage

27
 INF1120 - Programmation I : Les méthodes en Java

Pourquoi utiliser des méthodes ?

Découper un problème complexe en sous-problèmes plus simples
Exemple calcul salaire :

Voir la classe CalculerSalaireAvecMethodesV1.java

28
 INF1120 - Programmation I : Les méthodes en Java

Réutilisation du code (éviter la répétition de code)

Exemple :
Soit les deux méthodes suivantes utilisées dans la classe
CalculerSalaireAvecMethodesV1.java

public static double validerNbrHeures() {

double nbrHr;

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;
}

29
 INF1120 - Programmation I : Les méthodes en Java

public static double validerTauxHoraire() {

double tauxHr;

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;
}

Les deux méthodes ci-dessus sont pratiquement identiques = répétition de

code.
! Les méthodes font la même chose : valider un nombre réel entre une borne minimum
et une borne maximum.
! Seuls les messages, et les valeurs minimums et maximums pour la validation varient.

Solution : faire une seule méthode qui prend en paramètres les valeurs qui
varient d’une méthode à l’autre, et réutiliser cette méthode pour valider et le
nombre d'heures, et le taux horaire.
30
 INF1120 - Programmation I : Les méthodes en Java

public static double validerReel(String msgSoll, String msgErr,

double min, double max) {
double nbrReel;

System.out.print(msgSoll);
nbrReel = Clavier.lireDouble();

while (nbrReel < min || nbrReel > max) {

System.out.println(msgErr);
System.out.print(msgSoll);
nbrReel = Clavier.lireDouble();
}
return nbrReel;
}

On peut alors réutiliser cette méthode pour valider tout nombre réel entre
une borne min et une borne max.

Exemples :
nbrHeures = validerReel(MSG_SOL_NBR_HEURES, MSG_ERR_NBR_HEURES,
NBR_HR_MIN, NBR_HR_MAX);
tauxHoraire = validerReel(MSG_SOL_TAUX_HORAIRE, MSG_ERR_TAUX_HORAIRE,
TAUX_MIN, TAUX_MAX);

Voir la classe CalculerSalaireAvecMethodesV2.java

31
 INF1120 - Programmation I : Les méthodes en Java

Exercices sur les méthodes

Conception de méthodes

Exercice 1

Vous devez concevoir la méthode afficherMajuscule qui prend un paramètre de

type char et qui affiche la lettre majuscule correspondant au caractère reçu en
paramètre. Si le caractère reçu n’est pas une lettre minuscule, la méthode affiche un
message d’erreur et se termine. Si le caractère est bien une lettre minuscule, la
méthode affiche la lettre majuscule correspondante et se termine.

Exercice 2

Vous devez écrire la méthode validerCaractere qui saisit et valide un caractère

entre une borne inférieure et une borne supérieure données en paramètres. La méthode
retourne ensuite le caractère saisi (et valide). Votre méthode doit recevoir les 4
paramètres suivants, dans cet ordre :
1. Le message de sollicitation du caractère (type String)
2. Le message d’erreur lors d’une saisie invalide (type String)
3. La borne inférieure pour la validation (type char)
4. La borne supérieure pour la validation (type char)

32
 INF1120 - Programmation I : Les méthodes en Java

Utilisation (appel) de méthodes

Exercice 3

Étant données les méthodes suivantes :

/**
* Cette methode affiche la presentation de ce programme.
*/
public static void presenterLogiciel() {...}

/**
* Cette methode affiche un message disant a l'utilisateur
* d'appuyer sur ENTREE pour continuer.
*/
public static void pause() {...}

/**
* Cette methode affiche un message de fin du programme.
*/
public static void finProgramme() {...}

33
 INF1120 - Programmation I : Les méthodes en Java

/**
* Cette methode transforme carMin en majuscule, si carMin
* est une lettre minuscule, et affiche la majuscule
* correspondante. Sinon, la methode affiche un message
* d'erreur.
* @param carMin le caractere a transformer en majuscule
* (si possible).
*/
public static void afficherMajuscule(char carMin) {...}

/**
* Saisit et valide un caractere entre min et max inclusivement.
* @param msgSoll le message de sollicitation du caractere.
* @param msgErr le message d'erreur lorque le caractere
* n'est pas entre min et max.
* @param min la borne inferieure valide pour le caractere saisi.
* @param max la borne superieure valide pour le caractere saisi.
* @return le caractere saisi qui est entre min et max inclusivement.
*/
public static char validerCaractere(String msgSoll, String msgErr,
char min, char max) {...}

34
 INF1120 - Programmation I : Les méthodes en Java

Écrivez un programme (une méthode main) qui demande à l'utilisateur d'entrer une
lettre minuscule et qui affiche ensuite son équivalent en majuscule.

1. Le programme commence en affichant une brève présentation du logiciel. Il fait une

pause pour laisser le temps à l'utilisateur de lire la présentation, et attend que l'utilisateur
tape « ENTRÉE » pour continuer.
2. Ensuite, le programme demande d'entrer une lettre minuscule (vous devez valider que la
saisie de l'utilisateur est bien une lettre minuscule).
3. Puis, le programme affiche la lettre majuscule correspondante et demande a l'utilisateur
s'il veut entrer un autre caractère (vous devez valider que la saisie est bien une réponse
valide : 'o' pour OUI ou 'n' pour NON).
4. Lorsque la réponse est 'o', le programme recommence à l'étape 2
5. Lorsque la réponse est 'n', le programme se termine en affichant un message à cet effet.
6. L'utilisateur doit pouvoir transformer autant de caractères qu'il le désire (tant qu'il n'entre
pas 'n').

Vous devez utiliser les cinq méthodes définies ci-dessus (considérez

qu’elles existent et qu’elles sont implémentées).

Solutions aux pages suivantes…

35
 INF1120 - Programmation I : Les méthodes en Java

Solution exercice 1

public static void afficherMajuscule(char car) {

char carMaj;

if (car >= 'a' && car <= 'z') {

carMaj = (char)(car - 32);

//ou
//carMaj = Character.toUpperCase(car);

System.out.println("La lettre " + car

+ " transformee en majuscule est: " + carMaj);
} else {
System.out.println("Erreur. le caractere donne n'est pas une "
+ "lettre minuscule.");
}
}

36
 INF1120 - Programmation I : Les méthodes en Java

Solution exercice 2

public static char validerCaractere(String msgSoll, String msgErr,

char min, char max) {
char c;

System.out.print(msgSoll);
c = Clavier.lireCharLn();

while (c < min || c > max) {

System.out.println(msgErr);
System.out.print(msgSoll);
c = Clavier.lireCharLn();
}

return c;
}

37
 INF1120 - Programmation I : Les méthodes en Java

Solution exercice 3

public static void main (String [] args) {

char lettreMin;
char continuer;

presenterLogiciel();
pause();

do {
//Saisir et valider une lettre minuscule
lettreMin = validerCaractere("Entrez une lettre minuscule : ",
"\nErreur, le caractere doit etre une lettre minuscule. "
+ "Recommencez !", 'a', 'z');

//afficher le caractere correspondant en majuscule

afficherMajuscule(lettreMin);

//saisir et valider si on recommence (o)ui ou (n)on

continuer = validerCaractere("\nRecommencez ? (o/n) : ",
"\nErreur! Entrez (o)ui ou (n)on...", 'n', 'o');

} while (continuer == 'o');

finProgramme();
}

38
 INF1120 - Programmation I : Les méthodes en Java

Coexistence de méthodes dans une même classe

Signature d’une méthode

La signature d’une méthode comprend :
! Le nom de la méthode (ou du constructeur = nom de la classe)
! Le nombre de paramètres et leur type, dans l’ordre où ils apparaissent (le
nom des paramètres n’est pas considéré).

Le type de retour ne fait pas partie de la signature de la méthode.

À l’intérieur d’une même classe, les méthodes doivent toutes posséder des
signatures différentes.

39
 INF1120 - Programmation I : Les méthodes en Java

Exemples

Entête Signature
1 void machin (int x) machin (int)
2 void machin (int y) machin (int)
3 void machin (String x) machin (String)
4 String machin (String x) machin (String)
5 void machin (int x, int y) machin (int, int)
6 void chose (int x, int y) chose (int, int)

1 et 2 : même signature, même si le nom des paramètres est différent.

3 et 4 : même signature, même si le type de retour est différent.

Surdéfinition (ou surcharge) de méthodes

Méthodes ayant le même nom, mais étant de signatures différentes.
Exemple : 1 (ou 2), 3 (ou 4) et 5 => sont des surdéfinitions (ou des méthodes
surchargées)
40
 INF1120 - Programmation I : Les méthodes en Java

Vérification de l’existence d’une méthode à la compilation

Lorsqu'il rencontre un appel à une méthode, le compilateur doit pouvoir faire un
choix sans ambiguïté.
Le compilateur recherche les méthodes selon les critères suivants :
! Le nom de la méthode (existe-t-il au moins une méthode de ce nom ?)
! Nombre paramètres effectifs = nombre paramètres formels
! Le type des chaque paramètre effectif est compatible par affectation avec le type de
chaque paramètre formel correspondant.
! La méthode est accessible (pour l'instant, nos méthodes public static sont
toujours accessibles)
Puis…
! Si le compilateur trouve une seule méthode, celle-ci sera utilisée pour l'appel.
! Si le compilateur ne trouve aucune méthode -> erreur de compilation.
! Si le compilateur trouve plusieurs méthodes admissibles -> erreur de compilation
(ambiguïté).

Le type de la valeur de retour n'est pas un critère de discrimination entre deux

méthodes de même nom.

41
 INF1120 - Programmation I : Les méthodes en Java

Le type d'un paramètre effectif peut être converti implicitement pour

correspondre au type de son paramètre formel correspondant, selon le schéma
ci-dessous.

Un byte peut être directement converti en short.

Un short peut être directement converti en int.
Un char peut être directement converti en int.
Un int peut être directement converti en long, float ou double.
Un long peut être directement converti en float ou double.
Un float peut être directement converti en double.
42
 INF1120 - Programmation I : Les méthodes en Java

C'est la méthode qui nécessite le moins de conversion(s) des paramètres

effectifs qui sera choisie.

Si plusieurs méthodes nécessitent le même nombre de conversions, il y aura

ambiguïté (= erreur de compilation).

Par exemple :

- Pour convertir un int en double, cela nécessite 1 conversion (une seule

flèche à traverser dans le diagramme précédent).

- Pour convertir un char en float, cela demande 2 conversions (2 flèches

à traverser dans le diagramme précédent).

- Pour convertir un byte en double, cela nécessite 4 conversions (4 flèches

à traverser dans le diagramme précédent).

43
 INF1120 - Programmation I : Les méthodes en Java

Exemple 1
public class SurdefinitionMethodes {

public static void afficher (int n) {

System.out.println("afficher 1");
}

public static void afficher (int n1, int n2) {

System.out.println("afficher 2");
}

public static void afficher (short s) {

System.out.println("afficher 3");
}

public static void main (String [] args) {

byte b = 30;

afficher (2); //affiche afficher 1

afficher (2, 3); //affiche afficher 2
afficher ((short)5); //affiche afficher 3
afficher (b); //affiche afficher 3
//conversion byte -> short
}
}

44
 INF1120 - Programmation I : Les méthodes en Java

Exemple 2

public class SurdefinitionMethodes2 {

public static void afficher (byte b, int n) {

System.out.println("afficher 1");
}
public static void afficher (int i, byte b) {
System.out.println("afficher 2");
}
public static void main (String[] params) {
byte b = 3;
int i = 5;

afficher (b, i); //affiche afficher 1

afficher (i, b); //affiche afficher 2
afficher(b, b); //ambiguïté - erreur compil.
}
}

45
 INF1120 - Programmation I : Les méthodes en Java

Exemple 3
public class SurdefinitionMethodes3 {

public static int bidon () {

return 3;
}

public static boolean bidon () { //erreur compil (même signature)

return true;
}
}

46
 INF1120 - Programmation I : Les méthodes en Java

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.

Exercices
Voir le fichier MethodesJava_ExercicesEtSolutions.pdf
47