Что чаще всего исключают из понятия ООП

Что исключают из ООП

Объектно-ориентированное программирование (ООП) имеет четыре основных столпа. Однако чаще всего из понятия ООП исключают полиморфизм или абстракцию, особенно когда речь идёт об упрощённом определении. Но на самом деле самое частое упущение — это инкапсуляция, которую часто путают с другими принципами.

Однако, если говорить о том, что чаще всего ИСКЛЮЧАЮТ из рассмотрения или путают, то это:

1. Абстракция (неправильное понимание)

Многие разработчики путают абстракцию с интерфейсами. Абстракция — это более широкое понятие, которое включает:

• Скрытие деталей реализации
• Определение контракта через интерфейсы и абстрактные классы
• Работа с объектами на высоком уровне абстракции

Несколько инженеров ошибочно считают, что абстракция — это только интерфейсы, что не совсем верно.

// Абстракция — не только интерфейсы
abstract class Animal {
    abstract void makeSound();
    
    public void sleep() {
        System.out.println("Животное спит");
    }
}

interface Movable {
    void move();
}

class Dog extends Animal implements Movable {
    @Override
    void makeSound() {
        System.out.println("Гав-гав");
    }
    
    @Override
    public void move() {
        System.out.println("Собака бегает");
    }
}

2. Полиморфизм (часто упускают часть его видов)

Полиморфизм имеет несколько видов, но часто рассматривают только полиморфизм подтипов (работа через интерфейсы/наследование). Упускают:

• Параметрический полиморфизм (Generics) — работа с обобщённым типом данных
• Перегрузка методов (Ad-hoc полиморфизм) — несколько методов с одним именем
• Полиморфизм включения — через наследование иерархии классов

// 1. Полиморфизм подтипов (через наследование)
Animal animal = new Dog();
animal.makeSound(); // Выведет "Гав-гав"

// 2. Параметрический полиморфизм (Generics)
public class Container<T> {
    private T value;
    
    public void set(T value) {
        this.value = value;
    }
    
    public T get() {
        return value;
    }
}

Container<String> stringContainer = new Container<>();
Container<Integer> intContainer = new Container<>();

// 3. Перегрузка методов
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;
    }
}

3. Инкапсуляция (часто путают с просто приватными полями)

Инкапсуляция — это не просто скрытие переменных с помощью private. Это:

• Скрытие внутреннего состояния объекта
• Предоставление управляемого интерфейса через методы
• Защита от неправильного использования
• Возможность менять реализацию без влияния на клиентов

// ПЛОХО: просто приватное поле без управления
public class BankAccount {
    private double balance;
}

// ХОРОШО: инкапсуляция с валидацией
public class BankAccount {
    private double balance;
    private static final double MIN_BALANCE = 0;
    private static final double MAX_BALANCE = 1_000_000;
    
    public void deposit(double amount) {
        if (amount <= 0) {
            throw new IllegalArgumentException("Сумма должна быть положительной");
        }
        if (balance + amount > MAX_BALANCE) {
            throw new IllegalArgumentException("Превышен максимальный баланс");
        }
        this.balance += amount;
    }
    
    public boolean withdraw(double amount) {
        if (amount <= 0) {
            throw new IllegalArgumentException("Сумма должна быть положительной");
        }
        if (balance - amount < MIN_BALANCE) {
            return false; // Недостаточно средств
        }
        this.balance -= amount;
        return true;
    }
    
    public double getBalance() {
        return balance;
    }
}

4. Наследование (иногда выделяют как отдельный столп)

Некоторые источники выделяют наследование как четвёртый столп ООП, но на самом деле оно является реализацией полиморфизма и повторного использования кода:

public class Animal {
    protected String name;
    
    public Animal(String name) {
        this.name = name;
    }
    
    public void eat() {
        System.out.println(name + " ест");
    }
}

public class Dog extends Animal {
    public Dog(String name) {
        super(name);
    }
    
    public void bark() {
        System.out.println(name + " лает");
    }
}

Классические четыре столпа ООП

1. Инкапсуляция — скрытие данных и управление доступом
2. Наследование — повторное использование кода и построение иерархий
3. Полиморфизм — способность объектов принимать разные формы
4. Абстракция — представление существенных признаков объекта

Частые ошибки

• Путают инкапсуляцию с просто использованием private
• Видят полиморфизм только через интерфейсы
• Не понимают, что абстракция шире, чем абстрактные классы
• Используют наследование вместо композиции

Вывод

Чаще всего исключают или неправильно понимают абстракцию и полиморфизм. Абстракция воспринимается как просто интерфейсы, а полиморфизм сводится только к переопределению методов. На самом деле это намного более глубокие концепции, которые включают работу с обобщёнными типами, перегрузку, параметрический полиморфизм и многое другое.