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

Какова точная разница между инкапсуляцией и абстракцией?

Ответ 1

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

Каждая функция является encapsulation; в псевдокоде:
```
point x = { 1, 4 }
point y = { 23, 42 }

numeric d = distance(x, y)
```
Здесь distance инкапсулирует вычисление (евклидова) расстояния между двумя точками в плоскости: оно скрывает детали реализации. Это инкапсуляция, чистая и простая.
Abstraction - это процесс обобщения: принятие конкретной реализации и применение ее применительно к разные, хотя и несколько связанные, типы данных. Классическим примером абстракции является функция Cs qsort для сортировки данных:

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

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

class point {
    numeric x
    numeric y
}

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

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

T pi<T> = 3.1415926535

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

template <typename T> constexpr T pi = T{3.1415926535};

Ответ 2

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

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

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

Ответ 3

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

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

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

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

Пример:

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

        int add(){    
            return a+b;   
        } 
}

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

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

Реализация метода add скрыта. → Абстракция.

Ответ 4

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

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

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

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

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

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

Ответ 5

Encapsulation скрывает данные, такие как использование getter и setter и т.д.

Abstraction означает скрытие реализации с использованием абстрактного класса и интерфейсов и т.д.

Ответ 6

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

Пример 2:
Архитектор решения является человеком, который создает высокоуровневый абстрактный технический дизайн всего раствора, и этот проект затем передан команде развития для реализации.

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

учтивость

Ответ 7

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

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

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

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

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

Пример -

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

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

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

PS: выше ссылки на мой личный блог.

Ответ 8

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

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

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

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

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

Ответ 9

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

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

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

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

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

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

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

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

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

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

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

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

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

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

абстракция

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

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

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

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

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

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

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

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

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

JVM

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

Различия

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

Ответ 10

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

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

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

class Aeroplane : IFlyable, IFuelable, IMachine
{ // Aeroplane 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**

Ответ 11

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

Ответ 12

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

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

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

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

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

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

Ответ 13

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

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

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

Ответ 14

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

Предположим, что я создал неизменяемый класс 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_;
}

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

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

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

Ответ 15

`Abstraction` и `Encapsulation`, используя один обобщенный пример

-------------------------------------------- -------------------------------------------------- --------------------------------------

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

Ответ 16

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

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

Ответ 17

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

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

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

/// <summary>
/// We have an Employee class having two properties EmployeeName and EmployeeCode
/// </summary>
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);
    }
}

Ответ 18

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

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

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

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

Ответ 19

Давайте возьмем пример стека. Это может быть реализовано с использованием массива или связанного списка. Но операции, которые он поддерживает, являются push и pop.

Теперь абстракция выставляет только интерфейсы push и pop. Базовое представление скрыто (это массив или связанный список?) И предоставляется четко определенный интерфейс. Теперь, как вы обеспечиваете отсутствие случайного доступа к абстрагированным данным? Вот где начинается инкапсуляция. Например, классы в C++ используют спецификаторы доступа, которые обеспечивают предотвращение случайного доступа и изменения. А также, сделав вышеупомянутые интерфейсы общедоступными, это гарантирует, что единственный способ манипулировать стеком - через четко определенный интерфейс. В процессе он соединил данные и код, который может ими манипулировать (пусть здесь не задействованы функции друзей). То есть код и данные связаны вместе или связаны или инкапсулированы.

Ответ 20

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

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

Ответ 21

Из this

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

Абстракция и инкапсуляция - две важные концепции объектно-ориентированного программирования (OOPS). Инкапсуляция и абстракция являются взаимосвязанными терминами.

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

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

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

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

Абстракция реализована с использованием интерфейса и абстрактного класса, в то время как инкапсуляция реализована с использованием частного и защищенного модификатора доступа.
OOPS использует инкапсуляцию для обеспечения целостности типа (то есть, чтобы убедиться, что данные используются соответствующим образом), не позволяя программистам беспрепятственно обращаться к данным. Благодаря инкапсуляции доступ к данным может получить только определенная группа функций. Коллективный термин для типов данных и операций (методов), связанных с ограничениями доступа (public/private и т.д.), Является классом.

Ответ 22

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

Объединение данных и функций в один блок (называемый класс) известен как инкапсуляция. Инкапсуляция, содержащая и скрывающая информацию об объекте, такую как внутренние структуры данных и код.

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

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

