Ответ 1

Абстракция связана с отделением интерфейса от реализации. (Нам все равно, что это такое, мы заботимся о том, чтобы он работал определенным образом.)

Инкапсуляция связана с запретом доступа к внутренним структурам реализации или их знаний. (Нам все равно или нужно посмотреть, как это работает, только то, что он делает.)

Некоторые люди используют инкапсуляцию как синоним абстракции, который неверен (IMO). Возможно, ваш собеседник подумал об этом. Если это так, тогда вы говорили о двух разных вещах, когда вы ссылались на "инкапсуляцию".

Стоит отметить, что эти понятия представлены по-разному на разных языках программирования. Несколько примеров:

• В Java и С# интерфейсы (и, в некоторой степени, абстрактные классы) обеспечивают абстракцию, в то время как модификаторы доступа обеспечивают инкапсуляцию.
• В основном это одна и та же сделка на С++, за исключением того, что у нас нет интерфейсов, у нас есть только абстрактные классы.
• В JavaScript утиная печать обеспечивает абстракцию, а закрытие обеспечивает инкапсуляцию. (Соглашение об именовании также может обеспечивать инкапсуляцию, но это работает только в том случае, если все стороны согласятся следовать ей.)

Ответ 2

Простой!

Возьмите пример телевидения - это Инкапсуляция, потому что:

• Телевидение загружено различными функционалами, которые я не знаю, потому что они полностью скрыты.

• Скрытые вещи, такие как музыка, видео и т.д., все в комплекте в капсуле, что мы называем телевизор

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

Например: Пульт дистанционного управления для телевизора - это абстракция, потому что

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

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

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

Ответ 3

Абстрактные

Отображение объекта вместо данных объекта.

"Подробности есть, но мы их не рассматриваем. Они не требуются".

Пример 1:

Различные расчеты: Сложение, умножение, вычитание, разделение, квадрат, грех, кос, танец.

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

Пример 2:

Сотрудник имеет: Имя, фамилия, отчество. Он может Войти(), Выход(), DoWork().

Многие процессы могут происходить для входа в систему "Сотрудник" In, например, для подключения к базе данных, отправки идентификатора сотрудника и пароля, получения ответа от базы данных. Несмотря на наличие более подробной информации, мы скроем детали и выставим только "Сотрудник".

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

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

"Подробности есть, мы их рассматриваем, но не показываем их, вместо этого мы показываем, что вам нужно видеть".

Пример 1:

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

Пример 2:

Все характеристики и операции теперь передаются сотрудником, таким как "Джон". У Джона есть имя. John Can DoWork(). Джон может Войти().

Скрытие

Скрытие реализации из внешнего мира. Так что внешний мир не увидит, что не следует видеть.

"Подробности есть, мы их рассматриваем, но мы их не показываем. Вам не нужно их видеть".

Пример 1:

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

Вам не нужно знать, где хранятся операнды. Это не ваше требование.

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

Пример 2:

Джон хотел бы знать его процент посещаемости. Так будет вызываться GetAttendancePercentage().

Однако для этого метода нужны данные, сохраненные в базе данных. Следовательно, он будет вызывать FetchDataFromDB(). FetchDataFromDB() НЕ требуется быть видимым для внешнего мира.

Следовательно, мы скроем его. Однако John.GetAttendancePercentage() будет видимым для внешнего мира.

Абстракция, инкапсуляция и скрытие дополняют друг друга.

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

Ответ 4

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

Абстрактные

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

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

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

Ответ 5

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

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

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

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

Инкапсуляция помогает скрыть реализацию за интерфейсом.

Абстрактные

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

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

Наконец, выражение, чтобы ответить на все путаницы до сих пор - Часть, которая скрыта, относится к инкапсуляции, а часть, которая экспонируется, относится к абстракции.

Подробнее об этом здесь

Ответ 6

Абстракция: Абстракция - это процесс, в котором вы собираете или собираете релевантные данные и удаляете ненужные данные. (И если вы достигли абстракции, то также достигается инкапсуляция.)

Инкапсуляция: Инкапсуляция - это процесс, в котором вы обертываете функции и элементы в одном блоке. Средства. Вы скрываете детали реализации. Значит, пользователь может получить доступ, создав объект класса, он/она не может видеть детали.

Пример:

 public class Test
   {
    int t;
    string  s;
 public void show()
  {
   s = "Testing";
   Console.WriteLine(s);
   Console.WriteLine(See()); // No error
  }

 int See()
  {
   t = 10;
   return t;
  }

 public static void Main()
  {
  Test obj =  new Test();
  obj.Show(); // there is no error
  obj.See(); // Error:- Inaccessible due to its protection level
  }
 }

