Интервьюер: Что такое инкапсуляция и как вы ее достигаете в Java?
Me: Инкапсуляция - это механизм, позволяющий скрыть информацию от клиента. Информация может быть данными или реализацией или алгоритмом. Мы добиться этого с помощью модификаторов доступа.
Интервьюер: Это скрытие данных. Как добиться инкапсуляции в Java?
Me: uummmm
Конкретный вопрос: Помимо "модификаторов доступа", каков способ реализации инкапсуляции в Java?
В более общем случае инкапсуляция относится просто к объединению данных (например, объекта) с операциями над этими данными. Таким образом, у вас есть класс, инкапсулирующий данные - поля - вместе с методами управления этими данными.
Но инкапсуляция также иногда используется так же, как и ваш ответ, и, действительно, одна из точек связывания данных и методов - это скрыть реализацию.
Я предполагаю, что лучший ответ, чем просто методы использования, и сделать все поля закрытыми: используйте интерфейсы. Таким образом, операции над объектом основаны исключительно на контракте интерфейса и никоим образом не связаны с полями или вспомогательными методами, используемыми для внутреннего выполнения этого контракта.
Обычно Инкапсуляция означает объединение похожих элементов, простое.
Например, возьмите класс Student, где у нас будут ученические переменные экземпляра и поведение/методы, действующие на эти переменные экземпляра @на одно место.
Почему это важно? Мы не хотим, чтобы наш код разбросался по всей нашей базе кода.
Если мы скажем, что нам нужно внести изменения, нам нужно найти варианты (тех изменений) во всех местах. Объединяя похожие элементы, мы просто избегаем таких сценариев, и это также помогает сделать наш объединенный код более сфокусированным.
Это просто способ защитить ваши данные от внешнего мира. Что это значит, скажем, если бы я сделал свою переменную экземпляра общедоступной, тогда любой может изменить ее состояние. Но если мы сделаем нашу переменную instance private/protected, то на самом деле мы ограничиваем внешние сущности от внесения в нее изменений.
Теперь возникает вопрос, в чем мы защищаем наши переменные?
Снова нам нужно понять, что Инкапсуляция - это просто контейнер, в который нам нужно разместить похожие объекты.
Его просто действуют как черный ящик для внешнего мира. Внешний мир (я хочу сказать, что клиенты/потребители: используя наш класс Student) не знают внутренних деталей/деталей реализации класса Student, и на самом деле им не нужно заботиться о внутренних деталях/деталях реализации класса, Им просто нужны некоторые методы /API, чтобы они могли использовать их в своем клиентском приложении.
Итак, моя точка зрения - все поведение/переменные, связанные с учениками, помещаются в ящик Черного, который мы называем его классом. Теперь его разработчик класса, каковы элементы класса, должен быть скрыт и что не следует скрывать от внешнего мира.
Теперь вернемся к вопросу В Java: мы делаем наши переменные частными, это означает, что они защищены классом. Если мы хотим, чтобы наши переменные экземпляра были доступны по всему пакету, тогда они защищены пакетом. В рамках проекта они являются публичными. Поэтому я хочу сказать, что вам нужно скрыть данные, которые вам нужны в каком-то контейнере, где вы будете помещать свои данные и скрываться в отношении контейнера.
Итак, что я чувствую Скрытие данных невозможно без Encapsulation. Вы не можете скрыть свои данные, не помещая их в какой-либо контейнер. Опять же, я напоминаю вам, что я помещаю это в контекст объектно-ориентированного языка.
Но да Инкапсуляция возможна без скрытия ваших данных. Положите все на вещи публично, и вы можете увидеть аффект.
Инкапсуляция: возьмите пример капсулы. Если вы откроете его, в нем будет много ингредиентов. Объектно-ориентированное программирование Инкапсуляция тоже такая. Как следует из названия, "Инкапсуляция означает инкапсуляцию (создание капсулы) всех элементов данных, атрибутов и соответствующих методов в одной капсуле.
Как вы это сделаете: Допустим, вы создали класс под названием "Автомобиль". Теперь автомобиль имеет цветовую цену и модель. Это атрибуты, и он имеет метод запуска. Итак, здесь вы инкапсулировали все эти атрибуты и методы транспортного средства под названием "Автомобиль". Когда вы создаете такой экземпляр автомобиля
Car myCar = new Car();
Вы можете получить доступ ко всем атрибутам Car с помощью переменной myCar.
" Скрытие данных": скрытие данных контролируется в Java с использованием модификаторов доступа. Для доступа к членам данных вы используете ACCESSORS, а для изменения данных вы используете " Мутаторы". Java не предоставляет аксессуаров и мутаторов самостоятельно, вы сами создаете их (геттеры и сеттеры). В то время как С# предоставляет СВОЙСТВА для этого.
Мне не нравится это делать, но Wikipedia:
В языках программирования инкапсуляция используется для обозначения одного из двух но разные понятия, а иногда и комбинации его:
- Языковой механизм для ограничения доступа к некоторым компонентам объекта.
- Конструкция языка, которая облегчает объединение данных с помощью методов (или других функций), работающих с этими данными.
Ваше объяснение было больше в соответствии с первым понятием, интервьюер искал что-то на втором.
Инкапсуляция данных относится к механизму сохранения всех связанных свойств и метода в единый объект.
Пример: автомобиль. Он держит рулевые колеса, шины, двигатель и все связанные с ним вещи в один коллективный объект, известный как Car.
В языках программирования инкапсуляция выполняется с помощью классов. Класс содержит все свойства и связанные методы в one single entity, предназначенные для выполнения конкретной задачи.
Скрытие данных означает скрытие несущественных деталей от пользователя и отображение ему только соответствующих данных.
Пример. Когда мы нажимаем тормоза или акселератор в автомобиле, мы не знаем, что происходит за сценой (как это увеличивает его скорость или то, как она применяет тормоза в шинах). Все, что мы знаем, это то, что у нас есть тормоз и ускоритель для достижения желаемого результата.
В программировании это делается с помощью модификаторов доступа. Частные члены недоступны извне класса, и только члены public доступны для пользователей. Частным членам можно получить доступ только от членов класса, тем самым обеспечивая безопасность для частных членов, которые будут напрямую оцениваться извне класса.
Вопрос представляется ошибочным, я сомневаюсь, что кто-нибудь, кроме интервьюера, мог бы ответить на него, и вероятность того, что его ответ может быть неправильным. Самое главное, неясно, какой вопрос должен оценивать или обнаруживать.
Тем не менее, я подумал об этом, и следующее, что я считаю, может быть моей попыткой ответить на вопрос.
В Java инкапсуляция реализуется путем скрытия деталей с использованием модификаторов доступности (т.е. public, protected, private и т.д.). С этими уровнями доступности вы контролируете уровень скрытия информации. Чем менее ограничительный уровень, тем более дорогим изменением является то, когда это происходит, и чем больше он связан с другими зависимыми классами (например, пользовательскими классами, подклассами).
Очевидно, что инкапсуляция - это нечто большее, чем просто скрытие состояния. В Java вы можете скрыть целые классы и интерфейсы, их состояние и поведение, тем самым скрывая детали реализации всего API.
Например, метод Arrays.asList() возвращает реализацию List, но мы не заботимся о том, какая реализация, если она удовлетворяет публичному интерфейсу List, правильно?. Реализация может быть изменена в будущем, не затрагивая нас, пользователей метода, но фактическая реализация скрыта от нас.
До этого момента казалось бы, что инкапсуляция полностью зависит от емкости языка программирования, чтобы скрыть детали, и, следовательно, что это невозможно достичь без модификаторов доступа, правильно?
Однако, как язык, подобный Python, достигает инкапсуляции, когда у него нет модификаторов доступа? Все открыто в Python? Означает ли это, что инкапсуляция невозможна?
Что, если мы, условно, определяем открытый интерфейс наших компонентов, а затем получаем доступ к состоянию и поведению объектов только через их общий интерфейс? Очевидно, для этого нам нужно четкое понимание абстракций в нашей проблемной области и то, как они должны потребляться нашими пользователями.
Мне кажется, что вопрос интервью был предназначен для оценки инкапсуляции как более широкой концепции, в зависимости от определения очень четких абстракций, а не только как побочный продукт языковой функции, такой как модификаторы доступа.
Вот почему, на мой взгляд, чтобы действительно понять инкапсуляцию, нужно сначала понять абстракцию.
Подумайте, например, об уровне абстракции в концепции автомобиля. Автомобиль сложный в своей внутренней реализации. У них есть несколько подсистем, таких как система передачи, система разломов, топливная система и т.д.
Однако мы упростили его абстракцию, и мы взаимодействуем со всеми автомобилями в мире через публичный интерфейс их абстракции. Мы знаем, что у всех автомобилей есть рулевое колесо, через которое мы контролируем направление, у них есть педаль, когда вы нажимаете на нее, вы ускоряете машину и контролируете скорость, а другое - когда вы ее нажимаете, вы останавливаете ее, и у вас есть рычаг переключения передач которые позволяют вам контролировать, если вы продвигаетесь вперед. Эти функции представляют собой публичный интерфейс абстракции автомобиля. Утром вы можете водить седан, а затем выйти из него и водить внедорожник днем, как будто это то же самое.
Это не значит, что вы не можете открыть капот и посмотреть, как все это работает. Тем не менее, немногие из нас знают детали того, как все эти базовые функции реализованы под капотом, и правда в том, что нам не нужно знать детали, чтобы управлять автомобилем. Все это инкапсулировано под автомобильную абстракцию. Нам нужно знать только публичный интерфейс абстракции.
Подумайте о времени, когда автомобили не имели системы гидравлической направленности. В один прекрасный день изготовители автомобилей изобрели его, и они решают его сесть на автомобили. Тем не менее, это не изменило способ взаимодействия пользователей с ними. В лучшем случае пользователи испытали улучшение в использовании направленной системы. Такое изменение стало возможным благодаря тому, что внутренняя реализация автомобиля была инкапсулирована.
Это наглядно демонстрирует, что, скрывая детали того, как были реализованы направленные системы, они могли безопасно изменить его, не затрагивая публичный интерфейс автомобиля и, соответственно, не влияя на то, как пользователи взаимодействовали с ним.
Теперь подумайте, что производители автомобилей решили поставить топливную крышку под машину, а не на одной из ее сторон. Вы идете и покупаете одну из этих новых машин, и когда у вас заканчивается газ, вы идете на бензоколонку, и вы не найдете топливный колпачок. Внезапно вы понимаете, что ниже автомобиля, но вы не можете дотянуться до него с помощью шланга газового насоса. Теперь мы нарушили договор публичного интерфейса, и поэтому весь мир разбивается, он разваливается, потому что вещи не работают так, как ожидалось. Такое изменение стоило бы миллионов. Нам нужно будет заменить все газовые насосы в мире. Когда мы нарушаем инкапсуляцию, мы должны заплатить цену.
Итак, как вы видите, целью инкапсуляции является минимизация взаимозависимости и облегчение изменений. Вы максимизируете инкапсуляцию, сводя к минимуму воздействие деталей реализации. Состояние класса должно быть доступно только через его публичный интерфейс.
Красота инкапсуляции - это сила изменения вещей, не затрагивая ее пользователей.
Можно сказать, что эта конечная цель зависит от тщательного планирования и дизайна. В Java модификаторы доступа - это способ воплотить эти идеи в жизнь, но на языке, где эта функция не существует, одинаково можно добиться инкапсуляции.
В классе атрибуты и поведение помещаются вместе. Инкапсуляция означает, что при создании класса это само по себе означает, что вы реализуете принцип инкапсуляции. Потому что данные и поведение инкапсулируются в класс. Таким образом, скрытие данных является основной частью термина - инкапсуляция. А это означает точки доступа объекта.
Я видел, что много обсуждений уже сделано, просто для того, чтобы упростить свое понимание:
Инкапсуляция Обеспечивает, что поведение объекта может быть затронуто только через его API. Это позволяет нам контролировать, насколько изменение одного объекта повлияет на другие части системы, гарантируя отсутствие неожиданных зависимостей между несвязанные компоненты. Модификатор хода может использоваться для достижения инкапсуляции.
скрытие информации Скрывает, как объект реализует свои функции за абстракцией его API. Это позволяет нам работать с более высокими абстракциями, игнорируя детали нижнего уровня которые не связаны с поставленной задачей. Абстракция на уровне дизайна может использоваться для обеспечения скрытия данных.
Простейшим определением инкапсуляции является "Связывание данных и кода, которые управляют данными в единое целое", так что к данным не может быть напрямую доступ к внешним мирам.
В языке структуры, таком как c-данные, объявляются в начале блока и используются напрямую, доступ к ним открыто (любой tom, dick и harry могут обращаться к данным). Скрытие данных - это концепция, позволяющая ограничить доступ к данным напрямую и открыто любому тиму и члену. Инкапсуляция является одним из способов достижения скрытия данных. Вы добиваетесь скрытия данных путем объединения данных и функций (инкапсуляция).
Как вы достигаете в JAVA, см. пример функции getter(), setter() в JAVA. Проверьте это
Как я вижу, Инкапсуляция относится к идее привязки данных и метода к одиночному единица называется классом. Однако для привязки данных и методов существует два основных критерия. Один из них - скрытие информации, а не единственное. Чтобы быть прекрасно лаконичным, я бы сказал, что два основных критерия:
Инкапсуляция: инкапсуляция является одной из основ OOPS, также является надмножеством для двух других терминов, скрытия данных и абстракции. (Скрытие данных, поскольку этот термин относится.. Данные могут храниться только в переменных. Чтобы скрыть данные из внешнего мира, мы используем концепцию скрытия данных. Public, Private, Protected - это три модификатора доступа, предоставляемые нам для скрытия данных. ограниченным пакетом. Защищено, ограниченное унаследованным классом.) ** Частные переменные доступны только внутри класса, что означает, что если есть внутренний класс, там также могут быть вызваны частные переменные. Только статические внутренние классы могут вызывать статические переменные.
Теперь переход к абстракции (что означает Нематериальность). Абстракция также рассматривается как процесс скрыть реализацию от пользователя и предоставить только конечный результат. Пример: у нас есть класс человека, который имеет свойство "Вес". Это свойство довольно сложно, потому что мы не можем принять менее одного веса для человека. Также мы не можем принять более 500 кг. Таким образом, скрытие реализации для них будет в методе setter. Эта вещь, скрывающая детали реализации, - это абстракция.
** И полный пакет, т.е. закрытие объекта и реализация логики в установщике и получателе называется ENCAPSULATION.
Инкапсуляция означает привязывание элементов данных и метода (поведения) в одном блоке и предоставление столько информации, сколько требуется пользователю, легко сказать [encapsulation = data hiding + abstraction].
Класс полностью инкапсулированный элемент в java
Скрытие данных означает объявление переменных данных как конфиденциальных для защиты от несанкционированного доступа, но если вы даете некоторый общедоступный метод setter и getter для проверки.
Процесс определения класса, скрывая его данные от прямого доступа от внешнего члена класса и обеспечивая доступ только через общедоступный метод setter и getter посредством правильной проверки, называется Encapsulation.
Процесс привязки элементов данных и соответствующих методов в один блок - это не что иное, как инкапсуляция.
Инкапсуляция = Скрытие данных + Абстракция
Скрытие данных означает, что мы обеспечиваем безопасность данных внутри класса.
Абстракция означает скрытие кода путем определения функций-членов.
Инкапсуляция - это комбинация абстракции и скрытия данных, означает, что мы обертывание данных и кода, связанных с этими данными. Для ex bean class
class student {
private int age; // Data Hiding
public setAge(){} // Abstraction
public getAge(){} // Abstraction
}
класс студентов инкапсулирован.
encapsulation = скрытие данных + абстракция
Инкапсуляция Инкапсуляция - это концепция объектно-ориентированного программирования, которая связывает воедино данные и функции, которые манипулируют данными, и защищает как от внешнего вмешательства, так и от неправильного использования. Инкапсуляция данных привела к важной ООП-концепции сокрытия данных.
Если класс не позволяет вызывающему коду получать доступ к внутренним данным объекта и разрешает доступ только через методы, это является сильной формой абстракции или сокрытия информации, известной как инкапсуляция. Некоторые языки (например, Java) позволяют классам явно применять ограничения доступа, например, для обозначения внутренних данных с помощью ключевого слова private и обозначения методов, предназначенных для использования кодом вне класса, с помощью ключевого слова public. Методы также могут быть спроектированы как открытый, частный или промежуточный уровни, например защищенный (который обеспечивает доступ из того же класса и его подклассов, но не из объектов другого класса). В других языках (таких как Python) это обеспечивается только соглашением (например, частные методы могут иметь имена, начинающиеся с подчеркивания). Инкапсуляция предотвращает взаимодействие внешнего кода с внутренней работой объекта. Это облегчает рефакторинг кода, например, позволяет автору класса изменять, как объекты этого класса представляют свои данные внутренне, без изменения какого-либо внешнего кода (при условии, что "публичные" вызовы методов работают одинаково). Это также побуждает программистов помещать весь код, связанный с определенным набором данных, в один и тот же класс, что упрощает его понимание другими программистами. Инкапсуляция - это техника, которая поощряет разделение.
По сути, инкапсуляция данных - это процесс, а скрытие данных - это техника. В инкапсуляции данные могут быть общедоступными или частными, но в данных сокрытия данных являются только частными. Таким образом, сокрытие данных использует инкапсуляцию, но также использует различные методы, чтобы данные были разрешены только для авторизованного доступа. Надеюсь, поможет!
Абстракция говорит о том, что нужно для взаимодействия с объектом.
Инкапсуляция означает инкапсуляцию свойств объекта, состояния и поведения в одну логическую единицу, называемую классом.
Скрытие данных говорит о том, что скрытие внутренней реализации объектов означает закрытые методы и свойства, объект, который используется для поддержания их состояния.