Pass-by-value in Java
Leer pass-by-value in Java: primitieve waarden versus referenties, opnieuw toewijzen versus muteren, en valkuilen met arrays en onveranderlijkheid.
Pass-by-value in Java is een gratis Java Academy-les op CoddyKit. Dit is les 1 van 3. Je kunt de volledige les hieronder gratis lezen en daarna in de browser praktisch oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Java Academy. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Java Academy bevat in totaal 3 lessen.
Overzicht van doorgeven op waarde
Doel: Leer hoe Java parameters doorgeeft. Vergelijk primitieve waarden met verwijzingen, opnieuw toewijzen met muteren, arrays en onveranderlijkheid.
Kopie van primitieve waarden
Primitieve waarden worden doorgegeven op waarde: de aangeroepen methode krijgt een kopie. Een nieuwe toewijzing aan de parameter verandert de variabele van de aanroeper niet.
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
}
}
Verwijzingen: muteren en opnieuw toewijzen
Bij objecten wordt de referentie gekopieerd. Muteren via die referentie verandert het object van de aanroeper; een nieuwe toewijzing aan de parameter doet dat niet.
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
}
}
Arrays: muteren en opnieuw toewijzen
Arrays zijn objecten. Muteren verandert het object van de aanroeper; een nieuwe toewijzing aan de parameter vervangt de array van de aanroeper niet.
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
}
}
Onveranderlijk en veranderlijk
String is onveranderlijk en retourneert nieuwe objecten; StringBuilder is veranderlijk en wijzigt dezelfde instantie.
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!"
}
}
Correct omwisselen
Omdat parameters kopieën zijn, heeft het omwisselen van primitieve waarden binnen een methode geen effect op de aanroeper. Retourneer nieuwe waarden of gebruik een houderobject.
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
}
}
Controle van doorgeven op waarde
Snelle controle: Welke uitspraak over het doorgeven van parameters in Java is correct?
Samenvatting en volgende stap
Samenvatting: Je hebt primitieve waarden en verwijzingen, muteren en opnieuw toewijzen, arrays als objecten, onveranderlijkheid en een veilig patroon voor omwisselen bekeken. Volgende stap: statische en instantiemethoden.
Leer Java met een AI-tutor — gratis
Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.
- Cursussen
- 104
- Lessen
- 374
Veelgestelde vragen
Is de les “Pass-by-value in Java” gratis?
Ja — de volledige tekst van “Pass-by-value in Java” kun je hier gratis op het web lezen. Als je interactief wilt oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is, en de rest van de cursus Java Academy wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus Java Academy bevat in totaal 3 lessen.
Wat leer ik in “Pass-by-value in Java”?
Leer pass-by-value in Java: primitieve waarden versus referenties, opnieuw toewijzen versus muteren, en valkuilen met arrays en onveranderlijkheid. Je oefent met Java Academy door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.
Heb ik ervaring nodig om met Java Academy te beginnen?
Ervaring vooraf is niet nodig. Java Academy op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 1 van 3.
Hoe lang duurt de les “Pass-by-value in Java”?
De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.
Kan ik code schrijven en uitvoeren in deze les over Java Academy?
Ja. Elke les over Java Academy bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.
Alle lessen in deze cursus
- Pass-by-value in Java
- Statische versus instantiemethoden
- Methodedecompositie en clean code