Passage par valeur en Java
Comprenez le passage par valeur en Java : types primitifs et références, réaffectation et modification, tableaux et pièges liés à l’immuabilité.
Passage par valeur en Java est une leçon Java Academy gratuite sur CoddyKit. Ceci est la leçon 1 sur 3. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Java Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Java Academy comprend 3 leçons au total.
Vue d’ensemble du passage par valeur
Objectif : Comprendre comment Java transmet les paramètres. Comparez les types primitifs et les références, la réaffectation et la modification, les tableaux et l’immuabilité.
Copie des types primitifs
Les types primitifs sont transmis par valeur : la méthode appelée reçoit une copie. Réaffecter le paramètre ne modifie pas la variable de l’appelant.
public class Main {
static void inc(int x) {
x = x + 1; // modifies the local copy only
}
public static void main(String[] args) {
int a = 5;
inc(a);
System.out.println("a after inc(a) = " + a); // still 5
}
}
Références : modification et réaffectation
Pour les objets, la référence est copiée. Modifier l’objet via cette référence affecte l’objet de l’appelant ; réaffecter le paramètre ne le fait pas.
public class Main {
static class Box { int n; }
static void setTo999(Box b) { b.n = 999; } // mutate via copied reference
static void reassign(Box b) { b = new Box(); b.n = 123; } // reassign local copy only
public static void main(String[] args) {
Box bx = new Box();
bx.n = 10;
setTo999(bx);
System.out.println("after setTo999: bx.n = " + bx.n); // 999
reassign(bx);
System.out.println("after reassign: bx.n = " + bx.n); // still 999
}
}
Tableaux : modification et réaffectation
Les tableaux sont des objets. Modifiez-les pour affecter le tableau de l’appelant ; réaffecter le paramètre ne remplace pas le tableau de l’appelant.
public class Main {
static void fillZero(int[] a) {
for (int i = 0; i < a.length; i = i + 1) a[i] = 0; // mutate caller array
}
static void replace(int[] a) {
a = new int[] {9, 9, 9}; // reassign local copy of the reference
}
public static void main(String[] args) {
int[] arr = {1, 2, 3};
fillZero(arr);
System.out.println("after fillZero: " + arr[0] + "," + arr[1] + "," + arr[2]); // 0,0,0
replace(arr);
System.out.println("after replace: " + arr[0] + "," + arr[1] + "," + arr[2]); // still 0,0,0
}
}
Immuable et mutable
String est immuable (renvoie de nouveaux objets) ; StringBuilder est mutable (modifie la même instance).
public class Main {
static void tryChangeString(String s) {
s = s + "!"; // new String; original unchanged
}
static void changeBuilder(StringBuilder sb) {
sb.append("!"); // mutates same object
}
public static void main(String[] args) {
String s = "hi";
tryChangeString(s);
System.out.println("after tryChangeString: " + s); // "hi"
StringBuilder sb = new StringBuilder("hi");
changeBuilder(sb);
System.out.println("after changeBuilder: " + sb.toString()); // "hi!"
}
}
Échanger correctement
Comme les paramètres sont des copies, échanger des types primitifs dans une méthode n’affecte pas l’appelant. Renvoyez de nouvelles valeurs (ou utilisez un objet conteneur).
public class Main {
static void trySwap(int a, int b) {
int t = a; a = b; b = t; // swaps local copies only
}
static int[] swap(int a, int b) {
return new int[] { b, a }; // return results to the caller
}
public static void main(String[] args) {
int x = 1, y = 2;
trySwap(x, y);
System.out.println("after trySwap: x=" + x + ", y=" + y); // 1,2
int[] res = swap(x, y);
x = res[0]; y = res[1];
System.out.println("after swap: x=" + x + ", y=" + y); // 2,1
}
}
Vérification du passage par valeur
Vérification rapide : Quelle affirmation sur la transmission des paramètres en Java est correcte ?
Récapitulatif et suite
Récapitulatif : Vous avez découvert les types primitifs et les références, la modification et la réaffectation, les tableaux en tant qu’objets, l’immuabilité et une méthode d’échange sûre. Ensuite : les méthodes statiques et d’instance.
Questions Fréquemment Posées
La leçon « Passage par valeur en Java » est-elle gratuite ?
Oui — le texte complet de « Passage par valeur en Java » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Java Academy, passe à CoddyKit PRO. Le cours Java Academy comprend 3 leçons au total.
Qu'est-ce que j'apprendrai dans « Passage par valeur en Java » ?
Comprenez le passage par valeur en Java : types primitifs et références, réaffectation et modification, tableaux et pièges liés à l’immuabilité. Tu pratiques Java Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.
Dois-je avoir de l'expérience pour commencer Java Academy ?
Aucune expérience préalable n'est requise. Java Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 1 sur 3.
Combien de temps prend la leçon « Passage par valeur en Java » ?
La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.
Peux-tu écrire et exécuter du code dans cette leçon Java Academy ?
Oui. Chaque leçon Java Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.
Toutes les leçons de ce cours
- Passage par valeur en Java
- Méthodes statiques et d’instance
- Décomposition des méthodes et code propre