Урок 22 для Java-разработчика. 💻💡Методы в Java: Ваш Персональный Арсенал для Управления Кодом!

Урок 22 для Java-разработчика. 💻💡Методы в Java: Ваш Персональный Арсенал для Управления Кодом!

Привет, будущий гений Java! Если вы уже освоили классы и объекты, а также разобрались, что такое поля, то сегодня мы сделаем следующий гигантский шаг — погрузимся в мир методов. Представьте, что ваш объект — это супергерой. Поля — это его костюм, гаджеты и сверхспособности. А методы? Это то, как он использует эти гаджеты и способности, чтобы спасать мир! Методы — это наши "глаголы" в коде, действия, которые объекты могут выполнять. Давайте разберемся, как они работают!

Что такое Метод? Ваш Командный Центр

Представьте, что вы строите робота. Вы уже дали ему глаза (поля для зрения) и руки (поля для хватания). Теперь ему нужно научиться видеть и хватать. Вот тут на сцену выходят методы.

Метод в Java — это, по сути, блок кода, который выполняет определенную задачу. Методы:

• Живут внутри классов: Они всегда являются частью какого-то "чертежа" (класса) и описывают поведение объектов этого класса.
• Используют данные класса (поля): Методы могут читать, изменять и использовать информацию, которая хранится в полях.
• Принимают "посылки" (параметры): Иногда методу нужна дополнительная информация для работы. Эту информацию мы передаем ему в виде аргументов (значений), которые метод принимает через свои параметры.
• Возвращают "результат" своей работы: После выполнения задачи метод может вернуть какой-то результат обратно в ту часть кода, которая его вызвала.
• Могут объявлять "временных помощников" (локальные переменные): Внутри себя метод может использовать переменные, которые существуют только во время его выполнения.

Думайте о методе как о маленькой, специализированной программе внутри большой программы. Он знает, что делать, и когда вы его "вызываете", он начинает свою работу.

Анатомия Метода: Разбираем на Запчасти

Давайте взглянем на типичную структуру метода. Это как рецепт приготовления чего-то:

public int calculateSum (int num1, int num2) {
// Доступ // Тип // Имя // Параметры
// // возвращаемого // метода
// // значения

// Тело метода: здесь происходят все действия
int result = num1 + num2; // Локальная переменная для хранения суммы
return result; // Возвращаем результат
}

Разберем каждый компонент:

• Модификатор доступа (public, private, protected, или ничего - default): Это как "кто" может использовать ваш метод.
  public: Метод доступен отовсюду.
  private: Метод доступен только внутри того же класса.
  protected: Метод доступен внутри того же пакета и в классах-наследниках.
  default (без модификатора): Метод доступен только внутри того же пакета.
• Возвращаемый тип (int, String, void и т.д.): Это "что" метод вернет после своей работы.
  Если метод выполняет действие и ничего не возвращает, указываем void (пустота).
  Если он возвращает число, указываем int, double и т.д.
  Если он возвращает текст, указываем String.
  И так далее, для любого типа данных.
• Имя метода (calculateSum): Это "как" называется ваш метод. Должно быть информативным, начинаться с маленькой буквы, а каждое следующее слово — с заглавной (стиль camelCase). Например: getName, processData, saveFile.
• Список параметров (int num1, int num2): Это "что" метод принимает на вход. В круглых скобках через запятую перечисляются типы и имена переменных, которые метод будет использовать как входные данные. Если метод ничего не принимает, скобки остаются пустыми ().
• Тело метода { ... }: Это "где" происходит вся магия! Между фигурными скобками находится сам код, который выполняет задачи метода. Здесь могут быть объявления локальных переменных, циклы, условия и любые другие инструкции Java.
• Инструкция return (если тип возврата не void): Это "вернуть" что-то. Если метод не void, он должен вернуть значение того типа, который указан в его сигнатуре.

Примеры Методов: С Результатом и Без

Давайте посмотрим на два классических примера:

1. Метод, Возвращающий Результат: "Машина для Сложения"

Этот метод принимает два числа, складывает их и возвращает результат.

public class MathMachine {
// Этот метод находит сумму двух чисел и возвращает её.
public int sum(int a, int b) { // public - доступен отовсюду, int - возвращает целое число, sum - имя, a и b - параметры
int result = 0; // Локальная переменная 'result', существует только внутри этого метода
result = a + b; // Выполняем сложение и сохраняем в 'result'
return result; // Возвращаем значение 'result'
}
}

Комментарии к каждой строчке кода:

• public class MathMachine { — Объявляем публичный класс MathMachine.
• public int sum(int a, int b) { — Объявляем публичный метод sum. Он возвращает целое число (int) и принимает два параметра: a и b, оба типа int.
• int result = 0; — Объявляем локальную переменную result типа int и инициализируем её нулём. Она будет видна только внутри этого метода.
• result = a + b; — Выполняем операцию сложения параметров a и b, сохраняя результат в переменной result.
• return result; — Возвращаем значение переменной result из метода. Это значение будет получено той частью кода, которая вызвала метод sum.
• } — Закрываем метод sum.
• } — Закрываем класс MathMachine.

2. Метод Без Возвращаемого Результата: "Обратный Отсчет"

Этот метод просто печатает обратный отсчет, но ничего не возвращает.

