Core-1 · Тема 1 из 6

Основы ООП в Java: простое объяснение для начинающих

Начнём с обычной двери и будем усложнять модель только тогда, когда для этого появится понятная причина. Так каждый термин ООП окажется связан с конкретным кодом и практической пользой.

  • 10вопросов

Статья

От простой двери перейдём к объектам, наследованию, полиморфизму, инкапсуляции и абстракции — без скачков между кодом и терминами.

Класс и объект — сначала без сложных слов

Класс — это общее описание будущих объектов: какие данные они хранят и какие действия умеют выполнять. Объект — конкретный экземпляр, созданный по этому описанию.

Начнём с обычной двери в игре. Для нашей задачи достаточно знать её название и открыта она сейчас или закрыта. Ещё дверь должна уметь открываться.

В Java данные объекта хранятся в полях, а действия описываются методами. Поэтому name и open — поля двери, а open() — метод. Значение open равно false, пока дверь закрыта, и true после открытия.

class Door {
    String name;       // Название двери
    boolean open;      // false — закрыта, true — открыта

    void open() {
        open = true;
    }
}

Две двери — два независимых объекта

Само объявление class Door ещё не создаёт дверь. Выражение new Door() создаёт отдельный объект. Если выполнить его дважды, появятся две двери, и у каждой будут собственные значения полей.

У двери в пункт управления имя controlRoomDoor и состояние false. У двери на выход — другое имя и состояние true. Обе созданы по одному классу Door, но это не связывает значения их полей.

Вызов storageDoor.open() меняет open только у storageDoor. Состояние controlRoomDoor при этом не меняется. Метод описан в классе один раз, но работает с тем объектом, у которого его вызвали.

Door controlRoomDoor = new Door();
controlRoomDoor.name = "Дверь в пункт управления";
controlRoomDoor.open = true;

Door storageDoor = new Door();
storageDoor.name = "Дверь в хранилище";
storageDoor.open = false;

storageDoor.open();

// controlRoomDoor.open по-прежнему true
// storageDoor.open теперь тоже true

Что здесь уже относится к ООП

Текущие значения полей называют состоянием объекта. Название и признак open входят в состояние конкретной двери. Метод open() описывает поведение — действие, которое объект может выполнить со своим состоянием.

ООП — это способ организовать программу вокруг объектов, у которых есть собственное состояние и поведение. Класс задаёт общее устройство, а каждый объект хранит свои данные и использует общие методы.

Практическая польза уже видна: описание двери написано один раз, а объектов можно создать столько, сколько нужно уровню. Код, связанный с дверью, находится рядом, а изменение storageDoor не затрагивает другую дверь.

Польза и цена объектной модели

Объектная модель помогает распределить обязанности. Дверь отвечает за своё состояние и открытие; другой объект может отвечать за игрока или уровень. Разработчику проще найти место изменения и не копировать одно правило для каждой двери.

Но ООП не делает код хорошим автоматически. Если для простой задачи создать много классов, интерфейсов и уровней наследования, решение станет труднее читать. Неудачные зависимости также усиливают связанность: изменение одного класса начинает тянуть правки во многих других.

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

Дверь с кодом: зачем понадобилось наследование

Теперь появляется новая задача: обычная дверь открывается сразу, а дверь с кодовым замком — только после правильного кода. У них остаются общие название, состояние open и само действие open(). Не хочется описывать эту часть второй раз.

CodeDoor можно объявить как более конкретную разновидность Door. Запись extends Door означает, что кодовая дверь получает доступные поля и методы обычной двери, добавляет код доступа и может изменить поведение открытия.

Метод CodeDoor.open() имеет то же имя и те же параметры, что Door.open(), поэтому он переопределяет родительский метод. Пока unlocked равно false, дверь не открывается. После правильного кода вызывается super.open(), то есть реализация Door, которая меняет open на true. Закрытие и повторную блокировку в этой небольшой модели пока не рассматриваем.

class CodeDoor extends Door {
    int accessCode;
    boolean unlocked;

    void enterCode(int enteredAccessCode) {
        unlocked = enteredAccessCode == accessCode;
    }

    @Override
    void open() {
        if (unlocked) {
            super.open();
        }
    }
}

Одна команда — разное поведение

Наследование даёт ещё одну возможность: переменная Door door может ссылаться и на обычную Door, и на CodeDoor. Метод tryToOpen() поэтому работает с общим типом Door и не проверяет конкретный класс вручную.

Внутри tryToOpen() в обоих случаях написан один вызов door.open(). Для обычной двери будет выполнен Door.open(), а для объекта CodeDoor будет выполнен CodeDoor.open(). Конкретная реализация выбирается по фактическому объекту.

