К какому принципу ООП относится переопределение методов

К какому принципу ООП относится переопределение методов

Переопределение методов (Method Overriding) относится к принципу ПОЛИМОРФИЗМА (Polymorphism) — одному из четырёх столпов объектно-ориентированного программирования.

Четыре столпа ООП

1. Инкапсуляция (Encapsulation) — скрытие внутреннего состояния
2. Наследование (Inheritance) — переиспользование кода через иерархию классов
3. Полиморфизм (Polymorphism) — использование одного интерфейса для разных типов ← ВОТ ЗДЕСЬ
4. Абстракция (Abstraction) — скрытие сложности

Полиморфизм и переопределение методов

Полиморфизм означает "много форм" (poly = много, morph = форма). Один и тот же вызов метода может вести себя по-разному в зависимости от типа объекта.

Базовый пример

// Базовый класс
public abstract class Animal {
    public abstract void makeSound();  // Абстрактный метод
}

// Подклассы переопределяют метод
public class Dog extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Woof!");
    }
}

public class Cat extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Meow!");
    }
}

public class Bird extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Tweet!");
    }
}

// Полиморфизм в действии
public static void main(String[] args) {
    List<Animal> animals = new ArrayList<>();
    animals.add(new Dog());    // Собака
    animals.add(new Cat());    // Кошка
    animals.add(new Bird());   // Птица
    
    // Один код для всех типов!
    for (Animal animal : animals) {
        animal.makeSound();  // Полиморфный вызов
    }
    
    // Output:
    // Woof!
    // Meow!
    // Tweet!
    // ← Каждый объект "знает" свою реализацию
}

Механизм переопределения методов

1. Динамическое связывание (Dynamic Dispatch)

Вызванный метод определяется в runtime, а не compile-time:

Animal dog = new Dog();      // Переменная типа Animal
dog.makeSound();             // Но это вызывает Dog.makeSound()!

// В compile-time:
// Компилятор проверяет: имеет ли Animal метод makeSound()? ✓ Yes

// В runtime:
// JVM проверяет: какого РЕАЛЬНОГО типа объект dog?
// Это Dog → вызывает Dog.makeSound()

2. Virtual Method Table (VMT)

Для каждого класса JVM создаёт таблицу методов:

Animal.class VMT:
[0]: makeSound() → (must be overridden)

Dog.class VMT:
[0]: makeSound() → Dog.makeSound (реализация)

Cat.class VMT:
[0]: makeSound() → Cat.makeSound (реализация)

Вызов:
Animal animal = new Dog();
animal.makeSound();

Динамическая диспетчеризация:
1. Берём переменную animal (тип Animal)
2. Проверяем реальный класс → Dog
3. Смотрим в Dog.class VMT[0] → Dog.makeSound
4. Вызываем Dog.makeSound()

Правила переопределения (Overriding Rules)

Правило 1: Сигнатура метода должна совпадать

public class Parent {
    public void method(String param) {
        System.out.println("Parent");
    }
}

public class Child extends Parent {
    @Override
    public void method(String param) {  // Совпадает!
        System.out.println("Child");
    }
}

// Ошибка: разная сигнатура = перегрузка, не переопределение
public class WrongChild extends Parent {
    public void method(int param) {     // Другой тип параметра!
        System.out.println("Wrong");    // Это перегрузка (overloading), не переопределение
    }
}

Правило 2: Тип возврата может быть covariant (ковариантен)

public class Parent {
    public Animal getAnimal() {
        return new Animal();
    }
}

public class Child extends Parent {
    @Override
    public Dog getAnimal() {  // Более специфичный тип (Dog extends Animal) ✓
        return new Dog();
    }
}

Правило 3: Видимость не может быть уменьшена

public class Parent {
    public void publicMethod() {}
    protected void protectedMethod() {}
}

public class Child extends Parent {
    // Правильно: видимость сохранена или увеличена
    @Override
    public void publicMethod() {}  // ✓ public
    
    @Override
    public void protectedMethod() {}  // ✓ public (увеличена с protected)
    
    // ОШИБКА: видимость уменьшена!
    // @Override
    // private void publicMethod() {}  // ✗ Ошибка компиляции!
}

Правило 4: Checked исключения не могут быть добавлены

public class Parent {
    public void method() throws IOException {
        // ...
    }
}

public class Child extends Parent {
    @Override
    public void method() throws IOException {  // ✓ То же исключение
        // ...
    }
    
