Большинство ответов здесь сосредоточены на ООП, но инкапсуляция начинается гораздо раньше:

• Каждая функция является инкапсуляцией ; в псевдокоде:

  point x = { 1, 4 } point y = { 23, 42 } numeric d = distance(x, y) 

  Здесь distance инкапсулирует вычисление (евклидова) расстояния между двумя точками в плоскости: оно скрывает детали реализации. Это инкапсуляция, чистая и простая.

• Абстракция – это процесс обобщения : принятие конкретной реализации и применение ее применительно к различным, хотя и некоторым связанным, типам данных. Классическим примером абстракции является функция qsort для сортировки данных:

  Дело в qsort заключается в том, что он не заботится о сортируемых данных – на самом деле, он не знает, какие данные он сортирует. Скорее, его тип ввода – это беспринципный указатель ( void* ), который является только способом C сказать «я не забочусь о типе данных» (это также называется стиранием типа). Важным моментом является то, что реализация qsort всегда остается неизменной независимо от типа данных. Единственное, что нужно изменить, это функция сравнения, которая отличается от типа данных типом данных. Поэтому qsort ожидает, что пользователь предоставит упомянутую функцию сравнения в качестве аргумента функции.

Инкапсуляция и абстракция идут arm об руку настолько, что вы можете сказать, что они действительно неотделимы. Для практических целей это, вероятно, верно; что сказано, вот инкапсуляция, которая не слишком абстракция:

 class point { numeric x numeric y } 

Мы инкапсулируем координату точки, но мы не отвлекаем ее от материальной абстракции, а не группируем их логически.

И вот пример абстракции, которая не является инкапсуляцией:

 T pi = 3.1415926535 

Это общая переменная pi с заданным значением (π), и декларация не заботится о точном типе переменной. По общему признанию, мне было бы трудно найти что-то подобное в реальном коде: абстракция практически всегда использует инкапсуляцию. Однако указанное выше действительно существует в C ++ (14), через переменные шаблоны (= общие шаблоны для переменных); с немного более сложным синтаксисом, например:

 template  constexpr T pi = T{3.1415926535}; 

Инкапсуляция скрывает детали реализации, которые могут быть или не быть для общего или специализированного поведения (я).

Абстракция обеспечивает обобщение (скажем, по набору поведений).

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

инкапсуляция помещает некоторые вещи в коробку и дает вам глазок; это мешает вам скреститься с шестернями.

абстракция не учитывает детали, которые не имеют значения, например, имеют ли вещи шестерни, трещотки, маховики или ядерные ядра; они просто “идут”

примеры инкапсуляции:

• Трусы
• ящик для инструментов
• бумажник
• сумка
• капсула
• замороженный карбонит
• коробка с кнопкой или без нее
• буррито (технически, тортилья вокруг буррито)

примеры абстракции:

• «группы вещей» – это абстракция (которую мы называем агрегацией)
• «вещи, которые содержат другие вещи» – это абстракция (которую мы называем композицией)
• «контейнер» – это другой вид абстракции «вещи, которые содержат другие вещи»; обратите внимание, что все примеры инкапсуляции являются видами контейнеров, но не все контейнеры демонстрируют / обеспечивают инкапсуляцию. Например, корзина представляет собой контейнер, который не инкапсулирует его содержимое.

Многие ответы и их примеры вводят в заблуждение.

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

Абстракция – это механизм, который представляет основные функции, не включая детали реализации.

Инкапсуляция: – скрытие информации .
Абстракция: – скрытие реализации .

Пример:

 class foo{ private: int a, b; public: foo(): a(0), b(0) { } foo(int x, int y): a(x), b(y) { } int add() { return a+b; } } 

Внутреннее представление любого объекта classа foo скрыто вне classа. -> Инкапсуляция.
Любой ansible элемент (данные / функция) объекта foo ограничен и доступен только для этого объекта.

 foo foo_obj(3, 4); int sum = foo_obj.add(); 

Внедрение метода add скрыто. -> Абстракция.

Инкапсуляция означает скрытие данных, таких как использование геттера и сеттера и т. Д.

Абстракция означает скрытие реализации с использованием абстрактного classа и интерфейсов и т. Д.

Абстракция – обобщенный термин. т.е. инкапсуляция является подмножеством абстракции.

учтивость

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

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