Это полиморфизм: клиентский код использует общий тип и общий вызов, а разные объекты выполняют этот вызов по-своему. Добавление ещё одного вида двери не требует превращать tryToOpen() в цепочку if по классам.

static void tryToOpen(Door door) {
    door.open();
}

Door ordinaryDoor = new Door();

CodeDoor codeDoor = new CodeDoor();
codeDoor.accessCode = 4312;

tryToOpen(ordinaryDoor); // Выполнится Door.open()
tryToOpen(codeDoor);     // Выполнится CodeDoor.open(), дверь останется закрытой

codeDoor.enterCode(4312);
tryToOpen(codeDoor);     // Теперь кодовая дверь откроется

Нельзя оставлять состояние без защиты

Пока поля открыты, любой код может обойти правила объекта. Можно присвоить codeDoor.open = true и открыть кодовую дверь без проверки. Можно заменить accessCode на удобное значение и после этого передать то же число в enterCode().

Проблема не в методе enterCode(): он честно сравнивает значения. Проблема в том, что внешний код может напрямую переписать данные, от которых зависит правило.

Значит, объекту недостаточно просто иметь методы. Он должен контролировать, какие изменения его состояния разрешены.

codeDoor.open = true;    // Обход проверки
codeDoor.accessCode = 0;  // Подмена сохранённого кода

Инкапсуляция: объект сам следит за своими правилами

Сделаем поля private. Теперь изменить их напрямую из другого класса нельзя. Название и код доступа передаются конструктору при создании объекта, состояние читается через методы, а меняется только разрешёнными действиями.

Это инкапсуляция: объект объединяет состояние с правилами работы над ним и не позволяет внешнему коду произвольно нарушать эти правила. private — один из механизмов Java, а не полное определение принципа.

Безусловный setter для каждого поля не решает задачу. Если setOpen(true) открывает кодовую дверь без проверки, правило снова можно обойти. Методы должны выражать допустимые действия: ввести код, попытаться открыть дверь, узнать состояние.

class Door {
    private final String name;
    private boolean open;

    Door(String name) {
        this.name = name;
    }

    public void open() {
        open = true;
    }

    public boolean isOpen() {
        return open;
    }

    public String getName() {
        return name;
    }
}

class CodeDoor extends Door {
    private int accessCode;
    private boolean unlocked;

    CodeDoor(String name, int accessCode) {
        super(name);
        this.accessCode = accessCode;
    }

    public boolean enterCode(int enteredAccessCode) {
        unlocked = enteredAccessCode == accessCode;
        return unlocked;
    }

    @Override
    public void open() {
        if (unlocked) {
            super.open();
        }
    }

    public boolean changeAccessCode(int currentCode, int newCode) {
        if (currentCode != accessCode) {
            return false;
        }
        accessCode = newCode;
        return true;
    }
}

Абстракция — это понятная граница объекта

После инкапсуляции внешний код видит небольшой набор понятных действий: open(), enterCode(), isOpen(). Ему не нужно знать, где хранится признак unlocked, как сравниваются числа и какая строка меняет состояние двери.

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

Инкапсуляция и абстракция связаны, но отвечают на разные вопросы. Абстракция определяет, чем объектом можно пользоваться. Инкапсуляция не даёт обойти правила и добраться до скрытого состояния напрямую.

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

interface Openable {
    void open();
}

// К объявлению уже написанного класса можно добавить:
// class Door implements Openable

Четыре принципа в одной модели

Теперь четыре принципа не выглядят отдельными определениями. Абстракция оставила понятные действия двери. Инкапсуляция закрыла поля и сохранила правила изменения состояния.

Наследование позволило создать CodeDoor на основе Door и не копировать общую часть. Полиморфизм позволил методу tryToOpen(Door door) одинаково обращаться к разным дверям, сохранив их собственное поведение.

Эти принципы помогают сдерживать сложность, но не гарантируют хороший дизайн. Глубокая иерархия или неясный контракт могут сделать программу сложнее. Каждый принцип применяют для конкретной причины, а не ради самого термина.

IS-A, HAS-A и связи между объектами

CodeDoor IS-A Door: кодовая дверь является разновидностью двери. Поэтому наследование здесь можно объяснить предметным смыслом, а объект CodeDoor можно использовать там, где ожидается Door.

Но дверь не является замком — она имеет замок. Если проверка кода станет самостоятельной сложной частью, её лучше вынести в объект CodeLock и сохранить ссылку на него внутри CodeDoor. Это отношение HAS-A.

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

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

Раннее и позднее связывание

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

Если у CodeDoor есть open() и open(int enteredAccessCode), это перегрузка: имя одно, параметры разные. Для обычных необобщённых методов сигнатуру различают по имени и типам параметров; возвращаемого типа для новой перегрузки недостаточно. Компилятор выбирает подходящую сигнатуру по аргументам вызова.

