Три принципа ООП в Java - Вопросы

Классическая триада — инкапсуляция, наследование и полиморфизм. Большинство учебников и собеседований добавляют четвёртый принцип — абстракцию, поэтому встречаются обе формулировки: «три принципа ООП» и «четыре принципа ООП».

Безопасный ответ на собеседовании: назвать все четыре и уточнить, что часть авторов рассматривает абстракцию как часть инкапсуляции. Композиция и агрегация принципами ООП не являются — это виды отношений между объектами.

Инкапсуляция — это объединение данных и работающих с ними методов в одном классе и сокрытие деталей реализации от внешнего кода. Снаружи виден только публичный контракт.

В Java инкапсуляция реализуется модификаторами доступа (private, protected, package-private, public) и доступом к состоянию через методы, а не через голые поля:

public class BankAccount {

    private long balance;

    public void deposit(long amount) {
        if (amount <= 0) {
            throw new IllegalArgumentException("Сумма должна быть положительной");
        }
        balance += amount;
    }

    public long getBalance() {
        return balance;
    }
}

Важно: класс, где на каждое private-поле механически сгенерированы геттер и сеттер, инкапсулированным по сути не является — состояние по-прежнему меняется снаружи произвольно. Сокрытие данных — средство, а цель — сохранить инварианты объекта (отрицательный баланс создать извне невозможно).

Наследование — это описание нового класса на основе существующего с полным или частичным заимствованием его функциональности. Класс, от которого наследуют, называют базовым, родительским или суперклассом, новый — потомком или подклассом. Объявляется через extends, к реализации родителя обращаются через super.

public class Manager extends Employee {

    public Manager(String name) {
        super(name);
    }

    @Override
    public double salary() {
        return super.salary() * 1.5;
    }
}

Ограничения Java:

• класс наследуется только от одного класса — множественного наследования классов нет;
• реализовать можно сколько угодно интерфейсов (множественное наследование типа);
• все классы неявно наследуются от java.lang.Object;
• класс с модификатором final унаследовать нельзя (например, String).

Наследование выражает отношение «является» (Manager — это Employee). Если нужно просто переиспользовать чужой код, лучше композиция: класс хранит другой объект в поле и делегирует ему работу.

Полиморфизм буквально означает «много форм»: это способность работать с объектами через единый интерфейс, не зная их конкретного типа. Классическая формулировка — «один интерфейс, множество реализаций».

Динамический полиморфизм реализуется переопределением методов: какой метод вызвать, решается во время выполнения по фактическому типу объекта (динамическое связывание).

List<Employee> staff = List.of(new Employee("Иван"), new Manager("Ольга"));

for (Employee employee : staff) {
    System.out.println(employee.salary()); // 1000.0, затем 1500.0
}

Статический полиморфизм реализуется перегрузкой: несколько методов с одним именем и разными параметрами, нужный выбирает компилятор по типам аргументов.

public void print(int value) { }

public void print(String value) { }

Разница в моменте выбора: перегрузка разрешается компилятором по объявленному типу аргументов, переопределение — виртуальной машиной по реальному типу объекта. Поэтому статические методы не переопределяются, а скрываются (выбор по типу ссылки), и поля тоже не полиморфны.

Абстракция — это выделение значимых характеристик объекта и отбрасывание незначимых для решаемой задачи. Одна и та же сущность абстрагируется по-разному в зависимости от контекста: платёжному сервису у клиента важны идентификатор и способ оплаты, а отделу кадров того же человека описывают должность и стаж.

В Java абстракцию выражают интерфейсы и абстрактные классы: они описывают, что объект умеет делать, ничего не говоря о том, как именно.

public interface Payment {
    void pay(long amount);
}

public class CardPayment implements Payment {
    @Override
    public void pay(long amount) {
        System.out.println("Оплата картой: " + amount);
    }
}

Payment payment = new CardPayment();
payment.pay(2500);

Отличие от инкапсуляции: абстракция — это решение на уровне проектирования (что вынести в контракт), а инкапсуляция — механизм реализации, который это решение защищает (модификаторы доступа и методы доступа). Абстракция скрывает сложность, инкапсуляция скрывает данные.

Принципы ООП описывают, из чего состоит объектная модель языка: инкапсуляция, наследование, полиморфизм, абстракция. SOLID — это пять принципов проектирования, которые подсказывают, как пользоваться ООП, чтобы код оставался поддерживаемым.

• S — Single Responsibility: у класса одна причина для изменения;
• O — Open/Closed: открыт для расширения, закрыт для изменения (новый способ оплаты — новая реализация Payment);
• L — Liskov Substitution: потомок подставляется вместо родителя без сюрпризов;
• I — Interface Segregation: много узких интерфейсов лучше одного широкого;
• D — Dependency Inversion: зависим от абстракций, а не от реализаций (поле типа Payment, а не CardPayment).

Коротко: ООП отвечает на вопрос, из чего состоит модель, SOLID — как её выстроить, чтобы она не разваливалась при изменениях.