Как полиморфизм связан с абстракцией

Связь полиморфизма и абстракции

Это фундаментальная концепция OOP, которая часто путается. Объясню связь через примеры.

Определения

Абстракция — скрывание деталей реализации, показ только необходимого интерфейса.

Полиморфизм — способность объекта принимать много форм, одна переменная может ссылаться на разные типы.

Как они связаны

Абстракция создаёт интерфейс, полиморфизм позволяет использовать его.

// 1️⃣ АБСТРАКЦИЯ: Скрываем детали, показываем интерфейс
public abstract class Animal {
  public abstract void makeSound();  // Интерфейс - что может делать
}

// 2️⃣ РЕАЛИЗАЦИЯ: Разные животные по-разному
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!");
  }
}

// 3️⃣ ПОЛИМОРФИЗМ: Одна переменная, много форм
Animal dog = new Dog();       // Animal ссылка, но Dog объект
Animal cat = new Cat();       // Animal ссылка, но Cat объект
Animal bird = new Bird();     // Animal ссылка, но Bird объект

// 4️⃣ ИСПОЛЬЗОВАНИЕ: Не знаем конкретный тип
Animal[] animals = {dog, cat, bird};

for (Animal animal : animals) {
  animal.makeSound();  // Вызывается правильная реализация
}

// Вывод:
// Woof!
// Meow!
// Tweet!

Без абстракции нет полиморфизма

❌ Плохо: Нет абстракции

public class Dog {
  public void bark() { System.out.println("Woof!"); }
}

public class Cat {
  public void meow() { System.out.println("Meow!"); }
}

// Нет полиморфизма - разные методы!
Dog dog = new Dog();
Cat cat = new Cat();

dog.bark();  // Разные методы
cat.meow();  // Разные интерфейсы

// Код сломается если добавим новое животное
List<???> animals = new ArrayList<>();  // Что положить сюда?

✅ Хорошо: С абстракцией

// Абстракция
public abstract class Animal {
  public abstract void makeSound();
}

// Реализации
public class Dog extends Animal {
  public void makeSound() { System.out.println("Woof!"); }
}

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

// Полиморфизм - одна переменная, много форм
List<Animal> animals = new ArrayList<>();
animals.add(new Dog());
animals.add(new Cat());
animals.add(new Bird());

for (Animal animal : animals) {
  animal.makeSound();  // Полиморфный вызов
}

Три вида полиморфизма (с разными уровнями абстракции)

1. Compile-time полиморфизм (Overloading)

public class Calculator {
  // Абстракция: метод add(), реализация разная
  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();
calc.add(1, 2);         // int версия
calc.add(1.5, 2.5);    // double версия
calc.add("Hello", " World"); // String версия

2. Runtime полиморфизм (Overriding)

// Абстракция: interface Payment
public interface Payment {
  void pay(double amount);
}

// Разные реализации
public class CreditCardPayment implements Payment {
  @Override
  public void pay(double amount) {
    System.out.println("Credit card: " + amount);
  }
}

public class PayPalPayment implements Payment {
  @Override
  public void pay(double amount) {
    System.out.println("PayPal: " + amount);
  }
}

// Полиморфизм: одна переменная, разные реализации
public void processPayment(Payment payment, double amount) {
  payment.pay(amount);  // Вызывается правильная реализация
}

processPayment(new CreditCardPayment(), 100);  // Credit card: 100
processPayment(new PayPalPayment(), 100);      // PayPal: 100

3. Параметрический полиморфизм (Generics)

// Абстракция: контейнер для любого типа
public class Container<T> {
  private T value;
  
  public void setValue(T value) {
    this.value = value;
  }
  
  public T getValue() {
    return value;
  }
}

// Полиморфизм: один класс, много типов
Container<String> stringContainer = new Container<>();
stringContainer.setValue("Hello");

Container<Integer> intContainer = new Container<>();
intContainer.setValue(42);

Container<Dog> dogContainer = new Container<>();
dogContainer.setValue(new Dog());

Диаграмма связи

