Parametry metod w Javie: argumenty, przekazywanie przez wartość i return

Parametry pozwalają metodzie przyjmować dane

Metoda, która zawsze robi to samo, ma ograniczone możliwości. Parametry to dane wejściowe deklarowane w nawiasach metody, dzięki którym ta sama metoda może przy każdym wywołaniu działać na innych wartościach.

Każdy parametr zapisujesz z typem i nazwą. W ciele metody parametr zachowuje się jak zwykła lokalna zmienna, która już zawiera to, co przekazał wywołujący.

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

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

name to parametr. "Sam" i "Alex" to argumenty, czyli konkretne wartości podane w wywołaniu. Jedna definicja metody, dwa różne wyniki.

Parametry a argumenty

Tych dwóch słów często używa się zamiennie, ale warto je rozróżniać:

• Parametr to miejsce na wartość w deklaracji: String name.
• Argument to wartość, którą faktycznie przekazujesz: "Sam".

Czyli void greet(String name) deklaruje parametr, a greet("Sam") przekazuje argument. Gdy ktoś mówi "ta metoda przyjmuje dwa parametry", ma na myśli deklarację; "przekazuję dwa argumenty" dotyczy wywołania.

Kilka parametrów

Oddzielaj parametry przecinkami i każdemu nadaj własny typ. Nie da się współdzielić typu między dwoma parametrami tak jak w deklaracji zmiennych:

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

Argumenty są dopasowywane do parametrów wyłącznie według pozycji, nie według nazwy. describe("Sam", 30, true) działa, bo kolejność zgadza się z (String name, int age, boolean active). Zamień miejscami dwa argumenty zgodnych typów, a dostaniesz cichy błąd logiczny, nie błąd kompilacji. Kolejność ma więc znaczenie.

Częsty błąd to napisanie int add(int a, b). Każdy parametr potrzebuje własnego typu: int add(int a, int b).

Zwracanie wartości

Parametrami dane wpływają do metody; wartością zwracaną wynik wraca na zewnątrz. Zadeklaruj typ zwracany przed nazwą metody i użyj return, aby oddać wartość wywołującemu:

public class Main {
    static double average(int a, int b, int c) {
        int sum = a + b + c;
        return sum / 3.0;   // 3.0 wymusza dzielenie zmiennoprzecinkowe
    }

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

Typ zwracany (double) musi pasować do tego, co faktycznie zwracasz przez return. Metoda zadeklarowana jako void nic nie zwraca: może użyć samego return;, aby wcześniej zakończyć działanie, ale nie może zwrócić wartości. Gdy tylko wykona się return, metoda się kończy, a sterowanie wraca do miejsca wywołania.

Java przekazuje przez wartość

Na tym na początku potyka się prawie każdy. Gdy przekazujesz argument, Java kopiuje wartość do parametru. Dla typów prostych oznacza to, że metoda dostaje własną kopię, więc zmiana parametru nigdy nie dotyka zmiennej wywołującego:

public class Main {
    static void tryToChange(int n) {
        n = 999;   // zmienia tylko tę lokalną kopię
    }

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

x pozostaje 5. Metoda zmieniła własną kopię liczby, a nie oryginał.

Przekazywanie obiektów: nadal przez wartość, ale uważaj na referencję

Obiekty wyglądają na wyjątek, ale nim nie są. Kopiowana jest referencja (strzałka wskazująca na obiekt), a nie sam obiekt. Metoda wskazuje więc na ten sam obiekt i może go zmienić. Właśnie dlatego dodanie elementu do współdzielonej ArrayList wewnątrz metody jest widoczne dla wywołującego:

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

public class Main {
    static void addItem(List<String> items) {
        items.add("new");        // zmienia współdzielony obiekt: widoczne dla wywołującego
    }

    static void replace(List<String> items) {
        items = new ArrayList<>();   // przypisuje na nowo tylko lokalną kopię: NIE jest widoczne
        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);   // nadal [a, b, new]: przypisanie nie wyszło poza metodę
    }
}

Dwa różne wyniki, jedna zasada. addItem idzie za referencją i zmienia faktyczną listę, więc wywołujący widzi pojawienie się new. replace przypisuje parametrowi zupełnie nową listę, ale to przestawia tylko lokalną kopię referencji, więc list wywołującego pozostaje nietknięta. Wniosek: przez parametr możesz zmienić obiekt, ale nigdy nie sprawisz, że zmienna wywołującego zacznie wskazywać na coś innego.

Dalej: przeciążanie metod

Wiesz już, jak przekazać metodzie dokładnie te dane, których potrzebuje. A co, jeśli chcesz, by jedna nazwa metody przyjmowała różne zestawy parametrów, np. print(int) i print(String)? To przeciążanie metod i o nim jest następna strona.