В чем разница между полиморфизмом и абстракцией?

# Различие между полиморфизмом и абстракцией

Хотя эти два концепта часто используются вместе в объектно-ориентированном программировании, они решают разные задачи и основаны на разных принципах.

Абстракция

Абстракция — это процесс скрытия сложности и выделения только важных деталей. Это о том, ЧТО объект делает, не обращая внимания на КАК он это делает.

Пример абстракции

// Абстрактный класс определяет интерфейс для различных типов животных
public abstract class Animal {
    // Абстрактный метод скрывает детали реализации
    public abstract void makeSound();
    
    public abstract void move();
    
    // Конкретный метод (может быть абстрактным)
    public void sleep() {
        System.out.println("Animal is sleeping");
    }
}

// Интерфейс — это чистая абстракция
public interface Movable {
    void move();  // Скрывает КАК двигается объект
}

// Конкретные реализации скрывают детали
public class Dog extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Woof! Woof!");
    }
    
    @Override
    public void move() {
        System.out.println("Dog runs on four legs");
    }
}

public class Bird extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Tweet! Tweet!");
    }
    
    @Override
    public void move() {
        System.out.println("Bird flies with wings");
    }
}

Когда мы используем абстракцию, нас не интересует, КАК Dog издает звук, только то, что он издает звук:

// Мы видим только абстрактный интерфейс
Animal animal = new Dog();
// Нам не нужно знать детали реализации Dog.makeSound()
animal.makeSound();

Цели абстракции

1. Упрощение: снижение сложности
2. Скрытие деталей: инкапсуляция
3. Фокусировка: на важных деталях
4. Поддерживаемость: изменение деталей не влияет на клиентский код

// Плохо: видны все детали
public class DatabaseConnection {
    public void openSocket(String host, int port, String username, String password) {
        // ... 50 строк кода ...
    }
}

// Хорошо: детали скрыты, интерфейс простой
public interface Database {
    void connect(String connectionString);
    ResultSet query(String sql);
    void close();
}

Полиморфизм

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

Виды полиморфизма

1. Полиморфизм компиляции (Compile-time / Static Polymorphism)

Перегрузка методов (Method Overloading)

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();
calc.add(5, 10);              // вызывает int версию
calc.add(5.5, 10.5);          // вызывает double версию
calc.add("Hello", "World");   // вызывает String версию

Компилятор выбирает метод ВО ВРЕМЯ компиляции, основываясь на типах параметров.

2. Полиморфизм времени выполнения (Runtime / Dynamic Polymorphism)

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

// Определяем общий интерфейс
public interface Shape {
    void draw();           // абстрактный метод
    double calculateArea();
}

// Разные реализации
public class Circle implements Shape {
    private double radius;
    
    @Override
    public void draw() {
        System.out.println("Drawing Circle");
    }
    
    @Override
    public double calculateArea() {
        return Math.PI * radius * radius;
    }
}

public class Rectangle implements Shape {
    private double width, height;
    
    @Override
    public void draw() {
        System.out.println("Drawing Rectangle");
    }
    
    @Override
    public double calculateArea() {
        return width * height;
    }
}

public class Triangle implements Shape {
    private double base, height;
    
    @Override
    public void draw() {
        System.out.println("Drawing Triangle");
    }
    
    @Override
    public double calculateArea() {
        return 0.5 * base * height;
    }
}

// Полиморфизм в действии
public class ShapeProcessor {
    public static void processShapes(List<Shape> shapes) {
        for (Shape shape : shapes) {
            shape.draw();  // Вызывает разные методы для разных типов
            System.out.println("Area: " + shape.calculateArea());
        }
    }
}

// Использование
List<Shape> shapes = Arrays.asList(
    new Circle(),
    new Rectangle(),
    new Triangle()
);

ShapeProcessor.processShapes(shapes);
// Результат:
// Drawing Circle
// Area: 3.14...
// Drawing Rectangle
// Area: 100
// Drawing Triangle
// Area: 50

Вычисляется ВО ВРЕМЯ ВЫПОЛНЕНИЯ (runtime), основываясь на фактическом типе объекта.

