Что будет, если один метод будет реализовываться каждым классом по-разному

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

Это вопрос о полиморфизме — одном из столпов объектно-ориентированного программирования. Когда разные классы реализуют один метод по-разному, мы используем мощь полиморфизма для написания гибкого и расширяемого кода.

Базовая концепция: Переопределение методов

Это нормально и желательно! Это называется method overriding (переопределение) и является основой полиморфизма.

// Базовый класс или интерфейс
public abstract class Animal {
    public abstract void makeSound();
    
    public void sleep() {
        System.out.println("Zzzzz...");
    }
}

// Разные классы - разные реализации одного метода
public class Dog extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Woof! 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! Tweet!");
    }
}

Использование полиморфизма

Вот где настоящая мощь:

public class AnimalManager {
    
    // Один метод работает с РАЗНЫМИ реализациями
    public void makeAnimalSound(Animal animal) {
        animal.makeSound(); // Вызовет НУЖНЫЙ метод в зависимости от типа
    }
    
    public static void main(String[] args) {
        // Один код - разное поведение!
        Animal dog = new Dog();
        dog.makeSound(); // Выведет: Woof! Woof!
        
        Animal cat = new Cat();
        cat.makeSound(); // Выведет: Meow!
        
        Animal bird = new Bird();
        bird.makeSound(); // Выведет: Tweet! Tweet!
    }
}

Как это работает под капотом

Dynamic Dispatch (динамическое связывание):

public class DynamicDispatchExample {
    public static void main(String[] args) {
        // На этапе КОМПИЛЯЦИИ известен тип Animal
        Animal animal = new Dog();
        
        // Но на этапе ВЫПОЛНЕНИЯ вызывается metод именно Dog
        // JVM смотрит на реальный тип и вызывает нужную реализацию
        animal.makeSound();
        
        // Это НЕ статическое связывание:
        // animal.getClass().getName() → "Dog"
        // JVM вызывает Dog.makeSound(), а не Animal.makeSound()
    }
}

Практический пример: Обработка платежей

public interface PaymentProcessor {
    void processPayment(double amount);
    String getStatus();
}

public class CreditCardProcessor implements PaymentProcessor {
    @Override
    public void processPayment(double amount) {
        System.out.println("Обработка кредитной карты на сумму " + amount);
        validateCVV();
        connectToBank();
        chargeCard(amount);
    }
    
    @Override
    public String getStatus() {
        return "Credit Card (Instant)";
    }
    
    private void validateCVV() { /* ... */ }
    private void connectToBank() { /* ... */ }
    private void chargeCard(double amount) { /* ... */ }
}

public class PayPalProcessor implements PaymentProcessor {
    @Override
    public void processPayment(double amount) {
        System.out.println("Обработка PayPal платежа на сумму " + amount);
        authenticatePayPal();
        sendToPayPalAPI(amount);
    }
    
    @Override
    public String getStatus() {
        return "PayPal (3-5 minutes)";
    }
    
    private void authenticatePayPal() { /* ... */ }
    private void sendToPayPalAPI(double amount) { /* ... */ }
}

public class CryptoProcessor implements PaymentProcessor {
    @Override
    public void processPayment(double amount) {
        System.out.println("Обработка крипто платежа на сумму " + amount);
        validateWallet();
        sendTransaction();
    }
    
    @Override
    public String getStatus() {
        return "Cryptocurrency (10-30 minutes)";
    }
    
    private void validateWallet() { /* ... */ }
    private void sendTransaction() { /* ... */ }
}

Использование:

public class PaymentService {
    
    // Один метод - разные процессоры!
    public void checkout(PaymentProcessor processor, double amount) {
        System.out.println("Инициирование платежа через: " + processor.getStatus());
        processor.processPayment(amount);
        System.out.println("Платеж обработан!\n");
    }
    
    public static void main(String[] args) {
        PaymentService service = new PaymentService();
        
        // Один и тот же код для разных процессоров
        service.checkout(new CreditCardProcessor(), 99.99);
        service.checkout(new PayPalProcessor(), 99.99);
        service.checkout(new CryptoProcessor(), 99.99);
    }
}

// Выход:
// Инициирование платежа через: Credit Card (Instant)
// Обработка кредитной карты на сумму 99.99
// Платеж обработан!
//
// Инициирование платежа через: PayPal (3-5 minutes)
// Обработка PayPal платежа на сумму 99.99
// Платеж обработан!
//
// Инициирование платежа через: Cryptocurrency (10-30 minutes)
// Обработка крипто платежа на сумму 99.99
// Платеж обработан!

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

Контракт, который должен соблюдаться:

public abstract class Shape {
    // Исходный метод
    public abstract double calculateArea();
    