Позвольте мне привести пример на C #. Предположим, что у вас есть целое число:

 int Number = 5; string aStrNumber = Number.ToString(); 

вы можете использовать метод Number.ToString (), который возвращает представление символов из числа 5 и сохраняет его в строковом объекте. Метод подскажет вам, что он делает, а не как он это делает.

Много хороших ответов приведено выше, но я собираюсь представить свою (Java) точку зрения здесь.

Инкапсуляция данных просто означает перенос и контроль доступа логически сгруппированных данных в classе. Обычно это связано с другим ключевым словом – Data Hiding . Это достигается в Java с использованием модификаторов доступа .

Простым примером может быть определение частной переменной и предоставление доступа к ней с использованием методов getter и setter или создание частного метода, поскольку использование только classа. Пользователю не нужно знать об этих методах и переменных.

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

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

Пример –

Допустим, у нас есть интерфейс Animal, и у него есть функция makeSound () . Существует два конкретных classа Dog и Cat, которые реализуют этот интерфейс. Эти конкретные classы имеют отдельные реализации функции makeSound (). Теперь скажем, что у нас есть животное (мы получаем это из некоторого внешнего модуля). Все пользователи знают, что объект, который он получает, является некоторым животным, и ответственность за печать животных звучит от ответственности пользователей. Одним из способов грубой силы является проверка полученного объекта, чтобы идентифицировать его тип, затем приведите его к типу Animal и затем вызовите makeSound (). Но более аккуратным способом является абстрагирование . Используйте Animal как полиморфную ссылку и вызывайте makeSound () на ней. Во время выполнения, в зависимости от того, какой тип реального объекта является подходящей, будет вызываться.

Подробнее здесь .

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

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

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

Инкапсуляция – скрытие и / или ограничение доступа к определенным частям системы, а также отображение необходимых интерфейсов.

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

Основное сходство заключается в том, что эти методы направлены на улучшение понимания и полезности.

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

Длительный ответ

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

Вот пример инкапсуляции, который, надеюсь, делает вещи более ясными:

Здесь у нас есть Arduino Uno и Arduino Uno в корпусе. Корпус – отличное представление о том, что такое инкапсуляция.

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

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

В программировании это связано с группировкой различных компонентов в разделимую конструкцию, такую ​​как function , class или object . Он также включает в себя предоставление средств взаимодействия с этими конструкциями, а также методы получения полезной информации о них.

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

абстракция

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

Вот как мне нравится думать об абстракции:

Скажете ли вы, что изображение есть дерево? Скорее всего, вы бы это сделали. Но действительно ли это дерево? Ну, конечно, нет! Это куча пикселей, которые выглядят как нечто, что мы могли бы назвать деревом. Можно сказать, что это абстракция реального дерева. Обратите внимание, что несколько визуальных деталей дерева опущены. Кроме того, он не растет, не потребляет воду и не производит кислород. Как это могло быть? это всего лишь куча цветов на экране, представленная байтами в памяти вашего компьютера.

И вот суть абстракции. Это способ упрощения, поэтому их легче понять. Всякая идея, проходящая через вашу голову, – это абстракция реальности. Ваш ментальный образ дерева больше не является фактическим деревом, чем этот jpeg.

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

Абстрактные classы

Абстракция в программировании также позволяет рассматривать общие черты между несколькими «конкретными» типами объектов (типы, которые на самом деле существуют) и определять эти общие черты в уникальной сущности. Например, наш class Tree может наследовать от abstract class Plant , который имеет несколько свойств и методов, которые применимы ко всем нашим растительным classам, но удаляет те, которые характерны для каждого типа растений. Это может значительно уменьшить дублирование кода и улучшить ремонтопригодность.

Практическая разница abstract class и простого class заключается в том, что концептуально нет «реальных» экземпляров abstract class . Было бы бессмысленно строить объект Plant потому что это недостаточно специфично. Каждый «настоящий» Plant также является более конкретным типом Plant .

Кроме того, если мы хотим, чтобы наша программа была более реалистичной, мы могли бы рассмотреть тот факт, что наш class Tree может быть слишком абстрактным. В действительности каждое Tree является более конкретным типом Tree , поэтому мы могли бы создавать classы для таких типов, как Birch , Maple и т. Д., Которые наследуют от нашего, возможно, abstract , classа Tree .

JVM

