• 15 heures
  • Facile

Ce cours est visible gratuitement en ligne.

course.header.alt.is_video

course.header.alt.is_certifying

J'ai tout compris !

Mis à jour le 19/05/2021

Gérez les différents types de passage de paramètre

Connectez-vous ou inscrivez-vous gratuitement pour bénéficier de toutes les fonctionnalités de ce cours !

Depuis le début de ce cours, nous utilisons des fonctions (ou méthodes) comme  System.out.println(). Dans ce chapitre, vous allez vous familiariser avec les différents composants d'une déclaration de méthode (paramètres et valeur de retour) et la différence entre un type valeur et un type référence

En quoi consiste une déclaration de méthode ?

Supposons que vous ayez un rectangle de 6 (de longueur) par 4 (de largeur) et que vous vouliez calculer son périmètre.

public static void displayPerimeter() {
int perimeter = 2*(1 + 2);
System.out.println(perimeter); // -> 6
}

Cette méthode est correctement implémentée, mais avouons-le, tout à fait inutile car vous finiriez toujours par travailler avec les mêmes nombres. De quoi limiter votre champ d’action !

Fonctions avec paramètres

Pour remédier à cela, vous devez faire en sorte que votre fonction accepte des chiffres extérieurs. Pour cela, vous pouvez définir une fonction avec des paramètres.

En Java, le nom de la variable et le type du paramètre font partie de la déclaration de fonction. Voilà à quoi cela ressemble :

public static void displayPerimeter(int length, int width) {
int perimeter = 2 * (length + width);
System.out.println(perimeter);
//La valeur affichée depend de la longueur (length) et la largeur (width)
}

Les paramètres sont des variables listées dans la déclaration de fonction et qui sont spécifiées à l'intérieur de parenthèses  ()  avec le nom et le type. Vous pouvez maintenant appeler cette fonction et lui passer les valeurs que vous voulez :

displayPerimeter(10, 11); // -> 42
displayPerimeter(2, 2); // -> 8

Chaque valeur est affectée à un paramètre dans l'ordre de leur définition.

Détaillons un peu cette nouvelle terminologie. Les paramètres sont les variables déclarées dans une fonction. Les valeurs passées sur cette fonction s'appellent des arguments.

Parfait, nous avons ajouté un but à notre fonction. Maintenant, que pouvons-nous faire avec le résultat ?

Souvent, le code qui a appelé la fonction a besoin d'une réponse pour effectuer son propre travail. Cette réponse peut être fournie par la valeur de retourreturn, de la fonction.

Définissez une valeur de retour

Pour définir une valeur de retour, vous devez :

  1. Modifier la déclaration de la fonction pour indiquer qu'il est prévu qu'elle renvoie un résultat.

  2. Terminer la fonction avec le mot clé return.

Voici comment transformer le  displayPerimeter  en fonction  calculatePerimeter. Ceci retournera le résultat du calcul pour qu'il puisse être utilisé par l'appelant :

public static int sum(int a, int b)
{
int calc = a + b;
return calc;
}

Vous pouvez également renoncer à la variable somme et renvoyer directement le résultat de l'expression de calcul :

public static int sum(int a, int b){
return a + b;
}

Une fois votre fonction définie, vous pouvez l'utiliser autant de fois que vous le souhaitez. Voici quelques variantes :

int sumOfSmallNumbers = sum(3,7);
System.out.println(sumOfSmallNumbers); // -> 10
int sumOfLargerNumbers = sum(sumOfSmallNumbers,999);
System.out.println(sumOfLargerNumbers); // -> 1009

Dans l'exemple ci-dessus, nous avons utilisé le résultat du premier calcul comme paramètre pour le suivant.

Un autre élément à comprendre et à assimiler : certaines variables stockent une valeur directement, tandis que d'autres stockent une référence. Cela a un impact sur la façon dont elles sont envoyées comme arguments à une fonction.

Différenciez les types de valeur et de référence

Vous avez appris qu'il existe des types de variables simples (comme les nombres ou les chaînes) ou plus complexes (comme les classes). Chacun de ces types est classé comme un type valeur ou un type référence.

Commençons par les types valeur.

Types valeur

Prenons par exemple les nombres entiers. Si vous créez une variable entière puis que vous l'affectez à une autre variable, la valeur de la première variable sera copiée dans la seconde :