Переопределение работает иначе. Сигнатура open() уже известна, но Door и CodeDoor имеют разные реализации. Для переменной Door компилятор проверяет, что такой метод существует, а во время выполнения Java выбирает реализацию по фактическому объекту.

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

void open() {
    // Попытка открыть дверь по её правилам
}

void open(int enteredAccessCode) {
    // Другая сигнатура: метод принимает код доступа
}

Как отвечать на собеседовании

Сначала объясните ООП одним понятным предложением и покажите связь класса с объектами. Затем назовите четыре принципа. Если интервьюер попросит раскрыть один из них, объясните механизм и вернитесь к небольшому примеру.

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

Для нашей модели естественный пример такой: Door задаёт общую основу, CodeDoor уточняет открытие, private защищает состояние, а вызов open() через тип Door выполняет реализацию фактического объекта.

Можно сказать так

Пример ответа на собеседовании

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

Что важно запомнить

  • Класс задаёт общее описание, а каждый объект хранит собственное состояние.
  • Метод работает с тем объектом, у которого его вызвали.
  • ООП помогает распределять обязанности, локализовать изменения и повторно использовать общую основу.
  • Четыре принципа ООП: абстракция, инкапсуляция, наследование и полиморфизм.
  • Абстракция задаёт понятные возможности, инкапсуляция защищает состояние и правила.
  • Наследование выражает IS-A, а отдельный объект внутри класса — HAS-A.
  • Перегрузка выбирается при компиляции, переопределённая реализация — по фактическому объекту во время выполнения.
  • ООП полезно только тогда, когда структура делает задачу понятнее, а не добавляет классы ради классов.

Опубликовано · Обновлено · Проверено на актуальность

Чек-лист подготовки

Вопросы для самопроверки

Что такое ООП

Короткий ответ

ООП — это способ организовать программу вокруг объектов, у которых есть собственное состояние и поведение. Класс задаёт общее описание полей и методов, а каждый созданный объект хранит свои значения. Например, две двери класса Door имеют разные имена и независимо меняют состояние open.

Какие преимущества у ООП?

Короткий ответ

ООП помогает разделить программу на объекты с понятными обязанностями, держать связанные данные и действия рядом и локализовать изменения. Общее описание и контракты можно использовать повторно для многих объектов и разных реализаций.

Какие недостатки у ООП?

Короткий ответ

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

Принципы ООП

Короткий ответ

Четыре основных принципа ООП — абстракция, инкапсуляция, наследование и полиморфизм. Абстракция задаёт понятные возможности, инкапсуляция защищает состояние, наследование создаёт разновидность на общей основе, а полиморфизм позволяет общему вызову выполнять разные реализации.

Что такое абстракция?

Короткий ответ

Абстракция показывает клиентскому коду только существенные возможности объекта и их контракт. Например, код вызывает open() и isOpen(), но не знает, где хранится состояние и какие внутренние шаги выполняет дверь. В Java такую договорённость часто закрепляют интерфейсом или абстрактным классом.

Что такое инкапсуляция?

Короткий ответ

Инкапсуляция означает, что объект сам контролирует своё состояние и правила его изменения. Поля делают private, а снаружи оставляют осмысленные методы. Поэтому кодовую дверь нельзя открыть прямой записью open = true или незаметно подменить её accessCode.

Что такое наследование?

Короткий ответ

Наследование позволяет создать более конкретный класс на основе общего. CodeDoor extends Door получает доступную общую часть двери, добавляет кодовый замок и переопределяет open(). В Java класс имеет одного непосредственного родителя, а отношение должно честно выражать IS-A.

Что такое полиморфизм?

Короткий ответ

Полиморфизм позволяет работать с разными объектами через общий тип. Door door может ссылаться на обычную Door или CodeDoor, а один вызов door.open() выполнит Door.open() либо переопределённый CodeDoor.open() по фактическому объекту.

IS-A отношения HAS-A отношения ассоциация Агрегация Композиция

Короткий ответ

IS-A означает «является» и обычно ведёт к наследованию: CodeDoor является Door. HAS-A означает «имеет» и выражается ссылкой на другой объект: дверь имеет замок. Ассоциация — общая связь, агрегация оставляет часть самостоятельной, а композиция означает сильное владение частью.

Расскажите про раннее и позднее связывание.

Короткий ответ

Сначала компилятор выбирает подходящую сигнатуру метода. Например, open() и open(int) — перегрузка, и выбор зависит от аргументов вызова. Если выбран экземплярный метод open(), который переопределён в CodeDoor, конкретная реализация выбирается во время выполнения по фактическому объекту.

Закрепите вопросы в пробном режиме тренажёра

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

Запомнить