Другим хорошим примером абстракции является виртуальная машина Java (JVM) , которая предоставляет виртуальный или абстрактный компьютер для запуска Java-кода. Он существенно убирает все компоненты платформы, специфичные для платформы, и предоставляет абстрактный интерфейс «компьютера» независимо от какой-либо системы в частности.

Разница

Инкапсуляция отличается от абстракции тем, что она не имеет никакого отношения к тому, как «реальное» или «точное». Он не удаляет компоненты чего-то, чтобы сделать его более простым или более широко применимым. Скорее он может скрыть определенные компоненты для достижения аналогичной цели.

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

 List list = new List(); list.Sort(); /* Here, which sorting algorithm is used and hows its implemented is not useful to the user who wants to perform sort, that's why its hidden from the user of list. */ 

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

 class Aeroplane : IFlyable, IFuelable, IMachine { // Aeroplane's Design says: // Aeroplane is a flying object // Aeroplane can be fueled // Aeroplane is a Machine } // But the code related to Pilot, or Driver of Aeroplane is not bothered // about Machine or Fuel. Hence, // pilot code: IFlyable flyingObj = new Aeroplane(); flyingObj.Fly(); // fighter Pilot related code IFlyable flyingObj2 = new FighterAeroplane(); flyingObj2.Fly(); // UFO related code IFlyable ufoObj = new UFO(); ufoObj.Fly(); // **All the 3 Above codes are genaralized using IFlyable, // Interface Abstraction** // Fly related code knows how to fly, irrespective of the type of // flying object they are. // Similarly, Fuel related code: // Fueling an Aeroplane IFuelable fuelableObj = new Aeroplane(); fuelableObj.FillFuel(); // Fueling a Car IFuelable fuelableObj2 = new Car(); // class Car : IFuelable { } fuelableObj2.FillFuel(); // ** Fueling code does not need know what kind of vehicle it is, so far // as it can Fill Fuel** 

Абстракция: идея представить что-то упрощенным / другим способом, который легче понять и использовать или более уместно для ситуации.

Рассмотрим class, который отправляет электронное письмо … он использует абстракцию, чтобы показать себя как своего рода мальчика-мессенджера, поэтому вы можете позвонить по электронной почте: emailSender.send (почта, получатель). То, что он на самом деле делает – выбирает POP3 / SMTP, вызывающие серверы, MIME-перевод и т. Д., Абстрагируется. Вы только видите своего мальчика-посланника.

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

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

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

Все это делает мир более приятным местом для жизни: D

Разница между абстракцией и инкапсуляцией.

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

Возьмем еще один пример, например, ATM. Клиенту не нужно знать, как машина считывает PIN-код и обрабатывает транзакцию, все, что ему нужно сделать, это ввести PIN-код, взять наличные и уйти.

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

Другой пример:

Предположим, что я создал неизменный class Rectangle следующим образом:

 class Rectangle { public: Rectangle(int width, int height) : width_(width), height_(height) {} int width() const { return width_; } int height() const { return height_; } private: int width_; int height_; } 

Теперь очевидно, что я инкапсулировал ширину и высоту (доступ как-то ограничен), но я ничего не абстрагировал (хорошо, возможно, я проигнорировал, где прямоугольник расположен в пространстве координат, но это недостаток пример).

Хорошая абстракция обычно подразумевает хорошую инкапсуляцию.

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

Abstraction и Encapsulation с использованием одного обобщенного примера

————————————————– ————————————————– ——————————–

Мы все используем калькулятор для расчета сложных проблем!

Механизм, который предотвращает конфиденциальность данных конкретных объектов от преднамеренного или случайного злоупотребления внешними функциями, называется « инкапсуляция данных»,

Акт представления основных функций без включения фоновых деталей или объяснений известен как абстракция

Абстракция: абстракция означает показать What часть функциональности.

Инкапсуляция: инкапсуляция означает скрытие How части функциональности.

Давайте рассмотрим очень простой пример

 /// 
 /// We have an Employee class having two properties EmployeeName and EmployeeCode /// 
 public class Employee { public string EmplpyeeName { get; set; } public string EmployeeCode { get; set; } // Add new employee to DB is the main functionality, so are making it public so that we can expose it to external environment // This is ABSTRACTION public void AddEmployee(Employee obj) { // "Creation of DB connection" and "To check if employee exists" are internal details which we have hide from external environment // You can see that these methods are private, external environment just need "What" part only CreateDBConnection(); CheckIfEmployeeExists(); } // ENCAPLUSATION using private keyword private bool CheckIfEmployeeExists() { // Here we can validate if the employee already exists return true; } // ENCAPLUSATION using private keyword private void CreateDBConnection() { // Create DB connection code } } 

Класс программы консольного приложения

 class Program { static void Main(string[] args) { Employee obj = new Employee(); obj.EmplpyeeName = "001"; obj.EmployeeCode = "Raj"; // We have exposed only what part of the functionality obj.AddEmployee(obj); } } 

Инкапсуляция – это сложность упаковки в одной капсуле, которая является classом и, следовательно, инкапсуляцией … Хотя абстракция является характеристикой объекта, который отличается от другого объекта …

Абстракция может быть достигнута путем абстрактного абстрактного classа с одним или несколькими методами. Это не что иное, как характеристика, которую должен выполнять class, расширяющий ее. например, когда вы изобретаете / разрабатываете автомобиль, вы определяете характеристики, такие как автомобиль, должны иметь 4 двери, ломать, рулевое колесо и т. д. … поэтому каждый использует этот дизайн, должен включать в себя эти характеристики. Реализация не является главой каждой абстракции. Он просто определит характеристики, которые должны быть включены.

Инкапсуляция достигается с сохранением данных и поведения в одной капсуле, которая является classом, и используя модификаторы доступа, такие как public, private, protected, а также наследование, агрегацию или состав. Таким образом, вы показываете только нужные вещи, это тоже, только в той степени, в которой вы хотите показать. т.е. общественный, защищенный, дружественный и частный ka funda …… например, GM решает использовать абстрактный дизайн автомобиля выше. Но у них есть разные продукты с одинаковыми характеристиками и почти одинаковые функциональные возможности. Поэтому они пишут class, который расширяет приведенный выше абстрактный class. В нем говорится, как должна работать коробка передач, как должен работать разрыв, как должно работать рулевое колесо. Тогда все продукты просто используют эту общую функциональность. Им не нужно знать, как работает коробка передач или разорвать работы или рулевые работы. Индивидуализированный продукт, безусловно, может иметь больше функций, таких как a / c или auto lock и т. Д. …

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

Абстракция — Скрытие реализации – при дизайне — Использование интерфейса / Абстрактные калсы

Инкапсуляция – скрытие данных – разработка – использование модификаторов доступа (общедоступных / частных)

Давайте возьмем пример стека. Он может быть реализован с использованием массива или связанного списка. Но операции, которые он поддерживает, являются push и pop. Теперь абстракция демонстрирует только интерфейсы push и pop. Основное представление скрыто (это массив или это связанный список?) И четко определенный интерфейс. Now how do you ensure that no accidental access is made to the abstracted data? That is where the Encapsulation comes in. For eg classes in C++ use the access specifiers which ensure that accidental access and modification is prevented. And also by making the above mentioned interfaces as public, it ensures that the only way to manipulate the stack is through the well defined interface. In the process, it has coupled the data and the code that can manipulate it. ( Lets not get the friend functions involved here.). That is the code and data are bonded together or tied or encapsulated

Из этого

Difference between Encapsulation and Abstraction in OOPS

Abstraction and Encapsulation are two important Object Oriented Programming (OOPS) concepts. Encapsulation and Abstraction both are interrelated terms.

Real Life Difference Between Encapsulation and Abstraction

Encapsulate means to hide. Encapsulation is also called data hiding.You can think Encapsulation like a capsule (medicine tablet) which hides medicine inside it. Encapsulation is wrapping, just hiding properties and methods. Encapsulation is used for hide the code and data in a single unit to protect the data from the outside the world. Class is the best example of encapsulation.

Abstraction refers to showing only the necessary details to the intended user. As the name suggests, abstraction is the “abstract form of anything”. We use abstraction in programming languages to make abstract class. Abstract class represents abstract view of methods and properties of class.

Implementation Difference Between Encapsulation and Abstraction

1. Abstraction is implemented using interface and abstract class while Encapsulation is implemented using private and protected access modifier.

2. OOPS makes use of encapsulation to enforce the integrity of a type (ie to make sure data is used in an appropriate manner) by preventing programmers from accessing data in a non-intended manner. Through encapsulation, only a predetermined group of functions can access the data. The collective term for datatypes and operations (methods) bundled together with access restrictions (public/private, etc.) is a class.

I will try to demonstrate Encapsulation in a simple way.. Lets see..

• The wrapping up of data and functions into a single unit (called class) is known as encapsulation. Encapsulation containing and hiding information about an object, such as internal data structures and code.

Encapsulation is –

• Hiding Complexity,
• Binding Data and Function together,
• Making Complicated Method’s Private,
• Making Instance Variable’s Private,
• Hiding Unnecessary Data and Functions from End User.

Encapsulation implements Abstraction.

And Abstraction is –

• Showing Whats Necessary,
• Data needs to abstract from End User,

Lets see an example-

The below Image shows a GUI of “Customer Details to be ADD-ed into a Database”.

By looking at the Image we can say that we need a Customer Class.

Step – 1: What does my Customer Class needs?

т.е.

• 2 variables to store Customer Code and Customer Name.

• 1 Function to Add the Customer Code and Customer Name into Database.

  namespace CustomerContent { public class Customer { public string CustomerCode = “”; public string CustomerName = “”; public void ADD() { //my DB code will go here }

Now only ADD method wont work here alone.

Step -2: How will the validation work, ADD Function act?

We will need Database Connection code and Validation Code (Extra Methods).

 public bool Validate() { //Granular Customer Code and Name return true; } public bool CreateDBObject() { //DB Connection Code return true; } class Program { static void main(String[] args) { CustomerComponent.Customer obj = new CustomerComponent.Customer; obj.CustomerCode = "s001"; obj.CustomerName = "Mac"; obj.Validate(); obj.CreateDBObject(); obj.ADD(); } } 

Now there is no need of showing the Extra Methods(Validate(); CreateDBObject() [Complicated and Extra method] ) to the End User.End user only needs to see and know about Customer Code, Customer Name and ADD button which will ADD the record.. End User doesn’t care about HOW it will ADD the Data to Database?.

Step -3: Private the extra and complicated methods which doesn’t involves End User’s Interaction.

So making those Complicated and Extra method as Private instead Public(ie Hiding those methods) and deleting the obj.Validate(); obj.CreateDBObject(); from main in class Program we achieve Encapsulation.

In other words Simplifying Interface to End User is Encapsulation.

So now the code looks like as below –

 namespace CustomerContent { public class Customer { public string CustomerCode = ""; public string CustomerName = ""; public void ADD() { //my DB code will go here } private bool Validate() { //Granular Customer Code and Name return true; } private bool CreateDBObject() { //DB Connection Code return true; } class Program { static void main(String[] args) { CustomerComponent.Customer obj = new CustomerComponent.Customer; obj.CustomerCode = "s001"; obj.CustomerName = "Mac"; obj.ADD(); } } 

Summary :

Step -1: What does my Customer Class needs? is Abstraction.

Step -3: Step -3: Private the extra and complicated methods which doesn’t involves End User’s Interaction is Encapsulation.

PS – The code above is hard and fast.

The below paragraph helped me to understand how they differ from each other:

Data encapsulation is a mechanism of bundling the data, and the functions that use them and data abstraction is a mechanism of exposing only the interfaces and hiding the implementation details from the user.

Вы можете прочитать больше здесь .

Information hiding is not strictly required for abstraction or encapsulation. Information might be ignored, but does not have to be hidden.

Encapsulation is the ability to treat something as a single thing, even though it may be composed of many complex parts or ideas. For example, I can say that I’m sitting in a “chair” rather than referring to the many various parts of that chair each with a specific design and function, all fitting together precisely for the purpose of comfortably holding my butt a few feet away from the floor.

Abstraction is enabled by encapsulation. Because we encapsulate objects, we can think about them as things which relate to each other in some way rather than getting bogged down in the subtle details of internal object structure. Abstraction is the ability to consider the bigger picture, removed from concern over little details. The root of the word is abstract as in the summary that appears at the top of a scholarly paper, not abstract as in a class which can only be instantiated as a derived subclass.

I can honestly say that when I plop my butt down in my chair, I never think about how the structure of that chair will catch and hold my weight. It’s a decent enough chair that I don’t have to worry about those details. So I can turn my attention toward my computer. And again, I don’t think about the component parts of my computer. I’m just looking at a part of a webpage that represents a text area that I can type in, and I’m communicating in words, barely even thinking about how my fingers always find the right letters so quickly on the keyboard, and how the connection is ultimately made between tapping these keys and posting to this forum. This is the great power of abstraction. Because the lower levels of the system can be trusted to work with consistency and precision, we have attention to spare for greater work.

Encapsulation (Binding data and Code)

• Encapsulation is the mechanism that binds together code and the data it manipulates, and keeps both safe from outside interference and misuse.

• In an object-oriented language, code and data may be combined in such a way that a self-contained “black box” is created. When code and data are linked together in this fashion, an object is created. In other words, an object is the device that supports encapsulation.

• Encapsulation leads to the concept of data hiding, but the concept of encapsulation must not be restricted to information hiding.

• Encapsulation clearly represents the ability to bundle related data and functionality within a single, autonomous entity called a class.

Abstraction (Hiding how data stored and Hiding how function is implemented)

• Data abstraction is a process of representing the essential features without including implementation details.

• Abstraction is one of the most powerful and vital features provided by object-oriented programming.

• The main idea behind data abstraction is to give a clear separation between properties of data type and the associated implementation details. This separation is achieved in order that the properties of the abstract data type are visible to the user interface and the implementation details are hidden.

• Abstraction is separating the logical properties from implementation details. For example driving the car is a logical property and design of the engine is the implementation detail.

 class Aeroplane : IFlyable, IFuelable, IMachine { // Aeroplane's Design says: // Aeroplane is a flying object // Aeroplane can be fueled // Aeroplane is a Machine } // But the code related to Pilot, or Driver of Aeroplane is not bothered // about Machine or Fuel. Hence, // pilot code: IFlyable flyingObj = new Aeroplane(); flyingObj.Fly(); // fighter Pilot related code IFlyable flyingObj2 = new FighterAeroplane(); flyingObj2.Fly(); // UFO related code IFlyable ufoObj = new UFO(); ufoObj.Fly(); // **All the 3 Above codes are genaralized using IFlyable, // Interface Abstraction** // Fly related code knows how to fly, irrespective of the type of // flying object they are. // Similarly, Fuel related code: // Fueling an Aeroplane IFuelable fuelableObj = new Aeroplane(); fuelableObj.FillFuel(); // Fueling a Car IFuelable fuelableObj2 = new Car(); // class Car : IFuelable { } fuelableObj2.FillFuel(); // ** Fueling code does not need know what kind of vehicle it is, so far // as it can Fill Fuel** 

abstraction is hiding non useful data from users and encapsulation is bind together data into a capsule (a class). I think encapsulation is way that we achieve abstraction.

The process of Abstraction and Encapsulation both generate interfaces.

An interface generated via encapsulation hides implementation details.

An interface generated via abstraction becomes applicable to more data types, compared to before abstraction.

Abstraction is a contract for the implementation we are going to do. Implementation may get changed over period of time. The various implementations themselves may or may not be hidden but are Masked behind the Abstraction.

Suppose we define all the APIs of a class in an interface then ask the users of our code to depened upon the defined APIs of the interface . We are free to improve or modify the implementation only we must follow the set contract. The users are not coupled with our implementation.

We EXPOSE all the NECESSARY Rules (methods) in abstraction , the implementation of the rules are left for the implementor entities, also the implemention is not part of the abstraction. Its just the signature and declaration what makes the abstraction.

Encapsulation is simply HIDING the internal details by reducing the acess of the states and behaviors. An encapsulated class may or may not have well defined Abstraction .

java.util.List is an abstraction for java.util.ArrayList . The internal states of java.util.ArrayList being marked with non public access modifiers is encapsulation.

Edit Suppose a class Container.nava implements IContainer , IContainer may declare methods like addElement , removeElements , contains , etc. Here IContainer represents the abstraction for its implementing class. Abstraction is declaring the APIs of the class or a module or a system to the outer world. These APIs become the contract . That system may be or may not be developed yet. The users of the system now can depend on the declared APIs and are sure any system implementing such a contract will always adhere to the APIs declared, they will always provide tge implementation for those APIs. Once we are writing some concrete entity then deciding to hide our internal states is encapsulation

One could argue that abstraction is a technique that helps us identify which specific information should be visible, and which information should be hidden. Encapsulation is then the technique for packaging the information in such a way as to hide what should be hidden, and make visible what is intended to be visible.