Перегрузка методов в Java: одно имя, разные параметры

Одно имя, несколько версий

На предыдущей странице вы видели, как параметры метода определяют, что он принимает. Перегрузка методов идёт дальше: вы можете дать нескольким методам одно имя, лишь бы их списки параметров различались. Компилятор рассматривает их как отдельные методы и выбирает нужный по передаваемым аргументам.

Именно поэтому System.out.println спокойно выводит int, String, boolean или double — существует не один println, а множество перегрузок с общим именем. Вы пишете нужный вызов, а компилятор сопоставляет его с подходящей версией.

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));      // вызывает версию для int  -> 25
        System.out.println(square(2.5));    // вызывает версию для double -> 6.25
    }
}

Оба метода называются square, но один принимает int, а другой — double. Литерал 5 — это int, поэтому выполняется первая перегрузка; 2.5 — это double, поэтому выполняется вторая.

Что считается другой перегрузкой

Перегрузки должны различаться списком параметров — то есть хотя бы одним из следующего:

• другим числом параметров,
• другими типами параметров или
• другим порядком типов.

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

    static String join(String a, String b, String c) {   // другое количество
        return a + b + c;
    }

    static String join(String a, int times) {             // другие типы
        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));
    }
}

У каждого вызова список параметров точно совпадает ровно с одним из трёх методов join, поэтому никакой путаницы нет.

Тип возвращаемого значения не учитывается

Частая ловушка для новичков: попытка перегрузить только по типу возвращаемого значения. Тип возвращаемого значения не входит в сигнатуру, которую использует компилятор, поэтому это не компилируется:

// НЕ компилируется - одно имя, одни параметры, различается только тип возврата
static int   value() { return 1; }
static double value() { return 1.0; }   // ошибка: value() уже определён

Компилятор не может их различить, потому что в точке вызова вроде value() ничто в аргументах не подсказывает, какой вариант вам нужен. Можно задавать перегрузкам разные типы возврата, но только когда их списки параметров уже различаются.

Как Java выбирает перегрузку

Когда подойти под ваши аргументы могут несколько перегрузок, Java выбирает наиболее конкретную и предпочитает точное совпадение типов расширяющему преобразованию. Посмотрите, что происходит с аргументом 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);     // точное совпадение -> int
        show(7L);    // точное совпадение -> long
        show(7.0);   // точное совпадение -> double
    }
}

show(7) точно совпадает с int, хотя long и double тоже могли бы вместить 7 после расширения. Только если убрать точную перегрузку, компилятор расширил бы int до long, а затем до double. Это разрешение полностью определяется на этапе компиляции, исходя из объявленных типов ваших аргументов.

Остерегайтесь неоднозначных вызовов

Если ни одна перегрузка не является явно лучшим совпадением, компилятор отказывается угадывать и сообщает об ошибке. Чаще всего это случается с null, который подходит к любому ссылочному типу:

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

handle(null);   // ошибка: ссылка на handle неоднозначна

Обе перегрузки принимают null, и ни одна не является более конкретной, поэтому вызов не компилируется. Исправьте это, явно указав тип через приведение — handle((String) null) — или переработав код так, чтобы перегрузки не конфликтовали. Та же осторожность нужна при сочетании автоупаковки и расширения; держите наборы перегрузок достаточно простыми, чтобы у каждого вызова был один очевидный победитель.

Перегрузка конструкторов

Перегрузка не ограничивается обычными методами — конструкторы используют её постоянно, чтобы предложить несколько способов создания объекта. Конструктор без аргументов может делегировать более полному через this(...):

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

        Point() {
            this(0, 0);          // делегируем конструктору с двумя аргументами
        }

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

Оба конструктора носят имя Point, но различаются числом параметров — ровно как перегруженные методы. Делегирование через this(...) оставляет логику инициализации в одном месте.

Перегрузка против переопределения

Эти два понятия звучат похоже, но между ними нет связи:

• Перегрузка — одно имя, разные списки параметров, в одном классе. Компилятор выбирает версию на этапе компиляции. Речь о предоставлении вариантов операции.
• Переопределение — подкласс заново определяет унаследованный метод с тем же именем и теми же параметрами. Java выбирает версию во время выполнения на основе реального типа объекта. Речь о замене поведения (вы встретите его при изучении наследования и полиморфизма).

Если списки параметров одинаковы — это переопределение (или ошибка дублирования метода в одном классе); если различаются — это перегрузка.

Далее: Varargs

Перегрузка позволяет написать join(a, b) и join(a, b, c) как отдельные методы — но что, если нужно принимать любое число аргументов, не объявляя перегрузку для каждого количества? Синтаксис varargs в Java позволяет одному методу принимать список аргументов переменной длины, и это тема следующей страницы.