Java Academy · Lektion

Übergabe per Wert in Java

Verstehen Sie die Übergabe per Wert in Java: primitive Typen gegenüber Referenzen, Neuzuweisung gegenüber Mutation sowie Fallstricke bei Arrays und Unveränderlichkeit.

Übergabe per Wert in Java ist eine kostenlose Java Academy-Lektion auf CoddyKit. Dies ist Lektion 1 von 3. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Java Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Java Academy-Kurs umfasst insgesamt 3 Lektionen.

Überblick zur Wertübergabe

Ziel: Lernen Sie, wie Java Parameter übergibt. Vergleichen Sie primitive Typen mit Referenzen, Neuzuweisung mit Veränderung, Arrays und Unveränderlichkeit.

Primitive Typen werden kopiert

Primitive Typen werden als Wert übergeben: Die aufgerufene Methode erhält eine Kopie. Eine Neuzuweisung des Parameters ändert die Variable des Aufrufers nicht.

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
  }
}

Referenzen: verändern vs. neu zuweisen

Bei Objekten wird die Referenz kopiert. Eine Veränderung über diese Referenz wirkt sich auf das Objekt des Aufrufers aus; eine Neuzuweisung des Parameters jedoch nicht.

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: verändern vs. neu zuweisen

Arrays sind Objekte. Eine Veränderung wirkt sich auf den Aufrufer aus; eine Neuzuweisung des Parameters ersetzt das Array des Aufrufers nicht.

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
  }
}

Unveränderlich vs. veränderlich

String ist unveränderlich und gibt neue Objekte zurück; StringBuilder ist veränderlich und ändert dieselbe Instanz.

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!"
  }
}

Korrekt vertauschen

Da Parameter Kopien sind, wirkt sich das Vertauschen primitiver Werte innerhalb einer Methode nicht auf den Aufrufer aus. Geben Sie neue Werte oder ein Containerobjekt zurück.

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
  }
}

Prüfung der Wertübergabe

Kurzprüfung: Welche Aussage über die Parameterübergabe in Java ist richtig?

Zusammenfassung & Nächstes

Zusammenfassung: Sie haben primitive Typen und Referenzen, Veränderung und Neuzuweisung, Arrays als Objekte, Unveränderlichkeit und ein sicheres Muster zum Vertauschen kennengelernt. Als Nächstes geht es um statische und Instanzmethoden.

Häufig gestellte Fragen

Ist die Lektion „Übergabe per Wert in Java“ kostenlos?

Ja — der vollständige Text von „Übergabe per Wert in Java“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Java Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Java Academy-Kurs umfasst insgesamt 3 Lektionen.

Was lerne ich in „Übergabe per Wert in Java“?

Verstehen Sie die Übergabe per Wert in Java: primitive Typen gegenüber Referenzen, Neuzuweisung gegenüber Mutation sowie Fallstricke bei Arrays und Unveränderlichkeit. Du übst Java Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Java Academy zu starten?

Keine Vorkenntnisse erforderlich. Java Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 1 von 3.

Wie lange dauert die Lektion „Übergabe per Wert in Java“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Java Academy-Lektion Code schreiben und ausführen?

Ja. Jede Java Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu Java Academy