В приведенном выше примере пользователь может получить доступ только к методу Show(), используя obj, то есть Abstraction.

И метод See() вызывает внутренне метод Show(), который является инкапсуляцией, потому что пользователь не знает, что происходит в методе Show().

Ответ 7

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

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

Таким образом, мы определяем инкапсуляцию как обертку данных и методов в единый объект, называемый классом.

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

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

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

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

Ответ 8

Инкапсуляция: Предположим, у меня есть конфиденциальные документы, теперь я скрываю эти документы внутри шкафчика, поэтому никто не может получить к ним доступ, это инкапсуляция.

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

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

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

Ответ 9

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

Инкапсуляция: скрытие внутренних объектов. Объект - это абстракция реального мира. Но детали этого объекта (например, структуры данных...) могут быть скрыты посредством инкапсуляции.

Ответ 10

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

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

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

1.Абстракция фокусируется на внешнем виде объекта (т.е. интерфейса). Инкапсуляция (скрытие информации) не позволяет клиентам видеть внутренний вид, где реализовано поведение абстракции.

2.Abstraction решает проблему на стороне дизайна, в то время как инкапсуляция - это реализация.

3. Инкапсуляция - это результат абстракции. Инкапсуляция почти не говорит о группировке вашей абстракции в соответствии с потребностями разработчиков.

Ответ 11

АБСТРАКЦИЯ: "Взгляд на проблему, которая извлекает существенную информацию   относящихся к определенной цели, и игнорирует оставшуюся часть   информации". [IEEE, 1983]

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

Ответ 12

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

Ответ 13

Мое мнение об абстракции заключается не в том, чтобы скрывать информацию об осуществлении, либо о деталях фона!

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

Для меня самое важное для абстракции:

• сокращение сложности
• уменьшение размера/количества
• расщепление не связанных между собой доменов на понятные и независимые компоненты

Все это для меня не имеет ничего общего со скрытыми деталями фона!

Если вы думаете о сортировке некоторых данных, абстракция может привести к:

• алгоритм сортировки, который не зависит от представления данных
• функция сравнения, которая не зависит от алгоритма данных и сортировки
• общее представление данных, которое не зависит от используемых алгоритмов

Все это не имеет никакого отношения к сокрытию информации.

Ответ 14

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

Ответ 15

Разработчик A, который по своей сути использует концепцию абстракции, будет использовать модуль/библиотечную функцию/виджет, касающийся только того, что он делает (и для чего он будет использоваться), но не как его Имеет ли это. Интерфейс этого модуля/библиотечной функции/виджета ( "рычаги", которые разработчик А разрешает тянуть/нажимать) является олицетворением этой абстракции.

Разработчик B, который стремится создать такой модуль/функцию/виджет, использует концепцию инкапсуляции, чтобы гарантировать, что Developer A (и любой другой разработчик, который использует виджет) может воспользоваться преимуществами в результате абстракция. Разработчик B, безусловно, обеспокоен тем, как виджет делает то, что он делает.

TL;DR;

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

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

Ответ 16

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

Например, тезисы "Итератор" (ака обобщения) чередуются с обходом 0 или более значений - в С++ он проявляется как begin(), */-> (разыменование), end(), pre/post ++ и, возможно, --, тогда +, +=, [], std::advance и т.д. Это много багажа, если клиент может сказать приращение a size_t по массиву в любом случае. Существенно, что абстракция позволяет клиентскому коду, который должен выполнить такой обход, быть отделенным от точной природы "контейнера" или источника данных, предоставляющего элементы. Итерация - это понятие более высокого уровня, которое иногда ограничивает способ обхода (например, прямой итератор может только продвигать элемент за раз), но тогда данные могут быть предоставлены большим набором источников (например, с клавиатуры, где там даже не "контейнер" в смысле одновременно сохраненных значений). Клиентский код обычно может переключиться на другой источник данных, абстрагированный через свои собственные итераторы с минимальными или даже никакими изменениями и даже полиморфно с другими типами данных - либо неявно, либо явно используя что-то вроде std::iterator_traits<Iterator>::value_type.

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

Чтобы еще раз подчеркнуть разницу, рассмотрите, например, элемент данных private std::vector<Timing_Sample>, который случайно заполнен операциями над содержащим объектом, с отложенным оттуда при уничтожении. Поскольку побочные эффекты данных и деструктора не взаимодействуют с кодом объекта-объекта каким-либо образом, а операции над объектом, которые не преднамеренно контролируют поведение во времени, не содержат абстракции функциональности отчетности времени, а есть инкапсуляция. Примером абстракции может быть переход кода синхронизации в отдельный класс, который может инкапсулировать vector (сделать его private) и просто предоставить интерфейс типа add(const Timing_Sample&) и report(std::ostream&) - необходимые логические/абстрактные операции с использованием такого инструментария, с очень желательным побочным эффектом, что абстрагированный код часто может использоваться повторно для другого клиентского кода с аналогичными функциональными потребностями.

