Java-Methodenparameter: Argumente, Pass-by-Value und Rückgabe

Parameter ermöglichen einer Methode, Eingaben entgegenzunehmen

Eine Methode, die immer dasselbe tut, ist eingeschränkt. Parameter sind die Eingaben, die du innerhalb der Klammern der Methode deklarierst, damit dieselbe Methode bei jedem Aufruf mit anderen Werten arbeiten kann.

Du listest jeden Parameter mit einem Typ und einem Namen auf. Innerhalb des Methodenrumpfs verhält sich ein Parameter wie eine gewöhnliche lokale Variable, die bereits das enthält, was der Aufrufer übergeben hat.

public class Main {
    static void greet(String name) {
        System.out.println("Hello, " + name + "!");
    }

    public static void main(String[] args) {
        greet("Sam");
        greet("Alex");
    }
}

name ist der Parameter. "Sam" und "Alex" sind die Argumente - die konkreten Werte, die beim Aufruf geliefert werden. Eine Methodendefinition, zwei verschiedene Ausgaben.

Parameter versus Argumente

Diese beiden Wörter werden oft locker verwendet, aber die Unterscheidung lohnt sich klarzuhalten:

• Ein Parameter ist der Platzhalter in der Deklaration: String name.
• Ein Argument ist der Wert, den du tatsächlich übergibst: "Sam".

void greet(String name) deklariert also einen Parameter, und greet("Sam") übergibt ein Argument. Wenn jemand sagt „diese Methode nimmt zwei Parameter", meint er die Deklaration; „ich habe zwei Argumente übergeben" meint den Aufruf.

Mehrere Parameter

Trenne die Parameter durch Kommas und gib jedem seinen eigenen Typ - du kannst einen Typ nicht zwischen zwei Parametern teilen, wie du es bei einer Variablendeklaration vielleicht tun würdest:

public class Main {
    static int add(int a, int b) {
        return a + b;
    }

    static String describe(String name, int age, boolean active) {
        return name + " (" + age + ", " + (active ? "active" : "inactive") + ")";
    }

    public static void main(String[] args) {
        System.out.println(add(2, 3));
        System.out.println(describe("Sam", 30, true));
    }
}

Argumente werden den Parametern strikt nach Position zugeordnet, nicht nach Namen. describe("Sam", 30, true) funktioniert, weil die Reihenfolge mit (String name, int age, boolean active) übereinstimmt. Vertausche zwei Argumente kompatibler Typen, und du bekommst einen stillen Logikfehler, keinen Kompilierfehler - daher ist die Reihenfolge wichtig.

Ein häufiger Fehler ist int add(int a, b). Jeder Parameter braucht seinen eigenen Typ: int add(int a, int b).

Einen Wert zurückgeben

Parameter sind, wie Daten hineinfließen; der Rückgabewert ist, wie ein Ergebnis wieder herausfließt. Deklariere den Rückgabetyp vor dem Methodennamen und verwende return, um dem Aufrufer einen Wert zurückzugeben:

public class Main {
    static double average(int a, int b, int c) {
        int sum = a + b + c;
        return sum / 3.0;   // 3.0 erzwingt eine Gleitkommadivision
    }

    public static void main(String[] args) {
        double result = average(4, 5, 9);
        System.out.println("Average: " + result);
    }
}

Der Rückgabetyp (double) muss zu dem passen, was du tatsächlich mit return zurückgibst. Eine als void deklarierte Methode gibt nichts zurück - sie kann trotzdem ein blankes return; verwenden, um früh zu beenden, aber sie kann keinen Wert zurückgeben. Sobald return ausgeführt wird, endet die Methode und die Steuerung springt zurück zur Aufrufstelle.

Java ist Pass-by-Value

Das verwirrt am Anfang fast alle. Wenn du ein Argument übergibst, kopiert Java den Wert in den Parameter. Bei primitiven Typen bedeutet das, dass die Methode ihre eigene Kopie erhält - das Ändern des Parameters berührt niemals die Variable des Aufrufers:

public class Main {
    static void tryToChange(int n) {
        n = 999;   // ändert nur diese lokale Kopie
    }

    public static void main(String[] args) {
        int x = 5;
        tryToChange(x);
        System.out.println(x);   // immer noch 5
    }
}

x bleibt 5. Die Methode hat ihre eigene Kopie der Zahl geändert, nicht das Original.

Objekte übergeben: immer noch by Value, aber achte auf die Referenz

Objekte wirken wie eine Ausnahme, sind es aber nicht. Was kopiert wird, ist die Referenz (der Pfeil, der auf das Objekt zeigt), nicht das Objekt selbst. Daher zeigt die Methode auf dasselbe Objekt und kann es verändern:

import java.util.ArrayList;
import java.util.List;

public class Main {
    static void addItem(List<String> items) {
        items.add("new");        // verändert das gemeinsame Objekt - für den Aufrufer sichtbar
    }

    static void replace(List<String> items) {
        items = new ArrayList<>();   // weist nur die lokale Kopie neu zu - NICHT sichtbar
        items.add("ignored");
    }

    public static void main(String[] args) {
        List<String> list = new ArrayList<>(List.of("a", "b"));

        addItem(list);
        System.out.println(list);   // [a, b, new]

        replace(list);
        System.out.println(list);   // immer noch [a, b, new] - die Neuzuweisung ist nicht entwichen
    }
}

Zwei verschiedene Ergebnisse, eine Regel. addItem folgt der Referenz und ändert die tatsächliche Liste, sodass der Aufrufer new erscheinen sieht. replace weist den Parameter einer brandneuen Liste zu - aber das richtet nur die lokale Kopie der Referenz neu aus, sodass die list des Aufrufers unberührt bleibt. Die Erkenntnis: Du kannst ein Objekt über einen Parameter verändern, aber du kannst niemals die Variable des Aufrufers dazu bringen, auf etwas Neues zu zeigen.

Als Nächstes: Methodenüberladung

Du weißt jetzt, wie du einer Methode genau die Eingaben gibst, die sie benötigt. Aber was, wenn du möchtest, dass ein Methodenname verschiedene Sätze von Parametern akzeptiert - etwa print(int) und print(String)? Das ist Methodenüberladung, und es ist die nächste Seite.