Metody w Javie: jak definiować i wywoływać metody

Po co są metody

Metoda to nazwany blok kodu, który możesz uruchomić, kiedy tylko wywołasz jego nazwę. Zamiast pisać w kółko te same linie, piszesz je raz w metodzie i wywołujesz ją tyle razy, ile potrzebujesz. Dzięki temu programy są krótsze, łatwiejsze do czytania i dużo łatwiejsze do poprawiania: zmieniasz logikę w jednym miejscu, a każde wywołanie dostaje aktualizację.

Z metod już korzystasz: System.out.println(...) to wywołanie metody, tak samo jak list.size(). Teraz napiszesz własne.

Deklarowanie i wywoływanie metody

Deklaracja metody ma cztery części: typ zwracany, nazwę, parę nawiasów (na parametry) i ciało w nawiasach klamrowych. Oto najmniejszy przydatny przykład, czyli metoda, która wykonuje pracę i nic nie zwraca:

public class Main {
    static void printGreeting() {
        System.out.println("Hello from a method!");
    }

    public static void main(String[] args) {
        printGreeting();   // wywołaj ją
        printGreeting();   // wywołaj ją ponownie
    }
}

Przeczytaj części static void printGreeting():

• static: pozwala main wywołać ją bezpośrednio, bez tworzenia obiektu (więcej o tym niżej).
• void: ta metoda nie zwraca wartości.
• printGreeting: nazwa, której używasz do wywołania.
• (): puste nawiasy oznaczają, że metoda nie przyjmuje danych.

Metodę wywołujesz, pisząc jej nazwę, a po niej nawiasy. Dwa wywołania w main uruchamiają ciało dwa razy, więc powitanie wypisuje się dwukrotnie.

Zwracanie wartości

Większość metod coś oblicza i oddaje wynik przez return. Typ zwracany przed nazwą mówi, jaki rodzaj wartości wychodzi z metody, tutaj int:

public class Main {
    static int square(int n) {
        return n * n;
    }

    public static void main(String[] args) {
        int result = square(5);
        System.out.println(result);          // 25
        System.out.println(square(3) + 1);   // 10
    }
}

square(5) daje 25, które możesz zapisać w zmiennej, wypisać albo użyć w większym wyrażeniu: wywołanie metody zastępuje wartość, którą ona zwraca. Gdy tylko wykona się return, metoda się kończy, a sterowanie wraca do wywołującego. Kod po return na tej samej ścieżce nigdy się nie wykona.

Typ zwracany i zwracana wartość muszą się zgadzać: typ danych, który deklarujesz, to rodzaj wartości, którą metoda obiecuje oddać. Zadeklarowanie int i próba return "text"; to błąd kompilacji, bo kompilator pilnuje tej umowy.

void a typ zwracany

Podział jest prosty: użyj prawdziwego typu zwracanego, gdy wywołujący potrzebuje wartości, a void, gdy metoda tylko coś robi (wypisuje, zapisuje, zmienia stan).

void logMessage(String msg)   // wykonuje pracę, nic nie zwraca
int  add(int a, int b)        // oblicza wartość, której używa wywołujący

Częsty błąd początkujących to próba użycia "wyniku" metody void:

int x = printGreeting();   // błąd kompilacji: printGreeting() zwraca void

Nie ma wartości do przypisania, więc to się nie skompiluje. Jeśli chcesz dostać wynik metody void, to znak, że powinna ona coś zwracać.

Metody z rozgałęzieniami i wczesnym return

Możesz wykonać return w więcej niż jednym miejscu. Wczesne zwracanie, gdy tylko znasz odpowiedź, często czyta się łatwiej niż zagnieżdżanie wszystkiego w else:

public class Main {
    static String grade(int score) {
        if (score >= 90) return "A";
        if (score >= 80) return "B";
        if (score >= 70) return "C";
        return "F";
    }

    public static void main(String[] args) {
        System.out.println(grade(95));   // A
        System.out.println(grade(72));   // C
        System.out.println(grade(50));   // F
    }
}

Ponieważ każde return od razu kończy metodę, wygrywa pierwszy pasujący warunek. Pilnuj tylko, by każda ścieżka w metodzie zwracającej wartość kończyła się return. Jeśli któraś gałąź może przejść dalej bez zwrócenia wartości, kompilator zgłosi "missing return statement". Końcowe return "F"; obsługuje tutaj ten przypadek.

Co oznacza tu static

Zwróć uwagę, że każda metoda powyżej jest static. Metoda static należy do samej klasy, a nie do obiektu, więc main (też static) może ją wywołać bezpośrednio po nazwie. Bez static metoda należy do instancji i do jej wywołania potrzebny byłby obiekt.

Na razie, dopóki piszesz małe programy, których logika jest obok main, oznaczaj metody pomocnicze jako static, żeby dało się je wywoływać tak samo. Gdy zaczniesz budować własne klasy i obiekty, napiszesz też metody niestatyczne (instancyjne), ale to temat rozdziału o klasach.

public class Main {
    static int doubleIt(int n) {
        return n * 2;
    }

    public static void main(String[] args) {
        // main jest static, więc może wywołać doubleIt bezpośrednio
        System.out.println(doubleIt(21));   // 42
    }
}

Zmienne lokalne zostają w metodzie

Zmienne zadeklarowane w metodzie istnieją tylko tam. Powstają, gdy metoda się uruchamia, i znikają, gdy zwraca wynik. Wywołujący nigdy ich nie widzi:

public class Main {
    static int sumTo(int limit) {
        int total = 0;                       // lokalna w sumTo
        for (int i = 1; i <= limit; i++) {
            total += i;
        }
        return total;
    }

    public static void main(String[] args) {
        System.out.println(sumTo(100));      // 5050
        // System.out.println(total);        // błąd: total nie jest tu widoczne
    }
}

total i i żyją w całości wewnątrz sumTo. Jedyne, co wychodzi poza metodę, to wartość zwracana przez return. Ta izolacja to zaleta: każda metoda jest samodzielną jednostką, którą możesz analizować bez obaw, że jej tymczasowe zmienne wyciekną albo zderzą się z nazwami gdzie indziej.

Dalej: parametry metod

Każda metoda tutaj albo nie przyjmowała danych, albo przyjmowała jedną wartość. Prawdziwe możliwości daje przekazywanie danych do metody, a Java ma konkretne zasady dotyczące przekazywania argumentów, różnic między obiektami a typami prostymi i tego, jak dać parametrowi coś w rodzaju wartości domyślnej. O tym jest następna strona.