public class RocketLauncher {
// Этот метод имитирует обратный отсчет перед запуском ракеты. Он ничего не возвращает (void).
public void startCountdown(int startNumber) { // public - доступен отовсюду, void - ничего не возвращает, startCountdown - имя, startNumber - параметр
if (startNumber > 10 || startNumber <= 0) { // Проверяем условие: если число больше 10 или меньше/равно 0
System.out.println("Запуск отменен! Неверное начальное число."); // Выводим сообщение об ошибке
} else { // Иначе (если число в диапазоне от 1 до 10)
while (startNumber > 0) { // Запускаем цикл, пока startNumber больше 0
System.out.println(startNumber--); // Выводим текущее число, затем уменьшаем его на 1
try {
Thread.sleep(500); // Приостанавливаем выполнение на 0.5 секунды, для драматизма!
} catch (InterruptedException e) {
Thread.currentThread().interrupt(); // Обрабатываем возможное прерывание потока
}
}
System.out.println("Старт! Ракета пошла!"); // После отсчета выводим "Старт!"
}
}
}

Комментарии к каждой строчке кода:

• public class RocketLauncher { — Объявляем публичный класс RocketLauncher (Пусковая установка ракет).
• public void startCountdown(int startNumber) { — Объявляем публичный метод startCountdown (начать отсчет). Он ничего не возвращает (void) и принимает один параметр startNumber типа int.
• if (startNumber > 10 || startNumber <= 0) { — Начинаем условный блок if. Проверяем, если startNumber больше 10 ИЛИ startNumber меньше или равен 0.
• System.out.println("Запуск отменен! Неверное начальное число."); — Если условие истинно, выводим сообщение об ошибке.
• } else { — Иначе (если startNumber находится в допустимом диапазоне от 1 до 10)...
• while (startNumber > 0) { — Начинаем цикл while. Он будет выполняться, пока startNumber больше 0.
• System.out.println(startNumber--); — Выводим текущее значение startNumber, а затем уменьшаем его на 1 (оператор startNumber--).
• try { Thread.sleep(500); } catch (InterruptedException e) { Thread.currentThread().interrupt(); } — Это небольшой "хак" для замедления отсчета. Thread.sleep(500) заставляет программу "заснуть" на 500 миллисекунд (полсекунды). Блок try-catch нужен для обработки возможных ошибок.
• System.out.println("Старт! Ракета пошла!"); — После завершения цикла выводим финальное сообщение.
• } — Закрываем блок else.
• } — Закрываем метод startCountdown.
• } — Закрываем класс RocketLauncher.

Вызов Метода: Дайте Команду!

Вызов метода — это команда для его выполнения. Когда вы "вызываете" метод, управление программой передается ему. Он выполняет свой код, а затем (если не возвращает значение) управление возвращается обратно туда, откуда он был вызван. Если метод возвращает значение, это значение появляется в точке вызова.

Синтаксис Вызова:

имяОбъекта.имяМетода(аргумент1, аргумент2, ...);

Или для статических методов:

ИмяКласса.имяМетода(аргумент1, аргумент2, ...);

Аргументы (значения, которые мы передаем методу) могут быть:

• Литералами: myMethod(10, "hello");
• Выражениями: myMethod(5 + 3, someVariable * 2);
• Переменными: int x = 10; myMethod(x);

Примеры Вызова:

1. Получение Результата от Метода:

Java

public class GreetingMachine {
// Статический метод, который просто возвращает приветствие.
public static String getWelcomeMessage() {
return "Добро пожаловать в нашу цифровую вселенную!";
}

public static void main(String[] args) { // Главный метод, откуда начинается выполнение
// Вызываем метод getWelcomeMessage() и присваиваем его результат переменной message.
String message = getWelcomeMessage();
System.out.println(message); // Выводим полученное сообщение
}
}

Комментарии к каждой строчке кода:

• public class GreetingMachine { — Объявляем публичный класс GreetingMachine (Машина приветствий).
• public static String getWelcomeMessage() { — Объявляем статический метод getWelcomeMessage. static означает, что этот метод принадлежит классу GreetingMachine, а не конкретному объекту, и его можно вызвать напрямую через имя класса. Он возвращает String.
• return "Добро пожаловать в нашу цифровую вселенную!"; — Метод возвращает указанную строку.
• public static void main(String[] args) { — Стандартный главный метод Java, точка входа в программу.
• String message = getWelcomeMessage(); — Здесь происходит вызов метода. Мы вызываем статический метод getWelcomeMessage() и присваиваем возвращаемое им строковое значение локальной переменной message типа String.
• System.out.println(message); — Выводим содержимое переменной message на консоль.
• } — Закрываем метод main.
• } — Закрываем класс GreetingMachine.

2. Вызов Метода Без Аргументов:

public class BellTower {
// Метод, который имитирует звон колокола. Не принимает аргументов и ничего не возвращает.
public void ringBell() {
System.out.println("Дзинь-дон! Дзинь-дон!");
}

public static void main(String[] args) {
BellTower myBell = new BellTower(); // Создаем объект класса BellTower
myBell.ringBell(); // Вызываем метод ringBell() для объекта myBell. Скобки пустые, так как нет аргументов.
}
}

Комментарии к каждой строчке кода:

• public class BellTower { — Объявляем публичный класс BellTower (Колокольня).
• public void ringBell() { — Объявляем публичный метод ringBell. Он ничего не возвращает (void) и не принимает аргументов (()).
• System.out.println("Дзинь-дон! Дзинь-дон!"); — Выводим сообщение о звоне колокола.
• public static void main(String[] args) { — Главный метод.
• BellTower myBell = new BellTower(); — Создаем новый объект myBell класса BellTower.
• myBell.ringBell(); — Здесь происходит вызов метода. Мы вызываем метод ringBell() для объекта myBell. Поскольку метод не принимает аргументов, скобки после его имени остаются пустыми.
• } — Закрываем метод main.
• } — Закрываем класс BellTower.

3. Вызов Метода С Аргументами:

public class RecipeBook {
// Метод для приготовления простого блюда. Принимает название блюда и его основной ингредиент.
public void cookDish(String dishName, String mainIngredient) {
System.out.println("Готовим " + dishName + " с основным ингредиентом: " + mainIngredient + "!");
System.out.println("Приятного аппетита!");
}

public static void main(String[] args) {
RecipeBook myCookbook = new RecipeBook(); // Создаем объект кулинарной книги
// Вызываем метод cookDish, передавая два строковых аргумента.
myCookbook.cookDish("Борщ", "свекла"); // Первый вызов
myCookbook.cookDish("Паста Карбонара", "бекон"); // Второй вызов
}
}

Комментарии к каждой строчке кода:

• public class RecipeBook { — Объявляем публичный класс RecipeBook (Кулинарная книга).
• public void cookDish(String dishName, String mainIngredient) { — Объявляем публичный метод cookDish (приготовить блюдо). Он ничего не возвращает (void) и принимает два строковых параметра: dishName (название блюда) и mainIngredient (основной ингредиент).
• System.out.println("Готовим " + dishName + " с основным ингредиентом: " + mainIngredient + "!"); — Выводим сообщение, используя значения переданных параметров.
• System.out.println("Приятного аппетита!"); — Выводим дополнительное сообщение.
• public static void main(String[] args) { — Главный метод.
• RecipeBook myCookbook = new RecipeBook(); — Создаем новый объект myCookbook класса RecipeBook.
• myCookbook.cookDish("Борщ", "свекла"); — Здесь происходит вызов метода. Мы вызываем метод cookDish() для объекта myCookbook и передаем ему два строковых аргумента: "Борщ" и "свекла". Эти аргументы будут присвоены параметрам dishName и mainIngredient соответственно внутри метода.
• myCookbook.cookDish("Паста Карбонара", "бекон"); — Второй вызов того же метода с другими аргументами.
• } — Закрываем метод main.
• } — Закрываем класс RecipeBook.

Важно! Количество и типы аргументов при вызове метода должны строго соответствовать количеству и типам параметров в его описании. Иначе Java будет ругаться и выдаст ошибку!

Способы Передачи Аргументов: Копия или Ссылка?

Это один из самых важных моментов, который часто путает новичков. Как именно данные попадают в метод?

1. Передача "По Значению" (Pass by Value)

Когда вы передаете в метод примитивные типы данных (такие как int, double, boolean, char и т.д.), в метод передается копия их значения. Это значит, что если вы измените значение параметра внутри метода, оригинальная переменная вне метода не изменится.

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

public class PrimitivePlayground {
// Метод, который пытается изменить переданное число.
public void tryToChangeNumber(int number) {
System.out.println("Внутри метода: Исходное значение number = " + number); // 10
number = 99; // Меняем значение локальной копии параметра
System.out.println("Внутри метода: Новое значение number = " + number); // 99
}

public static void main(String[] args) {
PrimitivePlayground pp = new PrimitivePlayground();
int originalNumber = 10; // Оригинальная переменная
System.out.println("До вызова метода: originalNumber = " + originalNumber); // 10

pp.tryToChangeNumber(originalNumber); // Вызываем метод, передавая КОПИЮ значения 10

System.out.println("После вызова метода: originalNumber = " + originalNumber); // Все еще 10!
}
}

Комментарии к каждой строчке кода:

• public class PrimitivePlayground { — Объявляем публичный класс PrimitivePlayground.
• public void tryToChangeNumber(int number) { — Объявляем метод tryToChangeNumber. Он принимает параметр number типа int.
• System.out.println("Внутри метода: Исходное значение number = " + number); — Выводим значение number внутри метода до его изменения.
• number = 99; — Изменяем значение параметра number. Это изменение касается только копии значения, переданной в этот метод.
• System.out.println("Внутри метода: Новое значение number = " + number); — Выводим новое значение number внутри метода.
• public static void main(String[] args) { — Главный метод.
• PrimitivePlayground pp = new PrimitivePlayground(); — Создаем объект pp.
• int originalNumber = 10; — Объявляем и инициализируем переменную originalNumber.
• System.out.println("До вызова метода: originalNumber = " + originalNumber); — Выводим значение originalNumber до вызова метода.
• pp.tryToChangeNumber(originalNumber); — Вызываем метод, передавая значение originalNumber. Java создает копию значения 10 и передает её в tryToChangeNumber.
• System.out.println("После вызова метода: originalNumber = " + originalNumber); — Выводим значение originalNumber после вызова метода. Вы увидите, что оно осталось 10, потому что метод работал с копией.
• } — Закрываем метод main.
• } — Закрываем класс PrimitivePlayground.

2. Передача "По Ссылке" (Pass by Reference Value)

Когда вы передаете в метод объекты (ссылочные типы данных, например, String, массивы, или любой ваш собственный класс, типа Cat или Book), в метод передается копия ссылки на объект, а не сам объект. Это как дать другу адрес вашего дома. У него будет адрес, и он сможет прийти в ваш дом и изменить что-то внутри него.

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

Пример: У вас есть цифровой питомец — кот! Вы передаете "ссылку" на него в метод trainPet(). Метод "тренирует" кота (меняет его внутреннее состояние), и эти изменения видны всем!

// Класс Cat - наш цифровой питомец
class Cat {
private boolean isTrained = false; // Поле: обучен ли кот (по умолчанию нет)
private String name; // Имя кота

public Cat(String name) { // Конструктор для создания кота с именем
this.name = name;
}

// Метод, чтобы узнать, обучен ли кот
public boolean isTrained() {
return isTrained;
}

// Метод для обучения кота
public void train() {
isTrained = true; // Меняем состояние кота: теперь он обучен!
}

// Метод для получения имени
public String getName() {
return name;
}
}

public class PetTrainer {
// Метод для тренировки кота. Принимает КОПИЮ ССЫЛКИ на объект Cat.
public static void trainPet(Cat catToTrain) {
System.out.println("Внутри метода trainPet: Кот '" + catToTrain.getName() + "' обучен? " + catToTrain.isTrained());
catToTrain.train(); // Вызываем метод train() у объекта, на который указывает ссылка catToTrain
System.out.println("Внутри метода trainPet: Кот '" + catToTrain.getName() + "' теперь обучен? " + catToTrain.isTrained());
}

public static void main(String[] args) {
Cat fluffy = new Cat("Пушок"); // Создаем объект Cat по имени "Пушок"
System.out.println("До вызова trainPet: Кот '" + fluffy.getName() + "' обучен? " + fluffy.isTrained());

trainPet(fluffy); // Передаем КОПИЮ ССЫЛКИ на объект 'fluffy'

System.out.println("После вызова trainPet: Кот '" + fluffy.getName() + "' обучен? " + fluffy.isTrained());
}
}

Комментарии к каждой строчке кода:

• class Cat { — Объявляем класс Cat.
• private boolean isTrained = false; — Приватное поле isTrained (обучен) типа boolean. Оно private, значит, доступно только внутри этого класса.
• private String name; — Приватное поле name (имя) типа String.
• public Cat(String name) { — Конструктор класса Cat. Используется для создания нового объекта Cat и установки его имени.
• this.name = name; — Присваиваем переданное имя полю name текущего объекта.
• public boolean isTrained() { — Публичный метод для получения статуса isTrained.
• return isTrained; — Возвращает текущее значение isTrained.
• public void train() { — Публичный метод train (тренировать).
• isTrained = true; — Изменяет значение поля isTrained на true.
• public String getName() { — Публичный метод для получения имени кота.
• return name; — Возвращает имя.
• public class PetTrainer { — Объявляем публичный класс PetTrainer (Дрессировщик животных).
• public static void trainPet(Cat catToTrain) { — Объявляем статический метод trainPet. Он принимает параметр catToTrain типа Cat. Здесь catToTrain — это копия ссылки на объект Cat.
• System.out.println("Внутри метода trainPet: Кот '" + catToTrain.getName() + "' обучен? " + catToTrain.isTrained()); — Выводим статус обучения кота внутри метода.
• catToTrain.train(); — Вызываем метод train() для объекта, на который указывает catToTrain. Поскольку catToTrain и fluffy (из main) указывают на один и тот же объект в памяти, это изменение затронет оригинальный объект.
• System.out.println("Внутри метода trainPet: Кот '" + catToTrain.getName() + "' теперь обучен? " + catToTrain.isTrained()); — Выводим статус обучения после вызова train().
• public static void main(String[] args) { — Главный метод.
• Cat fluffy = new Cat("Пушок"); — Создаем объект Cat с именем "Пушок" и присваиваем его ссылку переменной fluffy.
• System.out.println("До вызова trainPet: Кот '" + fluffy.getName() + "' обучен? " + fluffy.isTrained()); — Выводим статус обучения до вызова метода.
• trainPet(fluffy); — Вызываем метод trainPet, передавая копию ссылки на объект fluffy.
• System.out.println("После вызова trainPet: Кот '" + fluffy.getName() + "' обучен? " + fluffy.isTrained()); — Выводим статус обучения после вызова метода. Вы увидите, что fluffy теперь обучен, потому что метод trainPet изменил оригинальный объект.
• } — Закрываем метод main.
• } — Закрываем класс PetTrainer.

Методы с Переменным Числом Аргументов (Varargs): Когда Не Знаешь, Сколько Будет!

Иногда нам нужно, чтобы метод мог принимать разное количество аргументов одного типа. Например, метод sum() должен складывать не только два числа, но и три, и десять, и хоть сто! Для этого в Java есть varargs (Variable Arguments – переменное число аргументов).

Синтаксис: тип_данных... имя_параметра

public class ScoreCalculator {
// Метод calcSum принимает переменное число аргументов типа int.
// Троеточие (...) показывает, что это varargs.
public int calculateTotalScore(int... scores) { // int... scores означает, что сюда можно передать 0 или более чисел int
int total = 0; // Локальная переменная для накопления суммы
// Внутри метода 'scores' обрабатывается как массив int[]
for (int score : scores) { // Используем цикл for-each для перебора всех переданных оценок
total += score; // Добавляем каждую оценку к общей сумме
}
return total; // Возвращаем общую сумму
}
}

public class GameSession {
public static void main(String[] args) {
ScoreCalculator calculator = new ScoreCalculator(); // Создаем объект калькулятора

// Вызываем метод с разным количеством аргументов
System.out.println("Счет без очков: " + calculator.calculateTotalScore()); // 0 аргументов
System.out.println("Счет за один раунд: " + calculator.calculateTotalScore(150)); // 1 аргумент
System.out.println("Счет за два раунда: " + calculator.calculateTotalScore(200, 350)); // 2 аргумента
System.out.println("Счет за несколько раундов: " + calculator.calculateTotalScore(100, 50, 250, 400, 75)); // Много аргументов
}
}

Комментарии к каждой строчке кода:

• public class ScoreCalculator { — Объявляем публичный класс ScoreCalculator (Калькулятор очков).
• public int calculateTotalScore(int... scores) { — Объявляем публичный метод calculateTotalScore. Он возвращает int и принимает переменное число аргументов (varargs) типа int. int... scores означает, что scores будет восприниматься внутри метода как массив int[].
• int total = 0; — Объявляем локальную переменную total для хранения суммы очков.
• for (int score : scores) { — Используем улучшенный цикл for-each. Он перебирает каждый элемент (score) в массиве scores.
• total += score; — Добавляем текущую оценку score к total.
• return total; — Возвращаем итоговую сумму.
• public class GameSession { — Объявляем публичный класс GameSession (Игровая сессия).
• public static void main(String[] args) { — Главный метод.
• ScoreCalculator calculator = new ScoreCalculator(); — Создаем объект calculator.
• System.out.println("Счет без очков: " + calculator.calculateTotalScore()); — Вызываем метод без аргументов. Varargs позволяет это (считается, что передан пустой массив).
• System.out.println("Счет за один раунд: " + calculator.calculateTotalScore(150)); — Вызываем метод с одним аргументом.
• System.out.println("Счет за два раунда: " + calculator.calculateTotalScore(200, 350)); — Вызываем метод с двумя аргументами.
• System.out.println("Счет за несколько раундов: " + calculator.calculateTotalScore(100, 50, 250, 400, 75)); — Вызываем метод с множеством аргументов.
• } — Закрываем метод main.
• } — Закрываем класс GameSession.

Важные моменты про Varargs:

• Ноль или более: Метод с varargs можно вызвать без аргументов, с одним аргументом или с множеством аргументов.
• Как массив: Внутри метода varargs-параметр ведет себя как обычный массив.
• Последний параметр: Если метод имеет другие параметры вместе с varargs-параметром, то varargs-параметр должен быть последним в списке параметров. Например: public void processOrder(String customerName, double... itemPrices) — это корректно. public void processOrder(double... itemPrices, String customerName) — это ошибка!

Ключевое слово final для Методов: Неизменяемое Поведение

Когда метод объявлен с ключевым словом final, это означает, что этот метод не может быть переопределен в дочерних классах (наследниках). Это полезно, когда вы хотите гарантировать, что определенное поведение класса останется неизменным, независимо от того, как этот класс расширяется.

Представьте, что у вас есть класс SuperHero с методом fly(). Если вы сделаете fly() final, то ни один другой супергерой, наследующий от SuperHero, не сможет изменить способ полета. Он всегда будет летать именно так, как вы это определили!

class BaseVehicle {
// Этот метод объявлен как final, поэтому его нельзя переопределить в подклассах.
public final void startEngine() {
System.out.println("Двигатель запущен с базовой процедурой. ВРРРУМ!");
}

public void drive() {
System.out.println("Транспортное средство едет.");
}
}

class SportsCar extends BaseVehicle {
// Попытка переопределить final метод вызовет ошибку компиляции!
// public void startEngine() { // Это приведет к ошибке!
// System.out.println("Спортивный автомобиль: Двигатель запущен по-особому!");
// }

@Override // Аннотация @Override помогает проверить, что метод действительно переопределяется
public void drive() {
System.out.println("Спортивный автомобиль мчится по шоссе!");
}
}

public class VehicleShowroom {
public static void main(String[] args) {
BaseVehicle genericCar = new BaseVehicle();
genericCar.startEngine(); // Вызываем базовый метод
genericCar.drive();

System.out.println("---");

SportsCar ferrari = new SportsCar();
ferrari.startEngine(); // Вызываем метод startEngine из BaseVehicle, так как он final
ferrari.drive(); // Вызываем переопределенный метод drive из SportsCar
}
}

Комментарии к каждой строчке кода:

• class BaseVehicle { — Объявляем базовый класс BaseVehicle (Базовое транспортное средство).
• public final void startEngine() { — Объявляем публичный метод startEngine. Ключевое слово final означает, что этот метод не может быть переопределен (изменен) в любых дочерних классах, которые будут наследовать от BaseVehicle.
• System.out.println("Двигатель запущен с базовой процедурой. ВРРРУМ!"); — Действие метода startEngine.
• public void drive() { — Объявляем обычный публичный метод drive (ехать). Его можно переопределять.
• System.out.println("Транспортное средство едет."); — Действие метода drive.
• class SportsCar extends BaseVehicle { — Объявляем класс SportsCar (Спортивный автомобиль), который наследует (extends) от BaseVehicle.
• // public void startEngine() { ... } — Этот закомментированный блок демонстрирует, что если бы мы попытались переопределить startEngine, компилятор выдал бы ошибку.
• @Override — Аннотация, которая сообщает компилятору, что мы намерены переопределить метод из родительского класса. Это хорошая практика для проверки.
• public void drive() { — Переопределяем метод drive. Теперь SportsCar будет "ехать" по-своему.
• System.out.println("Спортивный автомобиль мчится по шоссе!"); — Новое действие переопределенного метода drive.
• public class VehicleShowroom { — Объявляем публичный класс VehicleShowroom (Автосалон).
• public static void main(String[] args) { — Главный метод.
• BaseVehicle genericCar = new BaseVehicle(); — Создаем объект BaseVehicle.
• genericCar.startEngine(); — Вызываем startEngine.
• genericCar.drive(); — Вызываем drive.
• System.out.println("---"); — Разделитель для вывода.
• SportsCar ferrari = new SportsCar(); — Создаем объект SportsCar.
• ferrari.startEngine(); — Вызываем startEngine для SportsCar. Поскольку он final в BaseVehicle, будет вызван метод из BaseVehicle.
• ferrari.drive(); — Вызываем drive для SportsCar. Поскольку он переопределен, будет вызван метод из SportsCar.
• } — Закрываем метод main.
• } — Закрываем класс VehicleShowroom.

Примеры Задач для Практики: Ваша Лаборатория Кода!

Примеры Задач для Практики: Ваша Лаборатория Кода!

Приготовьтесь закрепить знания на практике!

Для Начинающих Магов:

Задача 1: Расчет Площади Прямоугольника

Описание: Создайте класс GeometryCalculator с методом calculateRectangleArea(double length, double width), который принимает длину и ширину прямоугольника и возвращает его площадь. В main методе вызовите этот метод с разными значениями и выведите результаты.

// Класс GeometryCalculator
class GeometryCalculator {
// Метод для расчета площади прямоугольника
public double calculateRectangleArea(double length, double width) {
return length * width; // Возвращаем произведение длины на ширину
}
}

// Пример использования в main методе:
// GeometryCalculator geo = new GeometryCalculator();
// double area1 = geo.calculateRectangleArea(10.0, 5.0);
// System.out.println("Площадь прямоугольника 1: " + area1); // Ожидаем 50.0

Задача 2: Приветствие по Имени

Описание: Создайте класс Greeter с методом sayHello(String name), который принимает имя человека и выводит на консоль персональное приветствие, например, "Привет, [Имя]! Добро пожаловать!". Этот метод ничего не должен возвращать.

// Класс Greeter
class Greeter {
// Метод для приветствия по имени
public void sayHello(String name) {
System.out.println("Привет, " + name + "! Добро пожаловать!");
}
}

// Пример использования в main методе:
// Greeter greeter = new Greeter();
// greeter.sayHello("Алиса");

Задача 3: Проверка Четности Числа

Описание: Создайте класс NumberChecker с методом isEven(int number), который принимает целое число и возвращает true, если оно четное, и false, если нечетное. Используйте оператор % (остаток от деления).

// Класс NumberChecker
class NumberChecker {
// Метод для проверки четности числа
public boolean isEven(int number) {
return number % 2 == 0; // Если остаток от деления на 2 равен 0, то число четное
}
}

// Пример использования в main методе:
// NumberChecker checker = new NumberChecker();
// System.out.println("Число 4 четное? " + checker.isEven(4)); // true
// System.out.println("Число 7 четное? " + checker.isEven(7)); // false

Задача 4: Управление Окном Приложения

Описание: Создайте класс ApplicationWindow с полем isOpen (булевый тип) и методами openWindow() и closeWindow(). Эти методы должны менять состояние isOpen и выводить соответствующие сообщения. Убедитесь, что метод closeWindow() корректно обрабатывает попытку закрыть уже закрытое окно. Методы ничего не возвращают.

// Класс ApplicationWindow
class ApplicationWindow {
boolean isOpen = false; // Поле: открыто ли окно

// Метод для открытия окна
public void openWindow() {
if (!isOpen) {
isOpen = true;
System.out.println("Окно открыто.");
} else {
System.out.println("Окно уже открыто.");
}
}

// Метод для закрытия окна
public void closeWindow() {
if (isOpen) {
isOpen = false;
System.out.println("Окно закрыто.");
} else {
System.out.println("Окно уже закрыто.");
}
}
}

// Пример использования в main методе:
// ApplicationWindow myApp = new ApplicationWindow();
// myApp.openWindow();
// myApp.closeWindow();
// myApp.closeWindow(); // Попытка закрыть уже закрытое

Для Продвинутых Заклинателей:

Задача 5: Управление Плейлистом (Varargs)

Описание: Создайте класс MusicPlayer с методом addToPlaylist(String... songs), который принимает переменное количество названий песен. Метод должен вывести "Добавляю в плейлист:" и затем список всех добавленных песен.

// Класс MusicPlayer
class MusicPlayer {
// Метод для добавления песен в плейлист с переменным числом аргументов
public void addToPlaylist(String... songs) {
System.out.println("Добавляю в плейлист:");
if (songs.length == 0) {
System.out.println(" (Нет песен для добавления)");
return;
}
for (String song : songs) {
System.out.println(" - " + song);
}
}
}

// Пример использования в main методе:
// MusicPlayer player = new MusicPlayer();
// player.addToPlaylist("Summer Time", "Blue Bossa", "Autumn Leaves");
// player.addToPlaylist("Take Five");
// player.addToPlaylist(); // Добавление пустого списка

Задача 6: Обновление Статуса Заказа (Передача по Ссылке)

Описание: Создайте класс Order со строковым полем status (например, "В обработке", "Отправлен", "Доставлен"). Создайте метод updateOrderStatus(Order order, String newStatus) в другом классе OrderProcessor. Этот метод должен принимать объект Order и новую строку статуса, и изменять статус объекта Order. Покажите, что изменение, сделанное в OrderProcessor, видно в main методе.

// Класс Order
class Order {
String orderId;
String status; // Статус заказа

public Order(String id, String initialStatus) {
this.orderId = id;
this.status = initialStatus;
}
}

// Класс OrderProcessor
class OrderProcessor {
// Метод для обновления статуса заказа. Принимает ссылку на объект Order.
public void updateOrderStatus(Order orderToUpdate, String newStatus) {
System.out.println("Processor: Старый статус заказа " + orderToUpdate.orderId + ": " + orderToUpdate.status);
orderToUpdate.status = newStatus; // Изменяем статус объекта, на который указывает ссылка
System.out.println("Processor: Новый статус заказа " + orderToUpdate.orderId + ": " + orderToUpdate.status);
}
}

// Пример использования в main методе:
// Order myOrder = new Order("ORD001", "В обработке");
// System.out.println("Main: Изначальный статус заказа " + myOrder.orderId + ": " + myOrder.status);

// OrderProcessor processor = new OrderProcessor();
// processor.updateOrderStatus(myOrder, "Отправлен"); // Передаем ссылку на myOrder

// System.out.println("Main: Статус заказа после обработки: " + myOrder.status); // Статус изменился!

Задача 7: Вычисление Степени (Финализация Метода)

Описание: Создайте базовый класс MathOperation с final методом power(int base, int exponent), который вычисляет base в степени exponent (например, 2 в степени 3 равно 8). Попробуйте создать дочерний класс AdvancedMathOperation и переопределить этот метод. Объясните, почему это невозможно.

// Базовый класс для математических операций
class MathOperation {
// Метод power является final, его нельзя переопределить.
public final long power(int base, int exponent) {
if (exponent < 0) {
System.out.println("Показатель степени не может быть отрицательным.");
return -1; // Возвращаем ошибку или выбрасываем исключение
}
long result = 1;
for (int i = 0; i < exponent; i++) {
result *= base;
}
return result;
}
}

// Дочерний класс AdvancedMathOperation
class AdvancedMathOperation extends MathOperation {
// !!!!!!!!!!! Эта часть кода вызовет ошибку компиляции !!!!!!!!!!!
// public long power(int base, int exponent) { // Ошибка: Cannot override the final method from MathOperation
// System.out.println("Это попытка переопределить final метод!");
// return super.power(base, exponent); // Вызов родительского метода
// }
// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

// Можно добавить новые методы или переопределить не-final методы
public long multiply(int a, int b) {
return (long)a * b;
}
}

// Пример использования в main методе:
// MathOperation basicOp = new MathOperation();
// System.out.println("2 в степени 3: " + basicOp.power(2, 3)); // 8

// AdvancedMathOperation advOp = new AdvancedMathOperation();
// // advOp.power(3, 2); // Этот вызов будет использовать final метод из MathOperation
// // Если раскомментировать переопределение, будет ошибка компиляции.

Задача 8: Объединение Строк (Varargs и Дополнительный Параметр)

Описание: Создайте класс TextFormatter с методом concatenateStrings(String separator, String... words). Этот метод должен принимать сначала строку-разделитель (например, ", " или " - ") и затем переменное количество слов. Метод должен объединить все слова, используя указанный разделитель, и вернуть полученную строку. Если слов нет, вернуть пустую строку.

// Класс TextFormatter
class TextFormatter {
// Метод для объединения строк с разделителем и переменным числом слов
public String concatenateStrings(String separator, String... words) {
if (words.length == 0) {
return ""; // Если слов нет, возвращаем пустую строку
}
StringBuilder resultBuilder = new StringBuilder(); // Используем StringBuilder для эффективной конкатенации

// Добавляем первое слово
resultBuilder.append(words[0]);

// Добавляем остальные слова с разделителем
for (int i = 1; i < words.length; i++) {
resultBuilder.append(separator).append(words[i]);
}
return resultBuilder.toString(); // Преобразуем StringBuilder в String и возвращаем
}
}

// Пример использования в main методе:
// TextFormatter formatter = new TextFormatter();
// System.out.println("Список покупок: " + formatter.concatenateStrings(", ", "Молоко", "Хлеб", "Яйца"));
// System.out.println("Хештеги: " + formatter.concatenateStrings(" #", "java", "programming", "methods", "varargs"));
// System.out.println("Пустой список: '" + formatter.concatenateStrings(" - ", ) + "'"); // Передаем 0 слов

Тест на Самопроверку: Насколько Вы Гуру?

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

Вопрос 1: Если метод принимает в качестве параметра примитивный тип данных (например, int), и внутри метода это значение изменяется, изменится ли оригинальная переменная вне метода?

а) Да

б) Нет

Вопрос 2: Какой из следующих вызовов метода processData будет компилироваться без ошибок, если метод объявлен как public void processData(String prefix, int... numbers)?

а) processData("Start");

б) processData("Values", 10, 20, 30);

в) processData(50, "End");

г) processData("Mixed", 1.5, 2);

Вопрос 3: Какие из следующих описаний методов являются корректными с точки зрения синтаксиса Java (могут быть скомпилированы без ошибок)?

а) void calculateArea() { }

б) int getResult(int x) { return x * 2; }

в) String buildMessage() { return "Hello"; }

г) double process()

д) void displayInfo(String name, int age) { }

Вопрос 4: Если у вас есть класс Parent с методом printMessage() и дочерний класс Child пытается переопределить этот метод, какое ключевое слово в описании printMessage() в классе Parent сделает это переопределение невозможным?

а) static

б) public

в) final

г) void

Задание Перед Выводом: Управление Складом с Автоматизацией!

Описание: Создайте класс WarehouseItem (Товар на складе) с полями: itemId (ID товара, String), name (название, String), quantity (количество, int).

Затем создайте класс WarehouseManager (Менеджер склада). В этом классе:

1. Статическое поле totalItemsInWarehouse (общее количество всех товаров на складе) типа int, инициализированное 0.
2. Метод receiveItems(WarehouseItem item, int receivedQuantity), который принимает объект WarehouseItem и количество поступивших товаров. Этот метод должен увеличивать item.quantity на receivedQuantity и добавлять receivedQuantity к totalItemsInWarehouse.
3. Метод dispatchItems(WarehouseItem item, int dispatchedQuantity), который принимает объект WarehouseItem и количество отгруженных товаров. Этот метод должен уменьшать item.quantity на dispatchedQuantity. Убедитесь, что item.quantity не становится отрицательным (если пытаются отгрузить больше, чем есть, выводите сообщение об ошибке). Также уменьшайте totalItemsInWarehouse на dispatchedQuantity (только если отгрузка прошла успешно).
4. Статический метод displayWarehouseSummary(), который выводит текущее значение totalItemsInWarehouse.

В main методе:

• Создайте несколько объектов WarehouseItem (например, "Молоко", "Хлеб").
• Используя методы WarehouseManager, примите на склад несколько партий разных товаров.
• Отгрузите часть товаров.
• Выведите статус каждого товара (ID, название, количество) и общую сводку склада после каждой операции. Попробуйте отгрузить больше, чем есть, и посмотрите на результат.

Это задание поможет вам попрактиковаться в использовании полей (экземпляра и статических) и различных типов методов (с параметрами, без возврата, статических), а также в передаче объектов.

Удачи, будущий логист Java!

Вывод: Наши Достижения

Сегодня мы освоили фундамент любого серьезного Java-приложения — методы! Теперь вы знаете, что:

• Методы — это кирпичики функциональности, позволяющие вашим объектам выполнять действия.
• Мы разобрали анатомию метода: модификаторы доступа, возвращаемые типы, имена и параметры.
• Вы научились вызывать методы, передавая им нужные аргументы.
• Мы выяснили тонкости передачи аргументов по значению (для примитивов) и по ссылке (для объектов), что критически важно для понимания поведения кода.
• Открыли для себя varargs — мощный инструмент для работы с переменным числом аргументов.
• Изучили ключевое слово final, которое позволяет "заморозить" поведение метода, предотвращая его переопределение.

Теперь ваш арсенал знаний по Java значительно пополнился! Вы не просто пишете код, вы начинаете его организовывать и управлять им. Практикуйтесь с примерами и заданиями, это закрепит ваши новые навыки. Вперед, к новым вершинам в программировании!

Ответы на Тест:

Вопрос 1: Если метод принимает в качестве параметра примитивный тип данных (например, int), и внутри метода это значение изменяется, изменится ли оригинальная переменная вне метода?

Ответ: б) Нет (Происходит передача по значению, изменяется только копия)

Вопрос 2: Какой из следующих вызовов метода processData будет компилироваться без ошибок, если метод объявлен как public void processData(String prefix, int... numbers)?

Ответ: б) processData("Values", 10, 20, 30); (Соответствует сигнатуре: String в начале, затем 0 или более int)

• а) Некорректно: processData("Start"); - корректно, так как numbers может быть пустым. (Мой недочёт в изначальном ответе, varargs может принимать 0 аргументов).
• в) Некорректно: Первый аргумент должен быть String.
• г) Некорректно: Аргументы после prefix должны быть int, а не double.

Вопрос 3: Какие из следующих описаний методов являются корректными с точки зрения синтаксиса Java (могут быть скомпилированы без ошибок)?

Ответ: а) void calculateArea() { }

б) int getResult(int x) { return x * 2; }

в) String buildMessage() { return "Hello"; }

д) void displayInfo(String name, int age) { }

• г) double process() - Некорректно, отсутствует тело метода {}.

Вопрос 4: Если у вас есть класс Parent с методом printMessage() и дочерний класс Child пытается переопределить этот метод, какое ключевое слово в описании printMessage() в классе Parent сделает это переопределение невозможным?

Ответ: в) final