Зачем нужна многоформенность в Java?

# Полиморфизм (Многоформенность) в Java

Определение

Полиморфизм (Polymorphism) — это один из четырех столпов объектно-ориентированного программирования. Слово происходит от греческого: "poly" (многие) + "morphe" (форма). Это способность объектов одного типа принимать разные формы или работать по-разному в зависимости от контекста.

Зачем нужен полиморфизм

1. Гибкость и расширяемость

// Без полиморфизма — нужен if для каждого типа
public void pay(Object payment) {
    if (payment instanceof CreditCard) {
        CreditCard card = (CreditCard) payment;
        card.chargeCard(...);
    } else if (payment instanceof PayPal) {
        PayPal paypal = (PayPal) payment;
        paypal.chargeAccount(...);
    } else if (payment instanceof Bitcoin) {
        Bitcoin bitcoin = (Bitcoin) payment;
        bitcoin.sendTransaction(...);
    }
    // Добавили новый способ оплаты? Нужно менять этот метод!
}

// С полиморфизмом — один вызов для всех типов
interface PaymentMethod {
    void charge(double amount);
}

public void pay(PaymentMethod payment) {
    payment.charge(100.0);  // Работает для любого типа оплаты
}

2. Снижение дублирования кода (DRY)

// Без полиморфизма — много повторений
public int calculateCreditCardFee(double amount) {
    return (int)(amount * 0.029);
}

public int calculatePayPalFee(double amount) {
    return (int)(amount * 0.034);
}

public int calculateBitcoinFee(double amount) {
    return (int)(amount * 0.001);
}

// С полиморфизмом — одна функция
public int calculateFee(PaymentMethod payment, double amount) {
    return payment.calculateFee(amount);
}

3. Легче добавлять новые типы

// Новый способ оплаты — просто реализуем интерфейс
class ApplePayment implements PaymentMethod {
    @Override
    public void charge(double amount) {
        // Логика Apple Pay
    }
}

// Существующий код работает без изменений!
PaymentMethod payment = new ApplePayment();
payment.charge(100.0);  // Работает

4. Упрощение тестирования

// Легко создать mock для тестов
class MockPayment implements PaymentMethod {
    @Override
    public void charge(double amount) {
        // Тестовая реализация
    }
}

// Тестируем
PaymentMethod mockPay = new MockPayment();
paymentService.process(mockPay);  // Работает с любым типом

Три типа полиморфизма в Java

1. Compile-time Polymorphism (Перегрузка методов)

// Одно имя метода, разные параметры
public class Calculator {
    public int add(int a, int b) {
        return a + b;
    }
    
    public double add(double a, double b) {
        return a + b;
    }
    
    public String add(String a, String b) {
        return a + b;
    }
}

// Использование
Calculator calc = new Calculator();
System.out.println(calc.add(5, 3));          // 8 (int)
System.out.println(calc.add(5.5, 3.2));      // 8.7 (double)
System.out.println(calc.add("Hello", "World")); // HelloWorld (String)

Компилятор определяет, какой метод вызывать на этапе компиляции.

2. Runtime Polymorphism (Переопределение методов)

// Родительский класс
class Animal {
    public void makeSound() {
        System.out.println("Животное издает звук");
    }
}

// Наследники
class Dog extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Гав!");
    }
}

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

// Использование
Animal animal1 = new Dog();
Animal animal2 = new Cat();

animal1.makeSound();  // "Гав!" — выбор метода во время выполнения
animal2.makeSound();  // "Мяу!"

// Один параметр, разное поведение
public void animalSound(Animal animal) {
    animal.makeSound();  // Вызовется нужный метод
}

animalSound(new Dog());   // "Гав!"
animalSound(new Cat());   // "Мяу!"

3. Interface Polymorphism (Полиморфизм интерфейсов)

// Интерфейс
interface Shape {
    double calculateArea();
}

// Реализации
class Circle implements Shape {
    private double radius;
    
    public Circle(double radius) {
        this.radius = radius;
    }
    
    @Override
    public double calculateArea() {
        return Math.PI * radius * radius;
    }
}

class Rectangle implements Shape {
    private double width, height;
    
    public Rectangle(double width, double height) {
        this.width = width;
        this.height = height;
    }
    
    @Override
    public double calculateArea() {
        return width * height;
    }
}

// Использование
List<Shape> shapes = new ArrayList<>();
shapes.add(new Circle(5));
shapes.add(new Rectangle(4, 6));