    // ✓ Исключение может быть удалено
    // @Override
    // public void method() {}
    
    // ✗ Новое checked исключение запрещено
    // @Override
    // public void method() throws SQLException {}
}

Переопределение vs Перегрузка (Overriding vs Overloading)

Это часто путают:

public class Animal {
    public void makeSound() {
        System.out.println("Some sound");
    }
}

public class Dog extends Animal {
    // ПЕРЕОПРЕДЕЛЕНИЕ — совпадает сигнатура, другая реализация
    @Override
    public void makeSound() {
        System.out.println("Woof!");
    }
    
    // ПЕРЕГРУЗКА — одно имя, разные параметры
    public void makeSound(int times) {
        for (int i = 0; i < times; i++) {
            System.out.println("Woof!");
        }
    }
}

public static void main(String[] args) {
    Dog dog = new Dog();
    dog.makeSound();        // Переопределённый метод
    dog.makeSound(3);       // Перегруженный метод
}

Практические примеры из Spring/Java

1. Обработка исключений

public interface ExceptionHandler {
    void handle(Exception e);
}

public class JsonExceptionHandler implements ExceptionHandler {
    @Override
    public void handle(Exception e) {
        System.out.println(Json.stringify(e));  // JSON формат
    }
}

public class XmlExceptionHandler implements ExceptionHandler {
    @Override
    public void handle(Exception e) {
        System.out.println(Xml.stringify(e));   // XML формат
    }
}

// Использование
ExceptionHandler handler = new JsonExceptionHandler();
handler.handle(new RuntimeException("Error"));
// Полиморфизм: один интерфейс, разные реализации

2. Spring Bean'ы

public interface UserRepository {
    User findById(Long id);
}

@Repository
public class DatabaseUserRepository implements UserRepository {
    @Override
    public User findById(Long id) {
        return database.query("SELECT * FROM users WHERE id = ?", id);
    }
}

@Repository
public class CacheUserRepository implements UserRepository {
    @Override
    public User findById(Long id) {
        User cached = cache.get(id);
        if (cached != null) return cached;
        User user = database.findById(id);
        cache.put(id, user);
        return user;
    }
}

// Spring автоматически инжектит правильную реализацию
@Service
public class UserService {
    @Autowired
    private UserRepository repository;  // Может быть любая реализация!
    
    public User getUser(Long id) {
        return repository.findById(id);  // Полиморфный вызов
    }
}

3. Stream API в Java 8+

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);

// Function переопределяет apply()
numbers.stream()
    .map(n -> n * 2)  // Lambda реализует Function.apply()
    .filter(n -> n > 4)  // Lambda реализует Predicate.test()
    .forEach(System.out::println);

Преимущества полиморфизма

// БЕЗ полиморфизма — много условных операторов
public void makeAnimalsSound(List<Animal> animals) {
    for (Animal animal : animals) {
        if (animal instanceof Dog) {
            ((Dog) animal).makeSound();
        } else if (animal instanceof Cat) {
            ((Cat) animal).makeSound();
        } else if (animal instanceof Bird) {
            ((Bird) animal).makeSound();
        }
        // Много дублирования!
    }
}

// С полиморфизмом — чистый и простой код
public void makeAnimalsSound(List<Animal> animals) {
    for (Animal animal : animals) {
        animal.makeSound();  // Один вызов для всех!
    }
}

Производительность

Одна из причин, почему Java быстра — оптимизация полиморфизма:

// JIT компилятор может оптимизировать часто используемые методы
for (int i = 0; i < 1_000_000; i++) {
    dog.makeSound();  // JIT может "узнать", что это всегда Dog
                      // и закэшировать реализацию
}
// На 1,000,000 итерациях выигрыш значительный!

Vs других концепций

ПОЛИМОРФИЗМ = один интерфейс, множество реализаций

Ремонт автомобиля:
Интерфейс: repair()  → один метод

Реализации:
- ToyotaRepairService.repair()  → специализированный ремонт для Toyota
- HondaRepairService.repair()   → специализированный ремонт для Honda
- GenericRepairService.repair() → универсальный ремонт

Механик (клиент кода) вызывает repair() одинаково,
но каждый сервис выполняет свой ремонт!

Заключение

Переопределение методов (overriding) — это практическая реализация полиморфизма:

• Один интерфейс (сигнатура метода)
• Множество реализаций (переопределённые методы в подклассах)
• Динамическое связывание (выбор метода в runtime)

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

Полиморфизм — один из самых мощных механизмов ООП!