Методы #

Метод - это именованный блок кода, который можно вызывать из других мест программы. Он принимает входные данные (параметры), выполняет определённые действия и может возвращать результат.

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

Например, мы пишем программу, которая должна найти сумму всех элементов в трёх массивах. Без методов код будет выглядеть так:

public class Main {
    public static void main(String[] args) {
        // Первый массив
        int[] arr1 = {1, 2, 3, 4, 5};
        int sum1 = 0;
        for (int i = 0; i < arr1.length; i++) {
            sum1 += arr1[i];
        }
        System.out.println("Сумма первого массива: " + sum1);
        
        // Второй массив
        int[] arr2 = {10, 20, 30};
        int sum2 = 0;
        for (int i = 0; i < arr2.length; i++) {
            sum2 += arr2[i];
        }
        System.out.println("Сумма второго массива: " + sum2);
        // Второй массив
        int[] arr3 = {7, 8, 9, 10};
        int sum3 = 0;
        for (int i = 0; i < arr3.length; i++) {
            sum3 += arr3[i];
        }
        System.out.println("Сумма третьего массива: " + sum3);
    }
}

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

public class Main {
	// Метод для поиска суммы элементов массива
	public static int calculateSum(int[] array) {
		int sum = 0;
		for (int i = 0; i < array.length; i++) {
            sum += array[i];
        }
        return sum;
	}
	
	void main() { // Валидная форма метода main для Java 25. Подробнее в сноске ниже
		// Те же массвы
		int[] arr1 = {1, 2, 3, 4, 5};
        int[] arr2 = {10, 20, 30};
        int[] arr3 = {7, 8, 9, 10};
        
        IO.println(calculateSum(arr1)); // используем метод
        IO.println(calculateSum(arr2));
        IO.println(calculateSum(arr3));
	}
}

Методы позволяют вынести повторяющийся код в отдельный блок и потом вызывать его по имени. Программа стала короче, код - чище, а вся логика сосредоточена в одном месте. Захотели что-то поменять - не надо переписывать весь код. Достаточно поменять один метод.

public static void main(String[] args) {...}

void main() {...}

Анатомия метода #

Рассмотрим объявление метода подробнее:

public static void helloWorld(String text) {
	IO.println("Hello " + text + "!");
}

• public - модификатор доступа. Пока мы пишем всё в одном классе, он просто должен быть public, чтобы метод можно было вызвать из main (который тоже public). Подробно о модификаторах поговорим в блоке ООП.
• static - ключевое слово, означающее, что метод принадлежит самому классу, а не конкретному объекту. Поскольку мы пока используем только статический main, все наши вспомогательные методы тоже должны быть static. Иначе мы не сможем их вызвать без создания объекта. Подробнее также в блоке ООП.
• void - тип возвращаемого значения. void означает, что метод ничего не возвращает. Он просто что-то делает.
• helloWorld - имя метода. Для именования методов используется тот же стиль, что и для переменных.
• (String text) - параметры метода. В скобках перечисляются переменные, которые метод принимает извне. Каждая переменная указывается с типом и именем.

Вызов метода #

Чтобы метод выполнился, его, очевидно, нужно вызвать. Вызов метода из main выглядит как обращение по имени с передачей аргументов в скобках:

helloWorld("World"); // Hello World!

Здесь "world" - это аргумент, который передаётся в метод. Внутри метода он попадает в переменную text.

Если метод не принимает параметров, скобки остаются пустыми:

// Объявление
public static hello() {
	IO.println("Hello!");
}

// Вызов
hello();

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

Метод может не только выполнять действия, но и возвращать результат. Тип возвращаемого значения указывается вместо void. Для возврата используется ключевое слово return.

Пример метода, который вычисляет сумму двух чисел:

public static int sum(int a, int b) {
    int result = a + b;
    return result;
}

Вызов такого метода можно использовать в выражениях:

int x = sum(5, 10); // x = 15
System.out.println(sum(3, 4)); // 7

Метод с return завершает свою работу сразу после выполнения return. Код после return в том же блоке не выполнится.

public static int getMax(int a, int b) {
    if (a > b) {
        return a;
    } 
    return b;
}

В примере выше можно не оборачивать return b в else. Если первое условие a > b выполнится, то вызовется return a, метод завершит работу и выполнение до второго return b не дойдёт.

return также можно использовать и в void-методах для досрочного выхода:

public static void printPositive(int number) {
    if (number <= 0) {
        return; // выходим, ничего не делаем
    }
    System.out.println("Число положительное: " + number);
}

Параметры и локальные переменные #

Параметры метода - это переменные, доступные только внутри тела метода. Их значения задаются при вызове. Внутри метода можно объявлять и свои собственные переменные - они называются локальными.

public static int square(int x) {
    int result = x * x; // result — локальная переменная, потому что создана внутри метода
    return result;
}

// Тут a и b - ПАРАМЕТРЫ
public static int add(int a, int b) {
        return a + b;
    }

// Тут 5 и 3 - АРГУМЕНТЫ
int result1 = add(5, 3);

// Тут x и y - тоже АРГУМЕНТЫ
int x = 10;
int y = 20;
int result2 = add(x, y);

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

public static void main(String[] args) {
    int a = 5;
    printTwice(a);
    // System.out.println(result); // ОШИБКА: result недоступна здесь
}

public static void printTwice(int value) {
    int result = value * 2;
    System.out.println(result);
    // System.out.println(a); // ОШИБКА: a недоступна здесь
}

Перегрузка методов #

В Java можно создавать несколько методов с одинаковым именем, но разными параметрами. Это называется перегрузкой. Компилятор сам выбирает подходящий метод по типам и количеству аргументов.

public static int sum(int a, int b) {
    return a + b;
}

public static double sum(double a, double b) {
    return a + b;
}

public static int sum(int a, int b, int c) {
    return a + b + c;
}

Теперь можно вызывать:

int result1 = sum(1, 2);       // вызовется первая версия
double result2 = sum(1.5, 2.5); // вторая
int result3 = sum(1, 2, 3);    // третья

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

Практическая работа №4 #

1. Метод приветствия #

Напишите метод greet, который принимает имя (строку) и выводит сообщение: Привет, <имя>!. Вызовите его из main для нескольких имён.

2. Минимум из трёх чисел #

Создайте метод minOfThree, который принимает три целых числа и возвращает наименьшее из них. В main запросите у пользователя три числа и выведите результат.

3. Проверка на чётность #

Напишите метод isEven, который принимает целое число и возвращает true, если число чётное, и false в противном случае. Используйте его в программе, которая выводит, является ли введённое пользователем число чётным.

4. Обработка массива #

Напишите два метода:

• fillArray - принимает массив целых чисел и заполняет его случайными числами от 1 до 100 (используйте Math.random() или класс Random).
• printArray - принимает массив и выводит его элементы через пробел. В main создайте массив на 10 элементов, заполните и выведите.

5. Возврат массива #

Напишите метод reverseArray, который принимает массив целых чисел и возвращает новый массив с элементами в обратном порядке. Не используйте встроенные методы копирования.

6*. Калькулятор с методами #

Реализуйте программу-калькулятор, которая просит пользователя ввести два числа и операцию (+, -, *, /), затем выполняет вычисление. Для каждой операции создайте отдельный метод: add, subtract, multiply, divide. Метод divide должен проверять, не делит ли пользователь на ноль, и выводить сообщение об ошибке.