Java: методы (функции)

Урок 4: Методы в Java – твои личные помощники

Введение: Зачем нам методы?

Представь, что ты строишь робота. У этого робота есть разные функции: он может идти вперёд, поворачивать, поднимать руку и говорить «Привет!». Каждая из этих функций – это отдельная команда. Теперь представь, что тебе нужно, чтобы робот сделал 10 шагов вперёд, повернул налево, поднял руку и сказал «Привет!». Если бы у тебя не было отдельных команд, тебе пришлось бы каждый раз писать огромную программу, где ты подробно описываешь, как именно нужно сделать шаг, как поднять руку и т.д. Это было бы очень неудобно и долго.

В программировании методы – это те самые отдельные команды. Они позволяют нам разбить большую задачу на маленькие, понятные кусочки. Ты можешь один раз написать метод «сделать шаг», а потом просто вызывать его столько раз, сколько нужно. Это как конструктор Lego: у тебя есть готовые блоки, из которых ты собираешь что-то большое.

В Java метод – это блок кода, который выполняет определённое действие. У него есть имя, и когда ты хочешь, чтобы это действие выполнилось, ты просто «вызываешь» метод по имени. Методы делают код:

• Понятнее – вместо кучи строк кода ты видишь осмысленные названия действий.
• Короче – не нужно повторять один и тот же код много раз.
• Удобнее для изменений – если нужно что-то исправить, ты меняешь код только в одном месте – в методе.

На этом уроке мы научимся создавать собственные методы и пользоваться ими. Поехали!

Как устроен метод? Анатомия метода

Любой метод в Java состоит из нескольких частей. Давай разберём их на примере простого метода, который печатает на экран приветствие.

// Объявление метода
public static void sayHello() {
    // Тело метода
    System.out.println("Привет, мир!");
}

Разберём каждую часть:

1. Модификаторы доступа – слово public. Пока запомни, что мы всегда будем писать public. Это значит, что метод доступен из любого места программы.
2. Ключевое слово static – мы тоже будем его использовать в наших уроках. Оно означает, что метод принадлежит классу, а не объекту. Пока просто пиши его всегда.
3. Возвращаемый тип – слово void. Оно говорит, что метод ничего не возвращает, он просто выполняет действие (например, печатает текст). Если метод должен что-то вернуть (например, число), мы пишем тип этого значения (int, String, и т.д.).
4. Имя метода – sayHello. Это имя мы придумываем сами. Важно: имя должно быть понятным и начинаться с маленькой буквы. Если имя состоит из нескольких слов, каждое следующее слово пишется с большой буквы (это называется camelCase).
5. Круглые скобки () – в них мы можем указать параметры (входные данные), которые метод принимает. Пока у нас скобки пустые.
6. Тело метода – код внутри фигурных скобок {}. Здесь мы пишем то, что метод должен делать.

Теперь, чтобы использовать этот метод, нам нужно его вызвать. Вызов метода выглядит так:

public class Main {
    public static void main(String[] args) {
        // Вызов метода sayHello
        sayHello();
        sayHello();
        sayHello();
    }

    // Наш метод
    public static void sayHello() {
        System.out.println("Привет, мир!");
    }
}

Запусти программу, и ты увидишь, что «Привет, мир!» напечатается три раза. Мы не писали три раза одну и ту же строку кода – мы просто три раза вызвали метод. Удобно, правда?

Методы с параметрами: даём методу данные

Методы были бы не такими полезными, если бы они всегда делали одно и то же. Представь, что у тебя есть метод «сложить два числа». Но какие именно числа складывать? Для этого существуют параметры – это данные, которые мы передаём методу при вызове.

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

Давай создадим метод, который приветствует пользователя по имени:

public static void greetUser(String name) {
    System.out.println("Привет, " + name + "!");
}

Здесь String name – это параметр. String – это тип (строка), а name – имя параметра. Внутри метода мы используем name как обычную переменную.

Теперь вызовем этот метод:

public class Main {
    public static void main(String[] args) {
        greetUser("Анна");
        greetUser("Петя");
        greetUser("Мария");
    }

    public static void greetUser(String name) {
        System.out.println("Привет, " + name + "!");
    }
}

Программа напечатает:

Привет, Анна!
Привет, Петя!
Привет, Мария!

Видишь, как это удобно? Один метод, а работает с разными данными.

Теперь сделаем метод с двумя параметрами – сложение двух чисел:

public static void printSum(int a, int b) {
    int sum = a + b;
    System.out.println("Сумма " + a + " и " + b + " равна " + sum);
}

Вызов:

printSum(5, 3);
printSum(10, 20);

Вывод:

Сумма 5 и 3 равна 8
Сумма 10 и 20 равна 30

Методы, возвращающие значение: получаем результат

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

Для этого нужно:

1. Вместо void указать тип возвращаемого значения (например, int для целого числа).
2. Внутри метода использовать ключевое слово return, после которого указать значение, которое метод возвращает.

Пример – метод, который возвращает удвоенное число:

public static int doubleNumber(int number) {
    int result = number * 2;
    return result; // Возвращаем результат
}

Теперь мы можем использовать этот метод так:

public class Main {
    public static void main(String[] args) {
        int x = 5;
        int doubledX = doubleNumber(x); // doubledX теперь равно 10
        System.out.println("Удвоенное " + x + " равно " + doubledX);
        
        // Можно сразу использовать результат в другом выражении
        System.out.println("Удвоенное 7 равно " + doubleNumber(7));
    }

