Методы в Java: как объявлять и вызывать методы

Зачем нужны методы

Метод — это именованный блок кода, который можно запускать всякий раз, когда вы вызываете его по имени. Вместо того чтобы писать одни и те же строки снова и снова, вы пишете их один раз внутри метода и вызываете его столько раз, сколько нужно. Это делает программы короче, легче для чтения и гораздо проще в исправлении: вы меняете логику в одном месте, и все вызывающие участки получают обновление.

Вы уже вызывали методы: System.out.println(...) — это вызов метода, и list.size() тоже. Теперь вы напишете свои собственные.

Объявление и вызов метода

Объявление метода состоит из четырёх частей: типа возвращаемого значения, имени, пары скобок (для параметров) и тела в фигурных скобках. Вот самый маленький полезный пример — метод, который выполняет какую-то работу и ничего не возвращает:

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

    public static void main(String[] args) {
        printGreeting();   // вызываем его
        printGreeting();   // вызываем ещё раз
    }
}

Разберём части static void printGreeting():

• static — позволяет main вызывать его напрямую, не создавая объект (подробнее об этом ниже).
• void — этот метод не возвращает никакого значения.
• printGreeting — имя, по которому вы его вызываете.
• () — пустые скобки означают, что он не принимает входных данных.

Метод вызывается записью его имени, за которым следуют скобки. Два вызова в main выполняют тело дважды, поэтому это печатает приветствие два раза.

Возврат значения

Большинство методов что-то вычисляют и возвращают это с помощью return. Тип возвращаемого значения перед именем указывает, какого рода значение выходит наружу; здесь — 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) вычисляется в 25, которое вы можете сохранить в переменной, напечатать или использовать в более крупном выражении: вызов метода замещает собой возвращаемое им значение. В тот момент, когда выполняется return, метод завершается и управление возвращается к вызывающему коду. Любой код после return на том же пути никогда не выполняется.

Тип возвращаемого значения и возвращаемое значение должны совпадать. Объявить int и попытаться return "text"; — это ошибка компиляции: компилятор обеспечивает соблюдение контракта.

void против типа возвращаемого значения

Различие простое: используйте настоящий тип возвращаемого значения, когда вызывающему коду нужно получить значение, и void, когда метод просто что-то делает (печатает, сохраняет, обновляет состояние).

void logMessage(String msg)   // выполняет работу, ничего не возвращает
int  add(int a, int b)        // вычисляет значение, которое использует вызывающий код

Частая ошибка новичков — попытка использовать «результат» метода void:

int x = printGreeting();   // ошибка компиляции: printGreeting() возвращает void

Присваивать нечего, поэтому это не скомпилируется. Если вы ловите себя на желании получить результат метода void, это признак того, что ему стоило бы что-то возвращать.

Методы с ветвлением и ранним возвратом

Вы можете использовать return более чем в одном месте. Ранний возврат — как только вы знаете ответ — часто читается яснее, чем вложение всего в 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
    }
}

Поскольку каждый return выходит немедленно, побеждает первое подходящее условие. Просто убедитесь, что каждый путь через метод, возвращающий значение, заканчивается return: если какая-то ветка может «провалиться» без возврата, компилятор пожалуется на «missing return statement». Завершающий return "F"; здесь покрывает случай прохода до конца.

Что здесь означает static

Возможно, вы заметили, что каждый метод выше — static. Метод static принадлежит самому классу, а не какому-либо объекту, поэтому main (который тоже static) может вызывать его напрямую по имени. Без static метод принадлежит экземпляру, и вам понадобился бы объект, чтобы вызвать его на нём.

Пока вы пишете небольшие программы, логика которых живёт рядом с main, помечайте свои вспомогательные методы как static, чтобы их можно было вызывать таким же образом. Когда вы начнёте создавать собственные классы и объекты, вы будете писать и нестатические методы (методы экземпляра): это придёт с главой о классах.

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

    public static void main(String[] args) {
        // main статический, поэтому может вызвать doubleIt напрямую
        System.out.println(doubleIt(21));   // 42
    }
}

Локальные переменные остаются внутри метода

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

public class Main {
    static int sumTo(int limit) {
        int total = 0;                       // локальная для 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);        // ошибка: total здесь не виден
    }
}

total и i целиком живут внутри sumTo. Единственное, что покидает метод, — это значение, которое вы возвращаете через return. Такая изоляция — это преимущество: каждый метод представляет собой самодостаточную единицу, о которой можно рассуждать, не беспокоясь, что его временные переменные утекут наружу или столкнутся с именами в другом месте.

Далее: параметры методов

Каждый метод здесь либо не принимал входных данных, либо принимал одно значение. Настоящая мощь приходит с передачей данных внутрь — и в Java есть конкретные правила о том, как передаются аргументы, что происходит с объектами в сравнении с примитивами и как задать параметру что-то вроде значения по умолчанию. Об этом следующая страница.