06-practice.md

section	06
name	Методы
type	practice

06. Методы — Практика

Пример 1: Метод greet(String name)

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

    public static void main(String[] args) {
        greet("Алексей");
        greet("Мария");
        greet("Мир");
    }
}

Разбор кода:

• void greet(String name) — объявление метода без возвращаемого значения; параметр name принимает строку при каждом вызове
• Три вызова greet(...) с разными аргументами демонстрируют повторное использование одного метода
• Каждый вызов выполняет тело метода независимо, подставляя переданный аргумент вместо name

Вывод:

Привет, Алексей!
Привет, Мария!
Привет, Мир!

Пример 2: Метод max(int a, int b) с возвращаемым значением

public class MaxMethod {
    public static int max(int a, int b) {
        if (a > b) {
            return a;
        } else {
            return b;
        }
    }

    public static void main(String[] args) {
        int result = max(15, 23);
        System.out.println("Максимум: " + result);
        System.out.println("Максимум: " + max(100, 50));
    }
}

Разбор кода:

• Тип возврата int означает, что метод обязан вернуть целое число через return
• Оба пути (if и else) заканчиваются return — компилятор это проверяет
• Результат метода можно сохранить в переменную (result) или использовать прямо в выражении (max(100, 50))

Вывод:

Максимум: 23
Максимум: 100

Пример 3: Перегрузка — add(int, int), add(double, double), add(String, String)

public class OverloadedAdd {
    public static int add(int a, int b) {
        System.out.println("Вызван add(int, int)");
        return a + b;
    }

    public static double add(double a, double b) {
        System.out.println("Вызван add(double, double)");
        return a + b;
    }

    public static String add(String a, String b) {
        System.out.println("Вызван add(String, String)");
        return a + b;
    }

    public static void main(String[] args) {
        System.out.println(add(3, 5));
        System.out.println(add(3.14, 2.71));
        System.out.println(add("Hello, ", "World!"));
    }
}

Разбор кода:

• Три метода с одним именем add — это перегрузка. Сигнатуры различаются типами параметров
• Компилятор определяет нужный вариант по типам аргументов в момент вызова: 3, 5 — целые, 3.14, 2.71 — вещественные, "Hello, ", "World!" — строки
• Перегрузка не требует разных имён для схожих операций над разными типами

Вывод:

Вызван add(int, int)
8
Вызван add(double, double)
5.85
Вызван add(String, String)
Hello, World!

Пример 4: Рекурсия — факториал

public class Factorial {
    public static long factorial(int n) {
        if (n <= 1) {
            return 1;              // базовый случай
        }
        return n * factorial(n - 1); // рекурсивный вызов
    }

    public static void main(String[] args) {
        for (int i = 0; i <= 10; i++) {
            System.out.println(i + "! = " + factorial(i));
        }
    }
}

Разбор кода:

• Базовый случай n <= 1 останавливает рекурсию и возвращает 1
• Рекурсивный вызов factorial(n - 1) решает задачу меньшего размера
• Трассировка factorial(4):

  factorial(4) = 4 * factorial(3)
                     = 3 * factorial(2)
                               = 2 * factorial(1)
                                         = 1
               = 4 * 3 * 2 * 1 = 24
  

• Тип long выбран, потому что факториал растёт очень быстро: 13! уже не помещается в int

Вывод:

0! = 1
1! = 1
2! = 2
3! = 6
4! = 24
5! = 120
6! = 720
7! = 5040
8! = 40320
9! = 362880
10! = 3628800

Пример 5: Метод с массивом — сумма и среднее

public class ArraySum {
    public static int sum(int[] arr) {
        int total = 0;
        for (int x : arr) {
            total += x;
        }
        return total;
    }

    public static double average(int[] arr) {
        return (double) sum(arr) / arr.length;
    }

    public static void main(String[] args) {
        int[] scores = {85, 92, 78, 95, 88};
        System.out.println("Сумма: " + sum(scores));
        System.out.printf("Среднее: %.2f%n", average(scores));
    }
}

Разбор кода:

• Массив передаётся в метод по ссылке: метод работает с тем же массивом, что и main
• Метод average вызывает sum — один метод может использовать другой
• Приведение (double) перед делением необходимо, чтобы получить вещественный результат, а не целочисленное деление
• System.out.printf с форматом %.2f выводит число с двумя знаками после запятой

Вывод:

Сумма: 438
Среднее: 87,60

Пример 6: ❌ Неправильно / ✅ Правильно — метод без return

❌ Неправильно (не скомпилируется):

public static int multiply(int a, int b) {
    int result = a * b;
    // Ошибка компиляции: метод должен вернуть int, но return отсутствует
}

✅ Правильно:

public static int multiply(int a, int b) {
    int result = a * b;
    return result;  // или сразу: return a * b;
}

Объяснение: компилятор Java статически проверяет, что каждый путь выполнения не-void метода заканчивается оператором return. Если хотя бы один путь не возвращает значение, компиляция завершится с ошибкой missing return statement. Это защищает от ситуации, когда метод «забывает» вернуть результат.

Попробуй сам

На основе примеров из этого раздела попробуй:

1. Напиши метод isPrime(int n), возвращающий true, если число простое (делится только на 1 и на себя)
2. Напиши перегруженный метод describe(int n) и describe(String s), выводящий разные сообщения в зависимости от типа аргумента
3. Реализуй рекурсивный метод fibonacci(int n), возвращающий n-е число Фибоначчи (где fibonacci(0) = 0, fibonacci(1) = 1)

---

← Теория | Оглавление | Задания →