Apprenez à programmer en Java

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. 

Comprenez l'utilité de déclarer une 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*(4 + 6);
   System.out.println(perimeter); // -> 20
}

Cette méthode est correctement implémentée, mais avouons-le, tout à fait inutile car elle fournit toujours le même résultat… . De quoi limiter votre champ d’action ! Comment faire pour qu’elle calcule un périmètre avec d’autres données ?

Définissez des fonctions avec des paramètres

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

En Java, le type du paramètre et son nom correspondant dans le cadre de la fonction 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 dépend 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.

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 retour 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 type valeur et les type 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 un  int  et que vous lui donnez une valeur, puis que vous affectez cette variable à une seconde variable  int  , la valeur de la première 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  . Les deux valeurs sont indépendantes. 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

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ée avec la variable coté, cette variable aura pour valeur 7 en dehors de la méthode (une fois la méthode exécutée).

En résumé

• 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.