Rôle des paramètres

Les paramètres rendent les méthodes plus flexibles. Leur code peut fonctionner avec différentes informations comme entrées, alors au lieu d’écrire une méthode pour chaque entrée possible, on a la possibilité de fournir cette information durant l’appel.

C’est un concept très puissant.

En mathématiques, vous avez quelque chose de similaire avec les fonctions, p. ex. : f(x) = x^2. Cette fonction nous donne le carré de x. x est donc un paramètre de f. En passant différentes valeur de x à la fonction f(x) on obtient différents résultats.

Exemples connus de méthodes avec paramètres

Vous connaissez déjà quelques méthodes avec des paramètres :

• toutes les formes de print” :
  • System.out.print("Votre réponse > ")
  • System.out.println("Bonjour " + name + "!")
  • System.out.printf("%S\n", "david")
• créer un nouveau Scanner avec : new Scanner(System.in)
• spécifier le format de nombres sur un objet Scanner : .useLocale(Locale.CANADA_FRENCH)
• faire des calculs avec la classe Math : Math.pow(2, 3), Math.sqrt(9), Math.abs(-5)
• certaines opérations sur des objets String : comme .charAt(0)

Exemples connus de méthodes sans paramètres

Les méthodes sans paramètres sont appelées avec des parenthèses vides.

Ceux que vous connaissez le mieux sont les méthodes de Scanner :

• .next(), .nextLine(), .close()

On a aussi vu quelques méthodes de traitement des String :

• .length(), .toUpperCase()

Notez que ces méthodes commencent avec un point . car ils s’appelent suite au nom d’un objet. Elles utilisent l’information qui est déjà dans l’objet (le Scanner, le String) pour faire ce qu’ils ont à faire et n’ont donc pas besoin de paramètres.

Écrire nos propres méthodes avec paramètres

On a déjà vus la structure générale de la déclaration d’une méthode. Ici on ajoute un dernier détail : la liste de paramètres.

Signature de méthode

Voici le gabarit complet pour la déclaration d’une méthode, incluant maintenant les paramètres :

1
2
3
4
[type de retour] [nom de la méthode] ( [liste de paramètres] ) {
    // bloc de code,
    // avec instruction `return` au besoin
}

La liste de paramètres a le format suivant, soit une liste de déclarations de variables :

1
type1 nom1, type2 nom2, type3 nom3, ...

où les types sont ceux qu’on connaît (int, double, String, Scanner, etc.) et les noms sont un nom de variable selon les règles et les conventions qu’on utilise déjà.

Corps de méthode

Le but de déclarer des paramètres est d’avoir des informations qu’on peut manipuler dans le code de la méthode. On ne connaît pas encore la valeur de ces informations, mais on connaît leur type (à cause de la signature). On peut alors travailler librement avec ces variables dans le code comme on le ferait avec n’importe quel autre variable du même type.

Appeller des méthodes avec paramètres

Quand on appelle une méthode qui a déclaré des paramètres dans sa signature, nous devons fournir des informations du type approprié entre les parenthèses. Sinon le programme nous signale une erreur de syntaxe.

Les informations passées durant l’appel s’appellent des arguments.

Par exemple, si nous avons déclaré cette méthode en déclarant un paramètre String name :

1
2
3
void greetWithName(String name) {
    System.out.println("Bonjour " + name + "!");
}

Il faut absolument placer une valeur de type String entre les parenthèses durant l’appel, p. ex. :

1
2
3
4
5
void main(){
    greetWithName("Jean");
    greetWithName("Lucie");
    greetWithName(); // erreur de syntaxe à cette ligne
}

Différences entre paramètres et arguments

Comment ça marche? Le diagramme de flux

Comme le mécanisme appel-retour était plus explicite dans le diagramme de flux que dans le code, le mécanisme argument-appel l’est aussi.

Regardons donc le diagramme de flux pour l’exemple greetWithName ci-dessus.

Le diagramme de flux nous aide à mieux voir la mécanique argument-paramètre. On voit quelque chose là qui n’est pas aussi apparent dans le code.

Dans l’algorithme pour la méthode :

• la première instruction assigne la valeur reçue à une variable (dans cette exemple, name), ce qui correspond au paramètre de la méthode
• le reste du code est définie selon ce nom de variable

Dans l’algorithme principal du diagramme :

• l’instruction d’appel inclut une information à passer à la méthode, ce qui correspond à l’argument

Dans le code Java pour la méthode greetWithName, l’assignation de la valeur reçue est masquée / implicite.

Dans le diagramme de flux, on doit le mentionner explicitement.

Structure générale pour l’utilisation d’une méthode avec paramètre

Deux exemples

Le programme ci-dessous montre un exemple simple (et banal) de deux méthodes avec des paramètres.

Fichier : BasicParam.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
void greetWithName(String name) {
    System.out.println("Bonjour " + name + "!");
}

int product(int a, int b) {
    return a * b;
}

void main() {
    String david = "David";
    int x = 3;
    int b = 5;
    greetWithName(david);
    System.out.println(product(x, b));
}

Remarquez qu’on a encore placé la méthode main à la fin du fichier.

Tracer la séquence d’exécution

On commence toujours le programme à main. Le diagramme de séquence d’appel pour le programme dans BasicParam.java serait :

1
2
3
4
5
6
7
8
9
10
9
10
11
12
13 -> 1
      2
13 <- 3
14 -> 5
14 <- 6
15

Pour greetWithName

1
13 -> 1

1
13 <- 3

Pour product

1
14 -> 5

1
14 <- 6

Diagramme de dépendances

On commence à main et regarde quelles méthodes il appelle.

La nouveauté est qu’avec les paramètres, on inclut le type des chaque paramètre dans le bloc de la méthode entre des parenthèses. On peut trouvez cette information dans la signature de chaque méthode mais aussi dans la structure du document.

• [nom de la méthode]( [liste des types de paramètres] ) : [type de retour]

  

Voici donc une version possible de ce diagramme. L’ajout des types des paramètres nous indique que chaque méthode dépend sur main pour leur fournir les valeurs String et int pour leurs paramètres. On voit aussi que main devra géré la valeur int retournée par la méthode product.