for (Shape shape : shapes) {
    System.out.println("Площадь: " + shape.calculateArea());
}

Практические примеры

Пример 1: Система доставки

// Интерфейс
interface DeliveryService {
    void deliver(Order order);
    double calculateCost(Order order);
}

// Реализации
class DomesticDelivery implements DeliveryService {
    @Override
    public void deliver(Order order) {
        System.out.println("Доставляем внутри страны");
    }
    
    @Override
    public double calculateCost(Order order) {
        return order.getWeight() * 50;
    }
}

class InternationalDelivery implements DeliveryService {
    @Override
    public void deliver(Order order) {
        System.out.println("Отправляем в другую страну");
    }
    
    @Override
    public double calculateCost(Order order) {
        return order.getWeight() * 200 + 5000;
    }
}

// Используем
class OrderService {
    public void processOrder(Order order, DeliveryService delivery) {
        delivery.deliver(order);
        double cost = delivery.calculateCost(order);
        System.out.println("Стоимость доставки: " + cost);
    }
}

// Работает с любым типом доставки
OrderService service = new OrderService();
service.processOrder(order, new DomesticDelivery());
service.processOrder(order, new InternationalDelivery());

Пример 2: Database Access Layer

interface DatabaseConnection {
    void connect();
    ResultSet query(String sql);
    void close();
}

class PostgresConnection implements DatabaseConnection {
    @Override
    public void connect() { /* PostgreSQL логика */ }
    @Override
    public ResultSet query(String sql) { /* PostgreSQL query */ }
    @Override
    public void close() { /* Close PostgreSQL */ }
}

class MongoDBConnection implements DatabaseConnection {
    @Override
    public void connect() { /* MongoDB логика */ }
    @Override
    public ResultSet query(String sql) { /* MongoDB query */ }
    @Override
    public void close() { /* Close MongoDB */ }
}

// Сервис работает с обеими БД
public class UserRepository {
    private DatabaseConnection db;
    
    public UserRepository(DatabaseConnection db) {
        this.db = db;
    }
    
    public User findById(Long id) {
        db.connect();
        ResultSet rs = db.query("SELECT * FROM users WHERE id=" + id);
        // Обработка результатов
        db.close();
        return user;
    }
}

Пример 3: Strategy Pattern

interface SortingStrategy {
    void sort(int[] array);
}

class BubbleSort implements SortingStrategy {
    @Override
    public void sort(int[] array) { /* Bubble sort */ }
}

class QuickSort implements SortingStrategy {
    @Override
    public void sort(int[] array) { /* Quick sort */ }
}

class MergeSort implements SortingStrategy {
    @Override
    public void sort(int[] array) { /* Merge sort */ }
}

class DataProcessor {
    private SortingStrategy strategy;
    
    public void setStrategy(SortingStrategy strategy) {
        this.strategy = strategy;
    }
    
    public void processData(int[] data) {
        strategy.sort(data);  // Используем текущую стратегию
    }
}

Плюсы полиморфизма

1. Расширяемость — легко добавлять новые типы без изменения существующего кода
2. Гибкость — один метод работает со множеством типов
3. Тестируемость — можно использовать mock-объекты
4. Поддерживаемость — меньше дублирования, проще изменять
5. SOLID принципы — особенно Open/Closed principle

Минусы / Сложности

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

Когда использовать

Используй полиморфизм когда

✓ Есть несколько способов делать одно и то же ✓ Новые типы добавляются часто ✓ Хочешь избежать больших if-else блоков ✓ Нужна гибкость и расширяемость ✓ Тестируешь код с mock-объектами

НЕ используй полиморфизм когда

✗ Всего 1-2 реализации ✗ Реализации разные по смыслу ✗ YAGNI — не нужно сейчас, может не понадобиться ✗ Усложнение не оправдано простотой

Вывод

Полиморфизм — один из мощнейших инструментов ООП. Он позволяет писать гибкий, расширяемый и легко тестируемый код. Основной принцип: "Программируй для интерфейса, а не для реализации".

// Хорошо
PaymentMethod payment = getPaymentMethod();  // Не знаем конкретный тип
payment.charge(100.0);  // Работает для любого типа

// Плохо
if (payment instanceof CreditCard) { ... }
else if (payment instanceof PayPal) { ... }
// Добавили новый тип? Нужно менять код везде