    public static int doubleNumber(int number) {
        int result = number * 2;
        return result;
    }
}

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

Реальные аналогии: методы в жизни

Давай представим, что ты – робот-помощник на кухне. У тебя есть набор команд (методов):

• порезать(овощ) – принимает овощ и возвращает нарезанные кусочки.
• сварить(вода, макароны) – принимает воду и макароны, ничего не возвращает (просто варит).
• приготовитьСалат(помидор, огурец) – принимает ингредиенты и возвращает готовый салат.

Теперь, чтобы приготовить обед, тебе не нужно думать о том, как именно резать помидор или как варить макароны. Ты просто вызываешь готовые методы. Это и есть суть программирования – разбивать сложные задачи на простые шаги.

Практический пример: калькулятор

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

public class Calculator {
    public static void main(String[] args) {
        int a = 10;
        int b = 5;
        
        System.out.println("Числа: " + a + " и " + b);
        System.out.println("Сложение: " + add(a, b));
        System.out.println("Вычитание: " + subtract(a, b));
        System.out.println("Умножение: " + multiply(a, b));
        System.out.println("Деление: " + divide(a, b));
    }
    
    // Метод для сложения
    public static int add(int x, int y) {
        return x + y;
    }
    
    // Метод для вычитания
    public static int subtract(int x, int y) {
        return x - y;
    }
    
    // Метод для умножения
    public static int multiply(int x, int y) {
        return x * y;
    }
    
    // Метод для деления
    public static double divide(int x, int y) {
        // Если делить целые числа, Java отбросит дробную часть.
        // Поэтому мы преобразуем одно из чисел в double
        return (double) x / y;
    }
}

Обрати внимание на метод divide. Если мы поделим 10 на 3, то должны получить 3.333..., а не 3. Для этого мы преобразовали x в double (число с плавающей точкой) с помощью (double). Это называется приведение типа.

Параметры и аргументы: в чём разница?

Часто эти слова путают. Давай разберёмся:

• Параметр – это переменная, которая указана в объявлении метода. Например, в public static void greetUser(String name) параметром является String name.
• Аргумент – это конкретное значение, которое мы передаём методу при вызове. Например, в greetUser("Анна") аргументом является строка "Анна".

Проще говоря: параметр – это «коробка» для данных, а аргумент – то, что мы кладём в эту коробку.

Перегрузка методов (overloading)

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

Пример: метод printInfo, который может принимать разные данные.

public class OverloadExample {
    public static void main(String[] args) {
        printInfo("Анна");
        printInfo("Анна", 15);
        printInfo(25);
    }
    
    // Версия 1: только имя
    public static void printInfo(String name) {
        System.out.println("Имя: " + name);
    }
    
    // Версия 2: имя и возраст
    public static void printInfo(String name, int age) {
        System.out.println("Имя: " + name + ", Возраст: " + age);
    }
    
    // Версия 3: только возраст
    public static void printInfo(int age) {
        System.out.println("Возраст: " + age);
    }
}

Когда мы вызываем printInfo("Анна"), Java видит, что передан один аргумент типа String, и выбирает первую версию. Если передаём два аргумента – вторую, и так далее.

Перегрузка делает код более гибким. Например, метод System.out.println() тоже перегружен – он может принимать целые числа, строки, числа с плавающей точкой и т.д.

Область видимости переменных

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

public class ScopeExample {
    public static void main(String[] args) {
        int x = 10; // переменная x видна только в методе main
        myMethod();
        // System.out.println(y); // Ошибка! y не видна здесь
    }
    
    public static void myMethod() {
        int y = 20; // переменная y видна только в myMethod
        // System.out.println(x); // Ошибка! x не видна здесь
        System.out.println("y = " + y);
    }
}

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

Практические задания

Теперь твоя очередь! Попробуй выполнить эти задания самостоятельно. Если что-то не получается – перечитай урок или попроси помощи.

Задание 1: Приветствие с возрастом

Создай метод greetWithAge, который принимает имя (String) и возраст (int) и печатает сообщение: «Привет, [имя]! Тебе [возраст] лет.» В методе main вызови его три раза с разными данными.

Подсказка: Используй два параметра.

Задание 2: Максимум из двух чисел

Создай метод max, который принимает два целых числа и возвращает большее из них. Если числа равны, верни любое. В методе main протестируй его с разными парами чисел и выведи результат на экран.

Подсказка: Используй if-else внутри метода.

Задание 3: Таблица умножения

Создай метод printMultiplicationTable, который принимает целое число n и печатает таблицу умножения для этого числа от 1 до 10. Например, для числа 5 метод должен вывести:

5 * 1 = 5
5 * 2 = 10
...
5 * 10 = 50

В методе main вызови его для чисел 3, 7 и 9.

Подсказка: Используй цикл for внутри метода.

Заключение

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

• Создавать методы, которые выполняют действия (тип void).
• Создавать методы, которые принимают параметры.
• Создавать методы, которые возвращают значения.
• Использовать перегрузку методов.
• Понимать область видимости переменных.

Методы – это твои лучшие друзья в программировании. Они помогают делать код чистым, понятным и удобным для повторного использования. На следующем уроке мы узнаем, как методы могут работать с массивами, и научимся создавать ещё более сложные и полезные программы.

А пока – практикуйся! Чем больше ты пишешь код, тем быстрее запоминаешь. Удачи!