        АБСТРАКЦИЯ
             ↓
      (скрывает детали)
             ↓
        Интерфейс
             ↓
        ПОЛИМОРФИЗМ
             ↓
      (разные реализации
       через один интерфейс)

Практический пример: Система оплаты

// АБСТРАКЦИЯ: Интерфейс платежа (скрываем детали)
public interface PaymentProcessor {
  TransactionResult process(PaymentRequest request) throws PaymentException;
  void refund(String transactionId);
}

// ПОЛИМОРФИЗМ: Разные способы оплаты
public class StripeProcessor implements PaymentProcessor {
  @Override
  public TransactionResult process(PaymentRequest request) {
    // Stripe API вызовы
    return new TransactionResult("stripe_123", "SUCCESS");
  }
  
  @Override
  public void refund(String transactionId) {
    // Stripe refund API
  }
}

public class PaypalProcessor implements PaymentProcessor {
  @Override
  public TransactionResult process(PaymentRequest request) {
    // PayPal API вызовы
    return new TransactionResult("paypal_456", "SUCCESS");
  }
  
  @Override
  public void refund(String transactionId) {
    // PayPal refund API
  }
}

public class CryptoCurrencyProcessor implements PaymentProcessor {
  @Override
  public TransactionResult process(PaymentRequest request) {
    // Blockchain API вызовы
    return new TransactionResult("crypto_789", "SUCCESS");
  }
  
  @Override
  public void refund(String transactionId) {
    // Blockchain refund
  }
}

// ИСПОЛЬЗОВАНИЕ: Полиморфизм
public class OrderService {
  private final PaymentProcessor processor;
  
  // Абстракция позволяет подставить любой processor
  public OrderService(PaymentProcessor processor) {
    this.processor = processor;
  }
  
  public void processOrder(Order order, Payment payment) {
    try {
      PaymentRequest request = new PaymentRequest(
        payment.getAmount(),
        payment.getCurrency()
      );
      
      TransactionResult result = processor.process(request);
      order.setTransactionId(result.getTransactionId());
    } catch (PaymentException e) {
      order.setStatus("PAYMENT_FAILED");
    }
  }
}

// В приложении:
// Абстракция скрывает детали, полиморфизм позволяет менять реализацию
public class Application {
  public static void main(String[] args) {
    PaymentProcessor processor;
    
    if (config.isStripeEnabled()) {
      processor = new StripeProcessor();
    } else if (config.isPaypalEnabled()) {
      processor = new PaypalProcessor();
    } else {
      processor = new CryptoCurrencyProcessor();
    }
    
    OrderService service = new OrderService(processor);
    service.processOrder(order, payment);
    
    // OrderService не знает какой processor используется!
    // Это и есть полиморфизм через абстракцию
  }
}

SOLID принципы (используют абстракцию и полиморфизм)

Dependency Inversion Principle (DIP):

❌ Плохо (без абстракции):
  OrderService → StripeProcessor
  (зависимость от конкретного класса)

✅ Хорошо (с абстракцией):
  OrderService → PaymentProcessor (интерфейс)
                    ↙  ↓  ↘
         Stripe  PayPal  Crypto
  (полиморфизм позволяет менять реализацию)

Таблица сравнения

╔═══════════════╦════════════════════╦════════════════╗
║ Концепция     ║ Абстракция         ║ Полиморфизм    ║
╠═══════════════╬════════════════════╬════════════════╣
║ Определение   ║ Скрыть детали      ║ Много форм     ║
║ Зачем нужна   ║ Упростить код      ║ Гибкость       ║
║ Как работает  ║ Interface/Abstract  ║ Runtime/Compile║
║ Результат     ║ Контракт            ║ Разные реализ. ║
║ Без другой    ║ Нет пользы         ║ Нет смысла     ║
╚═══════════════╩════════════════════╩════════════════╝

Итог

Абстракция и полиморфизм неразделимы:

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

Без абстракции полиморфизм теряет смысл. Без полиморфизма абстракция не даёт преимуществ.

Это одна монета с двумя сторонами.