Почему некоторые не относят абстракцию к принципам ООП?

Абстракция в ООП: почему её не всегда считают основным принципом

Вопрос о том, считать ли абстракцию одним из четырёх столпов ООП, порождает дебаты в IT-сообществе. Давайте разберёмся, почему некоторые разработчики её исключают.

Классическая триада ООП

Все согласны, что три принципа входят в ядро ООП:

1. Инкапсуляция (Encapsulation) — скрывание внутренней реализации 2. Наследование (Inheritance) — переиспользование и расширение поведения 3. Полиморфизм (Polymorphism) — работа с объектами через единый интерфейс

Почему абстракцию не относят к основам

Причина 1: Абстракция — это результат, а не принцип

Некоторые считают, что абстракция — это не инструмент, а следствие применения других принципов:

// Абстракция достигается через инкапсуляцию
public class BankAccount {
    private double balance;  // Скрытая переменная
    
    public void deposit(double amount) {  // Скрывается логика добавления
        this.balance += amount;
    }
}

// Абстракция достигается через полиморфизм
interface Shape {
    void draw();  // Абстрактный контракт
}

class Circle implements Shape {
    @Override
    public void draw() {
        // Конкретная реализация
    }
}

Абстракция естественным образом возникает из инкапсуляции (скрывается деталь) и полиморфизма (используется интерфейс вместо реализации).

Причина 2: Абстракция — слишком общее понятие

Термин абстракция используется слишком широко в программировании:

// Абстракция на уровне класса
class Car {
    // Абстрагируем реальный автомобиль в программу
}

// Абстракция на уровне операции
public List<String> filter(List<String> items) {
    // Абстрагируем логику фильтрации
}

// Абстракция на уровне данных
public interface List<E> {
    // Абстрагируем конкретную структуру данных
    E get(int index);
    void add(E element);
}

// Абстракция на уровне типов
public <T> void processItem(T item) {
    // Абстрагируем конкретный тип
}

Все эти примеры — абстракция, но они качественно разные. Из-за этой многозначности абстракцию сложнее отнести к «основным принципам».

Причина 3: Исторический контекст

Когда объектно-ориентированное программирование только формировалось (1980-90е), основными считали именно три принципа:

// В ранних ООП языках (Smalltalk, Early C++)
// Инкапсуляция, Наследование, Полиморфизм
// были достаточны для описания всех концепций

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

Причина 4: Абстракция — это дизайн-решение, а не механизм

Инкапсуляция, наследование и полиморфизм — это встроенные механизмы языка:

// Инкапсуляция: встроенная в язык
private, protected, public

// Наследование: синтаксис языка
class Child extends Parent

// Полиморфизм: механизм виртуальных методов
@Override

А вот абстракция — это философский подход:

// Это выбор разработчика, где спрятать детали
interface PaymentService {
    void pay(double amount);  // Абстрагируем способ оплаты
}

Вместо того чтобы быть встроенным механизмом, абстракция — это паттерн мышления.

Как на самом деле связаны эти принципы

Абстракция ↔ Инкапсуляция:

// Инкапсуляция скрывает, абстракция обобщает
public class Database {
    private MySQLConnection connection;  // Инкапсуляция
    
    public void execute(String query) {  // Абстракция (скрываем SQL-Details)
        // реализация
    }
}

Абстракция ↔ Полиморфизм:

// Полиморфизм позволяет работать с абстракцией
interface DataSource {  // Абстракция
    Data read();
}

class JsonDataSource implements DataSource {  // Полиморфизм
    @Override
    public Data read() { /* json logic */ }
}

class XmlDataSource implements DataSource {  // Полиморфизм
    @Override
    public Data read() { /* xml logic */ }
}

public void process(DataSource source) {  // Работаем с абстракцией
    Data data = source.read();
}

Абстракция ↔ Наследование:

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

class Dog extends Animal {  // Наследование конкретизирует абстракцию
    @Override
    void makeSound() { /* bark */ }
}

Мнения в сообществе

Позиция 1: Абстракция — 4-й столп ООП

Абстракция + Инкапсуляция + Наследование + Полиморфизм = ООП

Аргументы:

• Java официально позиционирует её как ключевой принцип
• abstract класс и методы — первоклассное понятие в языке
• Это необходимо для понимания интерфейсов

Позиция 2: Абстракция — это следствие других трёх

Инкапсуляция + Наследование + Полиморфизм = Абстракция (как результат)

Аргументы:

• Абстракция возникает естественно из других принципов
• Это скорее философский подход, чем технический механизм
• Экономия на теоретических основах

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

На практике это не важно:

// Хороший код — с абстракцией или без, применяя все 4 (или 3) принципа

// Плохой пример
class User {
    public String name;  // Нет инкапсуляции
    public String password;  // Нет инкапсуляции
    
    public void saveToDatabase() {
        // Нет абстракции, код привязан к БД
    }
}

// Хороший пример
interface UserRepository {  // Абстракция
    void save(User user);  // Полиморфизм
}

class User {  // Инкапсуляция
    private String name;
    private String password;
    
    public String getName() { return name; }
}

class DatabaseUserRepository implements UserRepository {  // Наследование
    @Override
    public void save(User user) { /* реализация */ }
}

Заключение

Почему абстракцию не всегда относят к основам ООП:

1. Она — результат, а не инструмент: возникает из инкапсуляции и полиморфизма
2. Слишком широкое понятие: используется на разных уровнях архитектуры
3. Исторически основными считали три принципа
4. В Java она стала отдельным конструктом позже
5. Это скорее подход, чем встроенный механизм языка

Но в современной Java она практически важна и часто рассматривается как четвёртый столп. Главное — понимать, что все эти принципы работают вместе и дополняют друг друга, независимо от того, считаете ли вы абстракцию отдельным принципом или нет.