§ 49. Скрытие внутреннего устройства

Определения и обозначения

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

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

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

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

Как это устроено

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

Разделение интерфейса и реализации позволяет менять устройство класса, не переписывая код, который им пользуется. Например, коллекция может хранить элементы одним способом, а затем перейти на другой. Если внешние программы по-прежнему вызывают те же методы с теми же правилами, им не нужно знать о перемене. Поэтому при проектировании класса полезно заранее отделять нужные пользователю операции от решений, относящихся только к реализации.

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

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

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

Открытые и скрытые части класса

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

Разбор задач

Класс «Счёт»

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

1. Выделяем потребности пользователя: узнать баланс, внести деньги, снять деньги.
2. Делаем баланс закрытым полем, чтобы внешний код не мог задать ему произвольное значение.
3. Предоставляем открытые методы для чтения баланса, внесения и снятия суммы.
4. Внутри методов проверяем допустимость суммы и не выполняем недопустимую операцию.

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

Класс «Счётчик»

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

1. Объявляем поле со значением закрытым.
2. Добавляем открытый метод, который увеличивает значение на единицу.
3. Добавляем открытый метод, который возвращает текущее значение.
4. Не создаём метод для произвольной установки значения, так как он не нужен условию.

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

Класс «Коллекция»

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

1. Определяем открытые операции: добавить элемент, удалить элемент и получить элемент.
2. Проверяем, что внешний код вызывает только эти операции, а не обращается к внутреннему хранилищу напрямую.
3. Меняем способ хранения элементов внутри класса.
4. Сохраняем прежние операции и их правила использования.

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

Типичные ошибки

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

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

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

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

Связь с другими темами

Для понимания скрытия реализации нужно знать, что такое класс, объект, поле и метод, а также уметь вызывать методы объекта. Инкапсуляция помогает строить модульные программы: отдельные части взаимодействуют через понятные операции. Этот принцип пригодится при создании классов, библиотек и крупных проектов, где внутреннее устройство одного компонента не должно зависеть от кода другого. Ясные интерфейсы также подготавливают к изучению наследования и полиморфизма, связанных с устройством классов и использованием их возможностей.

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

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