Цели полиморфизма

1. Расширяемость: легко добавить новые типы
2. Гибкость: один код работает с разными типами
3. Переиспользование: общая логика для разных вариантов
4. Слабая связанность: код не зависит от конкретных типов

// Полиморфный код — работает с любым Shape
public void renderScene(List<Shape> shapes) {
    for (Shape shape : shapes) {
        shape.draw();  // Работает для Circle, Rectangle, Triangle и любого нового типа
    }
}

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

Хотя это разные концепты, они часто работают вместе:

// 1. Абстракция определяет ЧТО должно быть
public abstract class PaymentProcessor {
    public abstract void processPayment(double amount);
    public abstract boolean supports(String paymentMethod);
}

// 2. Полиморфизм позволяет разным типам делать ЭТО по-разному
public class CreditCardProcessor extends PaymentProcessor {
    @Override
    public void processPayment(double amount) {
        System.out.println("Processing credit card payment: " + amount);
        // Специфичная для кредитной карты логика
    }
    
    @Override
    public boolean supports(String paymentMethod) {
        return paymentMethod.equals("CREDIT_CARD");
    }
}

public class PayPalProcessor extends PaymentProcessor {
    @Override
    public void processPayment(double amount) {
        System.out.println("Processing PayPal payment: " + amount);
        // Специфичная для PayPal логика
    }
    
    @Override
    public boolean supports(String paymentMethod) {
        return paymentMethod.equals("PAYPAL");
    }
}

public class BitcoinProcessor extends PaymentProcessor {
    @Override
    public void processPayment(double amount) {
        System.out.println("Processing Bitcoin payment: " + amount);
        // Специфичная для Bitcoin логика
    }
    
    @Override
    public boolean supports(String paymentMethod) {
        return paymentMethod.equals("BITCOIN");
    }
}

// 3. Клиентский код пользуется абстракцией и полиморфизмом
public class PaymentService {
    private List<PaymentProcessor> processors;
    
    public void processPayment(String paymentMethod, double amount) {
        for (PaymentProcessor processor : processors) {
            if (processor.supports(paymentMethod)) {
                processor.processPayment(amount);  // Полиморфный вызов
                return;
            }
        }
        throw new IllegalArgumentException("Unsupported payment method: " + paymentMethod);
    }
}

Сравнительная таблица

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

// Абстракция: интерфейс Logger
public interface Logger {
    void log(String message);  // ЧТО делать
}

// Полиморфизм: разные реализации логирования
public class ConsoleLogger implements Logger {
    @Override
    public void log(String message) {
        System.out.println("[CONSOLE] " + message);
    }
}

public class FileLogger implements Logger {
    @Override
    public void log(String message) {
        writeToFile("[FILE] " + message);
    }
    
    private void writeToFile(String message) {
        // Логирование в файл
    }
}

public class DatabaseLogger implements Logger {
    @Override
    public void log(String message) {
        saveToDatabase("[DB] " + message);
    }
    
    private void saveToDatabase(String message) {
        // Логирование в БД
    }
}

// Клиентский код использует абстракцию
public class Application {
    private Logger logger;  // Абстракция
    
    public Application(Logger logger) {  // Инъекция зависимости
        this.logger = logger;
    }
    
    public void doSomething() {
        logger.log("Doing something");  // Полиморфный вызов
        // Работает с ConsoleLogger, FileLogger, DatabaseLogger...
    }
}

// Использование
Application app1 = new Application(new ConsoleLogger());
Application app2 = new Application(new FileLogger());
Application app3 = new Application(new DatabaseLogger());

Вывод

1. Абстракция — это о скрытии деталей и определении того, ЧТО нужно делать
2. Полиморфизм — это о позволении разным объектам реагировать по-разному на одно сообщение
3. Вместе они создают гибкие, расширяемые и поддерживаемые системы
4. Абстракция без полиморфизма — просто скрытие деталей
5. Полиморфизм без абстракции — путаница типов и сложный код

Мастерство ООП приходит из понимания и правильного применения обоих концептов.