    // С модификатором доступа
    public void draw() {
        System.out.println("Drawing shape");
    }
}

public class Circle extends Shape {
    private double radius;
    
    @Override // Аннотация - проверяет корректность переопределения
    public double calculateArea() {
        return Math.PI * radius * radius;
    }
    
    @Override
    public void draw() {
        System.out.println("Drawing circle with radius " + radius);
    }
}

public class Square extends Shape {
    private double side;
    
    @Override
    public double calculateArea() {
        return side * side;
    }
    
    @Override
    public void draw() {
        System.out.println("Drawing square with side " + side);
    }
}

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

public class OverridingRules {
    
    // ПРАВИЛО 1: Сигнатура метода должна быть такой же
    public class Parent {
        public void doSomething(String param) { }
    }
    
    public class Child extends Parent {
        @Override
        public void doSomething(String param) { } // OK
        
        // public void doSomething(int param) { }     // Это ПЕРЕГРУЗКА, не переопределение
    }
    
    // ПРАВИЛО 2: Тип возврата должен быть таким же или подтипом (covariant)
    public class ParentClass {
        public Animal getAnimal() {
            return new Animal();
        }
    }
    
    public class ChildClass extends ParentClass {
        @Override
        public Dog getAnimal() { // OK - Dog является подтипом Animal
            return new Dog();
        }
    }
    
    // ПРАВИЛО 3: Модификатор доступа не должен быть более ограничивающим
    public class ParentA {
        public void method() { } // public
    }
    
    public class ChildA extends ParentA {
        @Override
        public void method() { } // OK - public
        
        // @Override
        // protected void method() { } // ОШИБКА - более ограничивающий
    }
    
    // ПРАВИЛО 4: Исключения
    public class ParentB {
        public void method() throws IOException { }
    }
    
    public class ChildB extends ParentB {
        @Override
        public void method() throws FileNotFoundException { } // OK - более специфичное
        
        // @Override
        // public void method() throws Exception { } // ОШИБКА - более общее
    }
}

Практический пример: Каркас для plug-in системы

// Ядро система
public abstract class Plugin {
    public abstract void onLoad();
    public abstract void onUnload();
    public abstract void onEvent(String event);
    
    public final void init() {
        System.out.println("Инициализация плагина " + getClass().getSimpleName());
        onLoad();
    }
}

// Разные плагины - разные реализации
public class AnalyticsPlugin extends Plugin {
    @Override
    public void onLoad() {
        System.out.println("Загрузка аналитики");
    }
    
    @Override
    public void onUnload() {
        System.out.println("Выгрузка аналитики");
    }
    
    @Override
    public void onEvent(String event) {
        System.out.println("Трекинг события: " + event);
    }
}

public class LoggingPlugin extends Plugin {
    @Override
    public void onLoad() {
        System.out.println("Инициализация логирования");
    }
    
    @Override
    public void onUnload() {
        System.out.println("Остановка логирования");
    }
    
    @Override
    public void onEvent(String event) {
        System.out.println("[LOG] " + event);
    }
}

// Система управления плагинами
public class PluginManager {
    private List<Plugin> plugins = new ArrayList<>();
    
    public void addPlugin(Plugin plugin) {
        plugins.add(plugin);
    }
    
    public void loadAll() {
        for (Plugin plugin : plugins) {
            plugin.init(); // Полиморфный вызов
        }
    }
    
    public void dispatchEvent(String event) {
        for (Plugin plugin : plugins) {
            plugin.onEvent(event); // Каждый плагин обрабатывает по-своему
        }
    }
}

// Использование
PluginManager manager = new PluginManager();
manager.addPlugin(new AnalyticsPlugin());
manager.addPlugin(new LoggingPlugin());
manager.loadAll();
manager.dispatchEvent("User logged in");

Преимущества переопределения методов

1. Гибкость: Добавляйте новые классы без изменения существующего кода
2. Расширяемость: Легко добавлять новые типы
3. Отделение ответственности: Каждый класс знает о своей реализации
4. Слабая связанность: Код работает с интерфейсом, не с конкретным классом
5. Простота тестирования: Легче писать моки для разных реализаций

Резюме

Это не проблема - это фишка! Когда один метод реализуется разными классами по-разному, это называется полиморфизм и это один из самых мощных инструментов ООП.

Это позволяет:

• Писать обобщенный код, который работает с разными типами
• Легко расширять функционал новыми типами
• Следовать SOLID принципам
• Создавать гибкие архитектуры

Без переопределения методов нельзя было бы создавать современные фреймворки как Spring, которые полагаются на полиморфизм для обработки разных типов beans и компонентов.