Статья
От простой двери перейдём к объектам, наследованию, полиморфизму, инкапсуляции и абстракции — без скачков между кодом и терминами.
Класс и объект — сначала без сложных слов
Класс — это общее описание будущих объектов: какие данные они хранят и какие действия умеют выполнять. Объект — конкретный экземпляр, созданный по этому описанию.
Начнём с обычной двери в игре. Для нашей задачи достаточно знать её название и открыта она сейчас или закрыта. Ещё дверь должна уметь открываться.
В 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.
- Перегрузка выбирается при компиляции, переопределённая реализация — по фактическому объекту во время выполнения.
- ООП полезно только тогда, когда структура делает задачу понятнее, а не добавляет классы ради классов.
Опубликовано · Обновлено · Проверено на актуальность