Инкапсуляция реализует абстракцию.

И абстракция -

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

Давайте посмотрим пример -

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

Посмотрев на изображение, мы можем сказать, что нам нужен класс клиента.

Шаг - 1: что мне нужен класс клиента?

то есть.

2 переменных для хранения кода клиента и имени клиента.
1 Функция добавления кода клиента и имени клиента в базу данных.

пространство имен CustomerContent { клиент открытого класса { public string CustomerCode = ""; public string CustomerName = ""; public void ADD() { // мой код DB пойдет сюда }

Теперь только метод ADD не будет работать здесь один.

Шаг -2: Как будет работать валидация, действует функция ADD?

Нам понадобится код подключения к базе данных и код подтверждения (дополнительные методы).

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();
}
}

Теперь нет необходимости показывать конечным пользователям дополнительные методы (Validate(); CreateDBObject() [Сложный и дополнительный метод]). Пользователь должен только видеть и знать о кодах клиентов, имени клиента и кнопке ADD который ДОБАВЛЯЕТ запись. Конечный пользователь не заботится о том, КАК он ДОБАВЛЯЕТ данные в базу данных?.

Шаг -3: Привлеките дополнительные и сложные методы, которые не связаны с взаимодействием конечных пользователей.

Таким образом, использование метода Complicated и Extra Private как Private вместо Public (т.е. скрытие этих методов) и удаление объекта obj.Validate(); obj.CreateDBObject(); из основной в классе программы мы добиваемся инкапсуляции.

Другими словами, упрощение интерфейса для конечного пользователя - это инкапсуляция.

Итак, теперь код выглядит так:

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();
}
}

Сводка:

Шаг -1: Что требуется моему классу клиентов? Абстракция.

Шаг -3: Шаг -3: Частные дополнительные и сложные методы, которые не связаны с взаимодействием конечных пользователей, - это инкапсуляция.

P.S. - Сложный и быстрый код.

Ответ 23

Этот абзац помог мне понять, как они отличаются друг от друга:

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

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

Ответ 24

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

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

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

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

Ответ 25

Инкапсуляция (связывание данных и кода)

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

Абстракция (Скрытие того, как хранятся данные и Скрытие того, как реализована функция)

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

Ответ 26

class Aeroplane : IFlyable, IFuelable, IMachine
{ // Aeroplane 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**

Ответ 27

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

Ответ 28

Процесс абстракции и инкапсуляции генерирует интерфейсы.

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

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

Ответ 29

Abstraction - это контракт для реализации, которую мы собираемся сделать. Реализация может измениться с течением времени. Сами различные реализации могут быть или не быть скрытыми, но маскируются за абстракцией.

Предположим, что мы определяем все APIs класса в interface, а затем запрашиваем у пользователей нашего кода значение в APIs interface. Мы вольны улучшать или модифицировать реализацию, мы должны следовать установленному контракту. Пользователи не связаны с нашей реализацией.

ЭКСПОЗИЦИЯ всех НЕОБХОДИМЫХ правил (методов) в абстракции, реализация правил остается для объектов-исполнителей, а реализация не является частью абстракции. Его просто подпись и декларация, что делает абстракцию.

Encapsulation просто СКРЫВАЕТ внутренние детали, уменьшая степень состояний и поведения. Инкапсулированный класс может иметь или не иметь четко определенного Abstraction.

java.util.List является абстракцией для java.util.ArrayList. Внутренние состояния java.util.ArrayList, помеченные с помощью модификаторов доступа non public, - это инкапсуляция.

Edit Предположим, что класс Container.nava implements IContainer, IContainer может объявлять методы типа addElement, removeElements, contains и т.д. Здесь IContainer представляет абстракцию для его реализующего класса. Абстракция объявляет API-интерфейс класса или модуля или системы внешнему миру. Эти API становятся contract. Эта система может быть или еще не разработана. Теперь пользователи системы могут зависеть от заявленных API и уверены, что любая система, реализующая такой контракт, всегда будет придерживаться объявленных API, они всегда будут предоставлять реализацию tge для этих API. Когда мы пишем какую-то конкретную сущность, тогда решение скрывать наши внутренние состояния - это инкапсуляция

Ответ 30

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