// Déclarez la variable "a" en tant que "int" et l'initialiser avec une valeur de 10
int a = 10;
// Déclarez la variable "b" en tant que "int" et l'initialiser avec une copie de la valeur de "a"
int b = a;

Puisque  int  est un type valeur, une copie de la valeur de a  est assignée à  b. Cela signifie que si vous modifiez ultérieurement la valeur de a, la valeur de b ne sera pas modifiée.

System.out.println(a); // -> 10
System.out.println(b); // -> 10
a = 15;
System.out.println(a); // -> 15
System.out.println(b); // -> 10

C'est assez simple. Viennent ensuite les types référence.

Types référence

Dans cette section, nous allons travailler avec des classes. Lorsque vous créez une variable et lui affectez une instance de classe, l'objet est créé, mais la variable elle-même contient une référence à cet objet : l'emplacement où il est stocké dans la mémoire. Ensuite, lorsque vous affectez la valeur de cette variable à une autre variable, l'objet lui-même ne sera pas copié, et la nouvelle variable contiendra une référence à cet objet : la même adresse.

En voici un exemple :

public class Car {
String color = "red";
}
Car car = new Car();
Car carToPaint = car;

Si vous voulez peindre la voiture qui est accessible par la deuxième variable, la première variable sera également affectée car les deux pointent exactement vers la même instance de la classe « car » (voiture) :

public class Car {
String color = "red"
}
Car car = new Car();
Car carToPaint = car;
System.out.println(car.color); // -> red
System.out.println(carToPaint.color); // -> red
carToPaint.color = "yellow";
System.out.println(car.color); // -> yellow
System.out.println(carToPaint.color); // -> yellow

Vous voyez la différence ? ⚡️ C'est très utile, car cela permet d'économiser beaucoup de mémoire si vous devez faire passer le même objet sur tout votre programme. Cependant, cela peut également être dangereux car changer un objet dans une partie d'un programme affecte toutes les autres parties du programme qui utilisent le même objet.

class Car {
String color = "red";
}
public void paint( Car car, String color) {
car.color = color;
}
Car car = new Car();
System.out.println(car.color); // -> red
paint(car, "green");
System.out.println(car.color); // -> green

Mais les paramètres des fonctions ne seraient-ils pas des constantes en Java ?

En effet, en Java, les paramètres d'une fonction sont des constantes et ne peuvent pas être modifiés, ce qui signifie que vous ne pouvez pas affecter une nouvelle valeur à l'ensemble du nouvel objet (ou une référence à un objet). Mais vous pouvez tout à fait modifier les attributs de cet objet. C'est ce que nous avons fait dans l'exemple ci-dessus.

  • Lors des appels de méthode, les arguments sont toujours passés par valeur. Dans le cas des types primitifs (int,  char,  byte, etc.), c'est la valeur de l'argument qui est recopiée dans le paramètre de la méthode.

int cote = 5;
agrandirCote(cote); // Cette méthode ajoute 2cm au côté qui lui a été passé en paramètre

Dans l’exemple ci-dessus, la variable  cote  aura toujours la valeur 5 en dehors de la fonction  agrandirCote(int leCoteAagrandir).

  • Dans le cas des types « objet », c'est la valeur de la variable (la référence à l'objet), qui est transmise à la méthode.

Integer cote = 5;
agrandirCote(cote); // Cette méthode ajoute 2cm au côté qui lui a été passé en paramètre

Cette fois-ci, une fois la méthode  agrandirCote(Integer leCoteAagrandir)  appelé avec la variable cote, cette variable aura pour valeur 7 en dehors de la méthode (une fois la méthode exécutée).

En résumé

Dans ce chapitre, vous avez appris que :

  • les fonctions peuvent avoir des paramètres et des valeurs de retour (return) ;

  • une valeur de retour est le résultat de l'exécution de la fonction. Elle peut être renvoyée au bloc de code qui a appelé la fonction, et être utilisée si besoin est ;

  • les paramètres sont les entrées d'une fonction nécessaires à l'exécution et à l'obtention d'un résultat ;

  • les paramètres sont des variables définies par leur nom et par leur type. Ces paramètres sont spécifiés dans la déclaration de la fonction ;

  • lorsque vous appelez une fonction, vous passez des valeurs à ces variables. Ces valeurs sont appelées arguments.

Terminons en récapitulant les concepts importants de cette deuxième partie !

Exemple de certificat de réussite
Exemple de certificat de réussite