Ответ 17

По-моему, оба термина связаны в некотором смысле и смешаны друг с другом. "Инкапсуляция" предоставляет способ группировки связанных полей, методов в классе (или модуле) для объединения связанных вещей. С этого времени он обеспечивает скрытие данных двумя способами:

• Через модификаторы доступа.

  Чисто для скрытия состояния класса/объекта.

• Абстрактные функции.

  а. Через интерфейсы/абстрактные классы сложная логика внутри инкапсулированного класса или модуля может быть абстрагирована/обобщена для использования снаружи.

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

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

Ответ 18

Что касается iOS, можно сказать, что файлы Objective C (т.е..h и .m) используют абстракцию, а также инкапсуляцию.

Абстрактные

Заголовочный файл (.h) предоставляет только функции и публичные элементы для внешнего мира. Никто не знает, как они используются, если у них нет файла реализации. Это файл .m содержит всю логику использования и реализации с ним. "Реализация остается неэкспонированной".

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

Свойство (@property) инкапсулирует атрибут управления памятью (атомный, сильный, сохраняющий, слабый) iVar.

Ответ 19

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

Ответ 20

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

1.) Скрытие и защита данных (пользователь вашего класса не может изменять данные, кроме предоставляемых вами методов).

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

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

Ответ 21

Абстракция: сокрытие данных. Инкапсуляция: связывание данных.

Ответ 22

Почему инкапсуляция? Почему абстракция?

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

1) Что произойдет, если мы позволим коду получить прямой доступ к полю? (прямое разрешение означает обнародование поля)

давайте разберемся с этим на примере,

following is our BankAccount class and following is its limitation
*Limitation/Policy* : Balance in BankAccount can not be more than 50000Rs. (This line 
 is very important to understand)

class BankAccount
{
   **public** double balanceAmount;
}

Following is **AccountHolder**(user of BankAccount) class which is consumer of 
**BankAccount** class.

class AccountHolder
{
   BankAccount mybankAccount = new BankAccount();

   DoAmountCreditInBankAccount()
   {
       mybankAccount.balanceAmount = 70000; 
      /* 
       this is invalid practice because this statement violates policy....Here 
       BankAccount class is not able to protect its field from direct access
       Reason for direct access by acount holder is that balanceAmount directly 
       accessible due to its public access modifier. How to solve this issue and 
       successfully implement BankAccount Policy/Limitation. 
      */
   }
}

если какая-то другая часть кода напрямую обращается к полю balanceAmount и устанавливает сумму баланса в 70000Rs, что недопустимо. Здесь, в этом случае, мы не можем предотвратить доступ какой-либо другой части кода к полю balanceAmount.

Так что мы можем сделать?

=> Ответ: мы можем сделать поле balanceAmount приватным, чтобы никакой другой код не мог получить к нему прямой доступ и разрешить доступ к этому полю только через открытый метод, который работает с полем balanceAmount. Основная роль метода заключается в том, что мы можем написать некоторую логику предотвращения внутри метода, чтобы поле не могло быть инициализировано более чем с 50000R. Здесь мы устанавливаем связь между полем данных с именем balanceAmount и методом, который работает с этим полем. Этот процесс называется Encapsulation. (Все дело в защите полей с использованием модификатора доступа, такого как private)

Инкапсуляция является одним из способов достижения абстракции.... но как? => Пользователь этого метода не будет знать о реализации (как зачисляется сумма? Логика и все такое) метода, который он/она будет вызывать. Незнание деталей реализации пользователем называется абстракцией (скрытие деталей от пользователя).

Following will be the implementation of class:

class BankAccount
{
   **private** double balanceAmount;

   **public** void UpdateBankBalance(double amount)
   {
    if(balanceAmount + amount > 50000)
    {
       Console.WriteLine("Bank balance can not be more than 50000, Transaction can 
                          not be proceed");
    }
    else
    {
       balanceAmount = balanceAmount + amount;
           Console.WriteLine("Amount has been credited to your bank account 
                              successfully.....");
    }
   }
}


class AccountHolder
{
   BankAccount mybankAccount = new BankAccount();

   DoAmountCreditInBankAccount()
   {
      mybankAccount.UpdateBankBalance(some_amount);
      /*
       mybankAccount.balanceAmount will not be accessible due to its protection level 
       directly from AccountHolder so account holder will consume BankAccount public 
       method UpdateBankBalance(double amount) to update his/her balance.
      */
   }
}

Ответ 23

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