Что такое переопределение метода?

Переопределение метода (Method Overriding)

Переопределение метода — это механизм объектно-ориентированного программирования, который позволяет подклассу предоставить конкретную реализацию метода, уже определённого в его суперклассе. Это один из столпов полиморфизма в Java.

Базовая концепция

Переопределение возникает, когда:

1. Дочерний класс наследует методы от родительского класса
2. Дочерний класс переопределяет некоторые из этих методов
3. Сигнатура метода остаётся той же, но реализация меняется

// Родительский класс
public class Animal {
    public void makeSound() {
        System.out.println("Generic animal sound");
    }
    
    public void eat() {
        System.out.println("Animal is eating");
    }
}

// Дочерний класс 1
public class Dog extends Animal {
    @Override  // Аннотация для проверки переопределения
    public void makeSound() {
        System.out.println("Woof! Woof!");
    }
    
    // eat() не переопределён, будет использоваться родительская версия
}

// Дочерний класс 2
public class Cat extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Meow!");
    }
}

// Использование полиморфизма
public class Main {
    public static void main(String[] args) {
        Animal dog = new Dog();
        Animal cat = new Cat();
        Animal generic = new Animal();
        
        dog.makeSound();      // Вывод: Woof! Woof!
        cat.makeSound();      // Вывод: Meow!
        generic.makeSound();  // Вывод: Generic animal sound
        
        // Все наследуют eat()
        dog.eat();           // Вывод: Animal is eating
        cat.eat();           // Вывод: Animal is eating
    }
}

Правила переопределения

1. Сигнатура метода должна быть идентична

public class Parent {
    public void doSomething(int x) {
        System.out.println("Parent: " + x);
    }
}

public class Child extends Parent {
    // ✅ Правильно: идентичная сигнатура
    @Override
    public void doSomething(int x) {
        System.out.println("Child: " + x);
    }
    
    // ❌ Неправильно: другой тип параметра — это перегрузка, не переопределение
    public void doSomething(String x) {
        System.out.println("Child overload: " + x);
    }
}

2. Модификатор доступа не может быть более строгим

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

public class Child extends Parent {
    // ✅ Правильно: от public к public
    @Override
    public void publicMethod() {}
    
    // ✅ Правильно: от protected к public (расширение доступа)
    @Override
    public void protectedMethod() {}
    
    // ❌ Неправильно: от protected к private (сужение доступа)
    // @Override
    // private void protectedMethod() {}  // Compile Error!
}

3. Возвращаемый тип может быть более узким (Covariant Return Types)

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

public class Child extends Parent {
    // ✅ Правильно: Dog является подтипом Animal (covariant)
    @Override
    public Dog getAnimal() {
        return new Dog();
    }
}

public class AnotherChild extends Parent {
    // ❌ Неправильно: String не является подтипом Animal
    // @Override
    // public String getAnimal() {}  // Compile Error!
}

4. Исключения

public class Parent {
    public void riskyMethod() throws IOException {
        // может выкинуть IOException
    }
}

public class Child extends Parent {
    // ✅ Правильно: то же исключение
    @Override
    public void riskyMethod() throws IOException {}
    
    // ✅ Правильно: подкласс исключения
    // @Override
    // public void riskyMethod() throws FileNotFoundException {}  // OK
    
    // ✅ Правильно: вообще без исключений
    @Override
    public void riskyMethod() {}  // Throws nothing
    
    // ❌ Неправильно: новое исключение
    // @Override
    // public void riskyMethod() throws Exception {}  // Compile Error!
}

Переопределение vs Перегрузка

Это частая путаница:

public class Calculator {
    // Перегрузка (Overloading): РАЗНЫЕ сигнатуры
    public int add(int a, int b) {
        return a + b;
    }
    
    public double add(double a, double b) {
        return a + b;
    }
    
    public int add(int a, int b, int c) {
        return a + b + c;
    }
}

public class Parent {
    public void process() {
        System.out.println("Parent processing");
    }
}

// Переопределение (Overriding): ТА ЖЕ сигнатура
public class Child extends Parent {
    @Override
    public void process() {  // ИДЕНТИЧНАЯ сигнатура
        System.out.println("Child processing");
    }
}

Динамическая диспетчеризация (Dynamic Dispatch)

Это сердце полиморфизма в Java. Метод вызывается в runtime на основе типа ОБЪЕКТА, а не типа переменной:

public class Demo {
    public static void main(String[] args) {
        // Тип переменной: Animal
        // Тип объекта: Dog
        Animal animal = new Dog();
        
        // Вызовется Dog.makeSound(), а не Animal.makeSound()
        // Решение принимается в runtime!
        animal.makeSound();  // Вывод: Woof! Woof!
    }
    
    // Полиморфный метод
    public static void animalConcert(Animal[] animals) {
        for (Animal animal : animals) {
            // Вызывается переопределённый метод каждого конкретного типа
            animal.makeSound();
        }
    }
}

public class Main {
    public static void main(String[] args) {
        Animal[] animals = {
            new Dog(),
            new Cat(),
            new Bird()
        };
        
        Demo.animalConcert(animals);
        // Вывод:
        // Woof! Woof!
        // Meow!
        // Tweet!
    }
}

Интерфейсы и переопределение

Од из наиболее распространённых форм переопределения — реализация методов интерфейса:

public interface PaymentGateway {
    void processPayment(double amount);
    void refund(String transactionId);
}

// Первая реализация
public class StripeGateway implements PaymentGateway {
    @Override
    public void processPayment(double amount) {
        System.out.println("Processing $" + amount + " via Stripe");
        // Stripe API call
    }
    
    @Override
    public void refund(String transactionId) {
        System.out.println("Refunding transaction " + transactionId);
    }
}

// Вторая реализация
public class PayPalGateway implements PaymentGateway {
    @Override
    public void processPayment(double amount) {
        System.out.println("Processing $" + amount + " via PayPal");
        // PayPal API call
    }
    
    @Override
    public void refund(String transactionId) {
        System.out.println("Refunding via PayPal");
    }
}

// Использование
public class PaymentProcessor {
    private PaymentGateway gateway;
    
    public PaymentProcessor(PaymentGateway gateway) {
        this.gateway = gateway;  // Зависимость внедрена
    }
    
    public void processOrder(double amount) {
        gateway.processPayment(amount);  // Вызовется нужная реализация
    }
}

public class Main {
    public static void main(String[] args) {
        PaymentProcessor stripe = new PaymentProcessor(new StripeGateway());
        PaymentProcessor paypal = new PaymentProcessor(new PayPalGateway());
        
        stripe.processOrder(100);  // Via Stripe
        paypal.processOrder(200);  // Via PayPal
    }
}

@Override аннотация

Обязательно используй @Override:

// ✅ Хорошо
@Override
public void method() {
    // реализация
}

// ❌ Плохо — опечатка пройдёт незамеченной
public void metod() {  // Опечатка! Это будет перегрузка, не переопределение
    // реализация
}

// С @Override — компилятор выловит ошибку!
// @Override
// public void metod() {}  // Compile Error: method does not override

Практическое значение

Переопределение — один из самых мощных инструментов ООП:

1. Полиморфизм — один интерфейс, много реализаций
2. Гибкость — легко добавлять новые типы без изменения существующего кода
3. Расширяемость — Liskov Substitution Principle
4. Тестируемость — можно подменять реальные объекты на mock'и

Без переопределения невозможно представить современную Java архитектуру.