Что такое динамическая диспетчеризация метода?

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

Динамическая диспетчеризация — это механизм выбора метода для вызова во время выполнения программы (runtime), а не во время компиляции (compile time). Это позволяет писать полиморфный код, где одна ссылка может указывать на объекты разных типов.

Основная идея

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

class Dog extends Animal {
    @Override
    public void sound() {
        System.out.println("Woof!");
    }
}

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

public class Main {
    public static void main(String[] args) {
        Animal myDog = new Dog();      // объект Dog, но тип Animal
        Animal myCat = new Cat();      // объект Cat, но тип Animal
        Animal animal = new Animal();  // объект Animal
        
        myDog.sound();    // выведет "Woof!" (во время выполнения определится Dog)
        myCat.sound();    // выведет "Meow!" (во время выполнения определится Cat)
        animal.sound();   // выведет "Generic sound"
    }
}

Ключевой момент: компилятор видит, что все три переменные типа Animal. Но во время выполнения JVM определяет реальный тип объекта и вызывает соответствующий метод.

Как работает диспетчеризация

Во время компиляции (Compile Time)

Animal myDog = new Dog();
myDog.sound();  // компилятор знает, что sound() есть в Animal
                // но не знает, какой sound() вызывать (Dog или Animal)

Компилятор:

1. Проверяет, что Animal имеет метод sound()
2. Создаёт инструкцию вызвать sound()
3. Но не говорит, какую версию звать

Во время выполнения (Runtime)

JVM:

1. Смотрит на реальный тип объекта (объект это Dog, Cat или Animal?)
2. Ищет метод sound() в этом классе
3. Если найден — вызывает его
4. Если нет — ищет в родительском классе (Animal)

Виртуальные таблицы методов (Virtual Method Table)

Внутри JVM диспетчеризация работает через VTable:

class Animal {
    void sound() { }
    void move() { }
}

class Dog extends Animal {
    @Override
    void sound() { }  // переопределены
    // move() унаследован от Animal
}

// VTable для Animal:
// [0] -> Animal.sound()
// [1] -> Animal.move()

// VTable для Dog:
// [0] -> Dog.sound()      (переопределен)
// [1] -> Animal.move()    (унаследован)

Когда вызывается myDog.sound():

1. JVM смотрит на VTable объекта Dog
2. Берёт позицию [0] для sound()
3. Вызывает Dog.sound()

Статическая диспетчеризация vs Динамическая

Статическая (Static Dispatch) — Compile Time

public class Printer {
    public static void print(String text) {
        System.out.println(text);
    }
    
    public static void main(String[] args) {
        print("Hello");  // на этапе компиляции известно, что вызывать
    }
}

Статические методы:

• Разрешаются во время компиляции
• Нет полиморфизма
• Быстрее (inline оптимизация)

Динамическая (Dynamic Dispatch) — Runtime

Animal animal = new Dog();
animal.sound();  // на этапе компиляции неизвестно, какой sound() вызовется

Нестатические методы (instance methods):

• Разрешаются во время выполнения
• Полиморфизм работает
• Немного медленнее

Интерфейсы и динамическая диспетчеризация

Интерфейсы — идеальный способ использовать динамическую диспетчеризацию:

interface PaymentProcessor {
    void pay(double amount);
}

class CreditCardProcessor implements PaymentProcessor {
    @Override
    public void pay(double amount) {
        System.out.println("Оплата по кредитной карте: " + amount);
    }
}

class PayPalProcessor implements PaymentProcessor {
    @Override
    public void pay(double amount) {
        System.out.println("Оплата через PayPal: " + amount);
    }
}

public class Store {
    public void checkout(PaymentProcessor processor, double amount) {
        processor.pay(amount);  // динамическая диспетчеризация!
        // может быть CreditCard, PayPal или любой другой
    }
    
    public static void main(String[] args) {
        Store store = new Store();
        
        store.checkout(new CreditCardProcessor(), 100);  // "Оплата по кредитной карте: 100"
        store.checkout(new PayPalProcessor(), 50);        // "Оплата через PayPal: 50"
    }
}

Практический пример: Система логирования

interface Logger {
    void log(String message);
}

class ConsoleLogger implements Logger {
    @Override
    public void log(String message) {
        System.out.println("[CONSOLE] " + message);
    }
}

class FileLogger implements Logger {
    @Override
    public void log(String message) {
        // запись в файл
        System.out.println("[FILE] " + message);
    }
}

class Application {
    private Logger logger;  // ссылка на интерфейс
    
    public Application(Logger logger) {
        this.logger = logger;  // динамическая инъекция
    }
    
    public void run() {
        logger.log("Приложение запущено");  // динамическая диспетчеризация
        // может логировать в консоль, файл или куда угодно
    }
}

public class Main {
    public static void main(String[] args) {
        Application app1 = new Application(new ConsoleLogger());
        app1.run();  // логирование в консоль
        
        Application app2 = new Application(new FileLogger());
        app2.run();  // логирование в файл
    }
}

Производительность: Пытается ли JVM оптимизировать?

DЮ, JVM применяет оптимизации:

1. Inline Caching

// Если JVM видит, что animal всегда Dog, она оптимизирует:
for (int i = 0; i < 1000000; i++) {
    Animal animal = new Dog();  // всегда Dog
    animal.sound();  // JVM inline-ирует Dog.sound() после нескольких вызовов
}

2. Devirtualization

JVM может убрать динамическую диспетчеризацию, если поняла, что иная реализация невозможна.

Отличие от перегрузки методов (Overloading)

Перегрузка — это статическая диспетчеризация:

class Calculator {
    public int add(int a, int b) { return a + b; }
    public double add(double a, double b) { return a + b; }
}

Calculator calc = new Calculator();
calc.add(5, 10);      // компилятор выбирает add(int, int)
calc.add(5.5, 10.5);  // компилятор выбирает add(double, double)

Компилятор знает точный тип аргументов и вызывает правильную версию.

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

Animal animal = new Dog();  // компилятор НЕ знает реальный тип
animal.sound();  // JVM определяет во время выполнения

Лучшие практики

1. Используй интерфейсы вместо конкретных классов для параметров
2. Полагайся на динамическую диспетчеризацию для расширяемости
3. Профилируй, если производительность критична (JVM обычно хорошо оптимизирует)
4. Избегай глубокой иерархии наследования — сложнее для оптимизации

Вывод: Динамическая диспетчеризация — это основа полиморфизма в Java. Она позволяет писать гибкий код, где один интерфейс может работать с разными реализациями. JVM чаще всего хорошо оптимизирует динамические вызовы, поэтому беспокоиться о производительности не стоит.