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

Параметры позволяют методу принимать входные данные

Метод, который всегда делает одно и то же, ограничен. Параметры — это входные данные, которые вы объявляете внутри скобок метода, чтобы один и тот же метод мог работать с разными значениями при каждом вызове.

Вы перечисляете каждый параметр с типом и именем. Внутри тела метода параметр ведёт себя как обычная локальная переменная, которая уже содержит то, что передала вызывающая сторона.

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

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

name — это параметр. "Sam" и "Alex" — это аргументы, конкретные значения, переданные при вызове. Одно определение метода, два разных результата.

Параметры против аргументов

Эти два слова часто используют небрежно, но различие стоит держать в голове:

• Параметр — это заполнитель в объявлении: String name.
• Аргумент — это значение, которое вы действительно передаёте: "Sam".

Таким образом, void greet(String name) объявляет параметр, а greet("Sam") передаёт аргумент. Когда кто-то говорит «этот метод принимает два параметра», он имеет в виду объявление; «я передал два аргумента» — это про вызов.

Несколько параметров

Разделяйте параметры запятыми и давайте каждому свой собственный тип — нельзя разделить один тип между двумя параметрами, как это иногда делают при объявлении переменных:

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

Аргументы сопоставляются с параметрами строго по позиции, а не по имени. describe("Sam", 30, true) работает, потому что порядок совпадает с (String name, int age, boolean active). Поменяйте местами два аргумента совместимых типов — и вы получите тихую логическую ошибку, а не ошибку компиляции, поэтому порядок важен.

Распространённая ошибка — написать int add(int a, b). Каждому параметру нужен свой тип: int add(int a, int b).

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

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

public class Main {
    static double average(int a, int b, int c) {
        int sum = a + b + c;
        return sum / 3.0;   // 3.0 принудительно включает деление с плавающей точкой
    }

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

Тип возврата (double) должен соответствовать тому, что вы на самом деле возвращаете через return. Метод, объявленный как void, ничего не возвращает — он всё же может использовать простой return; для раннего выхода, но не может вернуть значение. В тот момент, когда выполняется return, метод завершается, и управление возвращается к месту вызова.

Java передаёт по значению

Это сбивает с толку почти всех поначалу. Когда вы передаёте аргумент, Java копирует значение в параметр. Для примитивов это означает, что метод получает свою собственную копию — изменение параметра никогда не затрагивает переменную вызывающей стороны:

public class Main {
    static void tryToChange(int n) {
        n = 999;   // меняет только эту локальную копию
    }

    public static void main(String[] args) {
        int x = 5;
        tryToChange(x);
        System.out.println(x);   // по-прежнему 5
    }
}

x остаётся равным 5. Метод изменил свою собственную копию числа, а не оригинал.

Передача объектов: всё ещё по значению, но следите за ссылкой

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

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

public class Main {
    static void addItem(List<String> items) {
        items.add("new");        // изменяет общий объект - видно вызывающей стороне
    }

    static void replace(List<String> items) {
        items = new ArrayList<>();   // переприсваивает только локальную копию - НЕ видно
        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);   // по-прежнему [a, b, new] - переприсваивание не вышло наружу
    }
}

Два разных результата, одно правило. addItem следует по ссылке и изменяет реальный список, поэтому вызывающая сторона видит появление new. replace переприсваивает параметру совершенно новый список — но это лишь перенаправляет локальную копию ссылки, поэтому list вызывающей стороны остаётся нетронутым. Вывод: вы можете изменить объект через параметр, но никогда не сможете заставить переменную вызывающей стороны указывать на что-то новое.

Далее: перегрузка методов

Теперь вы знаете, как передать методу именно те входные данные, которые ему нужны. Но что, если вы хотите, чтобы одно имя метода принимало разные наборы параметров — скажем, print(int) и print(String)? Это перегрузка методов, и это тема следующей страницы.