Przeciążanie metod w Javie: ta sama nazwa, inne parametry

Jedna nazwa, kilka wersji

Na poprzedniej stronie widać było, jak parametry metody określają, co ona przyjmuje. Przeciążanie metod idzie dalej: możesz nadać tę samą nazwę kilku metodom, o ile ich listy parametrów się różnią. Kompilator traktuje je jako osobne metody i wybiera właściwą na podstawie przekazanych argumentów.

Dlatego System.out.println bez problemu wypisuje int, String, boolean albo double: nie ma jednego println, jest wiele przeciążeń o tej samej nazwie. Piszesz wywołanie, o które ci chodzi, a kompilator dopasowuje je do pasującej wersji.

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

    static double square(double n) {
        return n * n;
    }

    public static void main(String[] args) {
        System.out.println(square(5));      // wywołuje wersję int  -> 25
        System.out.println(square(2.5));    // wywołuje wersję double -> 6.25
    }
}

Obie metody nazywają się square, ale jedna przyjmuje int, a druga double. Literał 5 to int, więc uruchamia się pierwsze przeciążenie; 2.5 to double, więc uruchamia się drugie.

Co liczy się jako inne przeciążenie

Przeciążenia muszą różnić się listą parametrów, czyli przynajmniej jednym z poniższych:

• inną liczbą parametrów,
• innymi typami parametrów,
• inną kolejnością typów.

public class Main {
    static String join(String a, String b) {
        return a + b;
    }

    static String join(String a, String b, String c) {   // inna liczba
        return a + b + c;
    }

    static String join(String a, int times) {             // inne typy
        return a.repeat(times);
    }

    public static void main(String[] args) {
        System.out.println(join("a", "b"));
        System.out.println(join("a", "b", "c"));
        System.out.println(join("hi", 3));
    }
}

Lista parametrów w każdym wywołaniu pasuje dokładnie do jednej z trzech metod join, więc nie ma żadnych wątpliwości.

Typ zwracany się nie liczy

Częsta pułapka początkujących: próba przeciążenia tylko po typie zwracanym. Typ zwracany nie należy do sygnatury, której używa kompilator, więc ten kod się nie kompiluje:

// NIE kompiluje się: ta sama nazwa, te same parametry, różni się tylko typ zwracany
static int   value() { return 1; }
static double value() { return 1.0; }   // error: value() jest już zdefiniowana

Kompilator nie potrafi ich odróżnić, bo w wywołaniu takim jak value() nic w argumentach nie wskazuje, o którą wersję chodzi. Przeciążenia mogą mieć różne typy zwracane, ale tylko wtedy, gdy ich listy parametrów już się różnią.

Jak Java wybiera przeciążenie

Gdy argumenty pasują do więcej niż jednego przeciążenia, Java wybiera najbardziej szczegółowe i woli dokładne dopasowanie typu od konwersji rozszerzającej. Zobacz, co się dzieje z argumentem int:

public class Main {
    static void show(int n)    { System.out.println("int: " + n); }
    static void show(long n)   { System.out.println("long: " + n); }
    static void show(double n) { System.out.println("double: " + n); }

    public static void main(String[] args) {
        show(7);     // dokładne dopasowanie -> int
        show(7L);    // dokładne dopasowanie -> long
        show(7.0);   // dokładne dopasowanie -> double
    }
}

show(7) pasuje dokładnie do int, choć long i double też pomieściłyby 7 po rozszerzeniu. Dopiero gdyby usunąć dokładne przeciążenie, kompilator rozszerzyłby int do long, a potem do double. O wyborze decyduje w całości kompilator, na podstawie zadeklarowanych typów argumentów.

Uważaj na niejednoznaczne wywołania

Jeśli żadne przeciążenie nie jest wyraźnie najlepsze, kompilator nie zgaduje, tylko zgłasza błąd. Najczęściej zdarza się to z null, który pasuje do każdego typu referencyjnego:

static void handle(String s) { }
static void handle(StringBuilder b) { }

handle(null);   // error: odwołanie do handle jest niejednoznaczne

Oba przeciążenia przyjmują null i żadne nie jest bardziej szczegółowe, więc wywołanie się nie skompiluje. Napraw to, podając typ jawnie przez rzutowanie, handle((String) null), albo przeprojektuj kod tak, by przeciążenia się nie zderzały. Ta sama ostrożność obowiązuje przy mieszaniu autoboxingu i rozszerzania; utrzymuj zestawy przeciążeń na tyle proste, by każde wywołanie miało jednego oczywistego zwycięzcę.

Przeciążanie konstruktorów

Przeciążanie nie ogranicza się do zwykłych metod. Konstruktory korzystają z niego stale, by oferować kilka sposobów tworzenia obiektu. Konstruktor bez argumentów może przekazać pracę pełniejszemu przez this(...):

public class Main {
    static class Point {
        int x, y;

        Point() {
            this(0, 0);          // deleguje do konstruktora z dwoma argumentami
        }

        Point(int x, int y) {
            this.x = x;
            this.y = y;
        }

        public String toString() {
            return "(" + x + ", " + y + ")";
        }
    }

    public static void main(String[] args) {
        System.out.println(new Point());      // (0, 0)
        System.out.println(new Point(3, 4));  // (3, 4)
    }
}

Dwa konstruktory mają wspólną nazwę Point, ale różnią się liczbą parametrów, dokładnie jak przeciążone metody. Delegowanie przez this(...) trzyma logikę inicjalizacji w jednym miejscu.

Przeciążanie a nadpisywanie

Te dwa pojęcia brzmią podobnie, ale nie mają ze sobą związku:

• Przeciążanie (overloading): ta sama nazwa, różne listy parametrów, w tej samej klasie. Kompilator wybiera wersję w czasie kompilacji. Chodzi o oferowanie wariantów operacji.
• Nadpisywanie (overriding): podklasa definiuje na nowo odziedziczoną metodę o tej samej nazwie i tych samych parametrach. Java wybiera wersję w czasie działania na podstawie rzeczywistego typu obiektu. Chodzi o zastąpienie zachowania (spotkasz je przy dziedziczeniu i polimorfizmie).

Jeśli listy parametrów są identyczne, nadpisujesz (albo powodujesz błąd zduplikowanej metody w tej samej klasie); jeśli się różnią, przeciążasz.

Dalej: varargs

Przeciążanie pozwala napisać join(a, b) i join(a, b, c) jako osobne metody. Co jednak, jeśli chcesz przyjąć dowolną liczbę argumentów bez deklarowania przeciążenia dla każdej liczby? Składnia varargs w Javie pozwala jednej metodzie przyjąć listę argumentów o zmiennej długości i o tym jest następna strona.