Три принципа ООП в Java

Три принципа ООП в Java — это инкапсуляция, наследование и полиморфизм. Часто к ним добавляют четвёртый — абстракцию, поэтому в литературе встречаются оба варианта: «три принципа» и «четыре принципа» объектно-ориентированного программирования. Ниже — что означает каждый из них и как он выглядит в коде на Java.

Что такое ООП и зачем оно нужно

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

В отличие от процедурного подхода, где данные и функции живут отдельно друг от друга, ООП связывает их вместе. Это даёт три практических выгоды: код проще менять локально, поведение можно расширять без правки готовых классов и один и тот же вызов может работать с разными реализациями.

Java спроектирована вокруг классов: любой метод обязан находиться внутри класса или интерфейса, а точка входа main — тоже метод класса.

Инкапсуляция

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

В 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;
    }
}

BankAccount account = new BankAccount();
account.deposit(500);
// account.balance = -100; // не скомпилируется: поле private
System.out.println(account.getBalance()); // 500

Ключевая мысль: инкапсуляция не про «поставить private», а про то, что класс сам отвечает за корректность своих данных. Отрицательный баланс просто невозможно создать извне.

Наследование

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

В Java наследование объявляется словом extends, а обратиться к реализации родителя можно через super.

public class Employee {

    protected final String name;

    public Employee(String name) {
        this.name = name;
    }

    public double salary() {
        return 1000;
    }
}

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).

Полиморфизм

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

В Java различают две формы полиморфизма.

Динамический полиморфизм (переопределение)

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

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

for (Employee employee : staff) {
    // тип переменной — Employee, но вызывается метод фактического класса
    System.out.println(employee.salary());
}
// 1000.0
// 1500.0

Статический полиморфизм (перегрузка)

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

public class Printer {

    public void print(int value) {
        System.out.println("int: " + value);
    }

    public void print(String value) {
        System.out.println("String: " + value);
    }
}

Подробный разбор термина за пределами Java — в статье Полиморфизм (информатика).

Абстракция — четвёртый принцип

Абстракция данных — это выделение значимых характеристик объекта и отбрасывание незначимых для решаемой задачи. Набор таких характеристик и есть абстракция.

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

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

public interface Payment {
    void pay(long amount);            // что делаем — известно
}

public class CardPayment implements Payment {
    @Override
    public void pay(long amount) {    // как делаем — деталь реализации
        System.out.println("Оплата картой: " + amount);
    }
}

public class CashPayment implements Payment {
    @Override
    public void pay(long amount) {
        System.out.println("Оплата наличными: " + amount);
    }
}

Payment payment = new CardPayment();  // код работает с абстракцией
payment.pay(2500);                    // Оплата картой: 2500

Обратите внимание: этот пример одновременно демонстрирует абстракцию (интерфейс Payment) и полиморфизм (вызов pay() уходит в нужную реализацию). Принципы ООП работают в связке, а не по отдельности.

Сравнение четырёх принципов

ООП и SOLID — это разные вещи

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

Где чаще всего ошибаются

• Считают инкапсуляцию синонимом сокрытия данных. Сокрытие — только часть: инкапсуляция ещё и объединяет состояние с поведением в одном классе.
• Наследуют ради переиспользования кода. Если между классами нет отношения «является», получается хрупкая иерархия; композиция здесь надёжнее.
• Путают перегрузку и переопределение. Перегрузка — одинаковое имя и разные параметры в одном классе; переопределение — одинаковая сигнатура в потомке.
• Забывают @Override. Аннотация не обязательна, но без неё опечатка в имени метода превращает переопределение в новый метод — и компилятор промолчит.
• Называют композицию и агрегацию принципами ООП. Это виды отношений между объектами, а не принципы; на собеседовании такой ответ засчитают как ошибку.
• Утверждают, что Java — полностью объектно-ориентированный язык. Примитивные типы (int, double, boolean) объектами не являются, поэтому Java считают гибридным языком.

Официальное введение в объекты и классы — раздел Object-Oriented Programming Concepts в Java Tutorials от Oracle.