Яка точна різниця між інкапсуляцією та абстракцією?

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

• Кожна функція - це капсулювання ; у псевдокоді:

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

  Тут distanceінкапсулює обчислення (евклідової) відстані між двома точками в площині: вона приховує деталі реалізації. Це капсулювання, чисте і просте.

• Абстракція - це процес узагальнення : прийняття конкретної реалізації та надання її застосуванню до різних, хоча й дещо пов’язаних типів даних. Класичним прикладом абстрагування єqsortфункціяСдля сортування даних:

  Справа в тому qsort, що це не хвилює даних, які вони сортують - насправді він не знає, за якими даними він сортує. Скоріше, його вхідний тип - це безтиповий покажчик ( void*), який є лише способом С сказати: «Мені не важливо тип даних» (це також називається стиранням типу). Важливим моментом є те, що реалізація qsortзавжди залишається однаковою, незалежно від типу даних. Єдине , що має для зміни є функцією порівняння, яка відрізняється від типу даних типу даних. qsortтому очікує, що користувач надасть цю функцію порівняння як аргумент функції.

Інкапсуляція та абстракція йдуть рука об руку настільки, що ви можете зробити так, що вони справді нероздільні. Для практичних цілей це, мабуть, правда; що сказав, ось інкапсуляція, яка не є великою кількістю абстракції:

class point {
    numeric x
    numeric y
}

Ми інкапсулюємо координати точки, але не відкладаємо їх істотно, виходячи за логічну групування.

Ось приклад абстракції, яка не є капсулою:

T pi<T> = 3.1415926535

Це загальна змінна pi з заданим значенням (π), і декларація не стосується точного типу змінної. Правда, мені було б важко знайти щось подібне в реальному коді: абстракція практично завжди використовує інкапсуляцію. Тим НЕ менше, вище чи на самому справі існує в C ++ (14), з допомогою змінних шаблонів (= родових шаблонів для змінних); з дещо складнішим синтаксисом, наприклад:

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

Інкапсуляція приховує деталі реалізації, які можуть бути, а можуть бути, не для загальної або спеціалізованої поведінки.

Абстракція - це узагальнення (скажімо, над набором поведінки).

Ось хороше прочитання: Абстракція, інкапсуляція та приховування інформації Едварда В. Берара з Агентства об’єктів.

Багато відповідей та їхні приклади вводять в оману.

Інкапсуляція - це упаковка даних і функцій, що працюють над цими даними, в єдиний компонент і обмеження доступу до деяких компонентів об'єкта.
Інкапсуляція означає, що внутрішнє подання об'єкта, як правило, приховано від виду поза визначенням об'єкта.

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

Інкапсуляція: - приховування інформації .
Абстракція: - Приховування реалізації .

Приклад:

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прихована. -> Абстракція.

інкапсуляція кладе деякі речі в коробку і дає вам вигляд; це не дає вам спілкуватися з передачами.

вирівнювання абстракції ігнорує деталі, які не мають значення, як, наприклад, у речей є шестерні, храповики, маховики або ядерні сердечники; вони просто "йдуть"

приклади капсулювання:

• труси
• панель інструментів
• гаманець
• сумочка
• капсула
• заморожений карбоніт
• коробка, на ній кнопка або без неї
• буріто (технічно - тортилья навколо буріто)

приклади абстракції:

• "групи речей" - це абстракція (яку ми називаємо сукупністю)
• "речі, що містять інші речі" - це абстракція (яку ми називаємо композицією)
• "контейнер" - це інший вид абстракції "речей, які містять інші речі"; зауважте, що всі приклади інкапсуляції - це види контейнерів, але не всі контейнери демонструють / надають інкапсуляцію. Кошик, наприклад, є контейнером, який не інкапсулює його вміст.

Інкапсуляція означає приховування даних, таких як використання геттера та сетера тощо.

Абстракція означає приховування реалізації за допомогою абстрактних класів та інтерфейсів тощо.

Абстракція - це узагальнений термін. тобто інкапсуляція є підмножиною абстракції.

• Приклад 2:
  Архітектор рішення - це людина, яка створює високий рівень абстрактного технічного дизайну всього рішення, і ця конструкція потім передається команді розробників для впровадження .

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

• Приклад 3: Інкапсуляція (мережа) даних користувачів

Люб'язно

Абстракція (або модульність) - типи дозволяють програмістам мислити на більш високому рівні, ніж біт або байт, не переймаючись реалізацією на низькому рівні. Наприклад, програмісти можуть почати розглядати рядок як набір символьних значень, а не як просто масив байтів. Тим більше, що типи дозволяють програмістам думати і виражати інтерфейси між двома підсистемами будь-якого розміру. Це дозволяє отримати більше рівнів локалізації, щоб визначення, необхідні для сумісності підсистем, залишалися послідовними, коли ці дві підсистеми спілкуються. Джерело

Наведено багато хороших відповідей, але я збираюся представити тут свою (Java) точку зору.

Інкапсуляція даних просто означає обгортання та контроль доступу до логічно згрупованих даних у класі. Це, як правило, асоціюється з іншим ключовим словом - « Сховання даних» . Це досягається в Java за допомогою модифікаторів доступу .

Простим прикладом може бути визначення приватної змінної та надання доступу до неї за допомогою методів getter та setter або зробити метод приватним, оскільки його використовують лише withing the class. Користувач не повинен знати про ці методи та змінні.

Примітка . Не слід неправильно розуміти, що інкапсуляція стосується лише приховування даних. Коли ми говоримо про інкапсуляцію, акцент слід робити на групуванні або упаковці або з’єднанні даних та поведінки, пов’язаних із цим.

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

Приклад -

Скажімо, у нас є інтерфейс Animal і він має функцію makeSound () . Є два конкретні класи Dog and Cat, які реалізують цей інтерфейс. Ці конкретні класи мають окремі реалізації функції makeSound (). Тепер скажемо, що у нас є тварина (ми отримуємо це з якогось зовнішнього модуля). Всім користувачеві відомо, що об'єкт, який він отримує, - це якась тварина, а друк - звук тварин. Один перебір спосіб це перевірити об'єкт отримав для ідентифікації його типу, а потім надрукований нього до цього типу тварин , а потім називають makeSound () на ньому. Але більш охайний спосіб - це витягнути щось з реферату . Використовуйте тварин якполіморфна посилання та виклик makeSound () на ній. Під час виконання, залежно від того, який реальний тип об'єкта є належним, буде викликана функція.

Детальніше тут .

Складна логіка полягає в друкованій платі, яка інкапсульована в тачпад, і надається приємний інтерфейс (кнопки), щоб її абстрагувати користувачеві.

PS: Наведені вище посилання на мій особистий блог.

• Абстракція дозволяє зосередитись на тому, що робить об’єкт, а не на тому, як він це робить
• Інкапсуляція означає приховувати внутрішні деталі або механіку того, як об’єкт щось робить.

Як і коли ви їдете на машині, ви знаєте, що робить педаль газу, але ви, можливо, не знаєте процесу за нею, оскільки він інкапсульований.

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

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

ви можете скористатися таким методом, як Number.ToString (), який повертає вам представлення символів числа 5 та зберігає його у рядковому об'єкті. Метод повідомляє вам, що він робить замість того, як це робить.

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

Коротка відповідь

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

Абстракція - розглядаючи щось із певними вилученими характеристиками, крім конкретних реальностей, конкретних об'єктів чи фактичних екземплярів, тим самим зменшуючи складність.

Основна схожість полягає в тому, що ці методи спрямовані на покращення розуміння та корисності.

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

Довга відповідь

Інкапсуляція

Ось приклад інкапсуляції, який, сподіваємось, робить речі більш зрозумілими:

Тут у нас є 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-коду. Він по суті забирає всі конкретні для платформи компоненти системи та забезпечує абстрактний інтерфейс "комп'ютера" без огляду на будь-яку систему зокрема.

Різниця

Інкапсуляція відрізняється від абстракції тим, що вона не має нічого спільного з тим, наскільки щось справжнє або «точне». Це не видаляє компоненти чогось, щоб зробити його більш простим або широким застосуванням. Швидше, можливо, приховати певні компоненти для досягнення подібної мети.

Інкапсуляція : приховує небажані / не очікувані / втілені деталі реалізації від фактичних користувачів об'єкта. напр

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'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**

Різниця між абстракцією та інкапсуляцією.

Абстракція: Ідея представляти щось спрощеним / іншим способом, який або простіший для розуміння та використання, або більше стосується ситуації.

Розглянемо клас, який надсилає електронний лист ... він використовує абстракцію, щоб показати себе як певного хлопця-посланця, тож ви можете зателефонувати на emailSender.send (пошта, одержувач). Що він насправді робить - вибирає POP3 / SMTP, виклику серверів, MIME-трансляцію тощо. Ви бачите лише свого хлопця-посланця.

Інкапсуляція: ідея закріплення та приховування даних та методів, які є приватними для об'єкта. Він більше стосується створення чогось незалежного і безглуздого.

Візьміть мене, наприклад. Я інкапсулюю серцебиття від решти світу. Тому що я не хочу, щоб хтось міняв цю змінну, і мені не потрібно, щоб хтось інший встановлював її для того, щоб я функціонував. Для мене це життєво важливо, але вам не потрібно знати, що це таке, і ви, ймовірно, все одно не байдуже.

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

Все це робить світ приємнішим місцем для проживання: D

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

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

Інкапсуляція: Мається на увазі приховування конфіденційних даних класу, отже, приватизуючи його частину. Це спосіб зберігати певну інформацію приватною для своїх клієнтів, не допускаючи доступу до неї ззовні.

Ще один приклад:

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

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_;
}

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

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

Прикладом хорошої абстракції є загальний клас підключення до бази даних. Його загальнодоступний інтерфейс є агностично-бази даних, і він дуже простий, але дозволяє мені робити те, що я хочу з підключенням. А ти бачиш? Там також є інкапсуляція, тому що в класі повинні бути всі низькорівневі ручки та дзвінки всередині.

Abstractionі Encapsulationза допомогою єдиного узагальненого прикладу

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

Всі ми використовуємо калькулятор для розрахунку складних задач!

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

Акт представлення істотних ознак без включення довідкових деталей чи пояснень відомий як абстракція

Абстракція: абстракція означає показати 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);
    }
}

Візьмемо для прикладу стек. Він може бути реалізований за допомогою масиву або пов'язаного списку. Але операції, які він підтримує, - це push і pop.

Тепер абстракція виявляє лише інтерфейси push і pop. Основне представлення приховане (це масив чи пов'язаний список?) Та надається чітко визначений інтерфейс. Тепер як ви гарантуєте, що до абстрагованих даних не робиться випадковий доступ? Ось де відбувається інкапсуляція . Наприклад, класи на C ++ використовують специфікатори доступу, які забезпечують запобігання випадкового доступу та модифікації. А також, роблячи вищезазначені інтерфейси публічними, це забезпечує єдиний спосіб маніпулювати стеком через чітко визначений інтерфейс. У цьому процесі він з'єднав дані та код, який може ними маніпулювати (не давайте тут брати участь функції друзів). Тобто код і дані скріплюються разом або зав'язуються або інкапсулюються.

Інкапсуляція - це завершення складності в одній капсулі, яка є класом і, отже, інкапсуляція ... У той час як абстракція - це характеристики об'єкта, які відрізняються від інших об'єктів ...

Абстрагування можна досягти, зробивши клас абстрактним, що має один або кілька методів абстрактних. Що є не що інше, як характеристика, яку повинен реалізувати клас, що розширює його. Наприклад, коли вигадуєте / проектуєте автомобіль, ви визначаєте такі характеристики, як автомобіль повинен мати 4 двері, розрив, кермо тощо тощо, тому кожен, хто використовує цю конструкцію, повинен включати ці характеристики. Виконання не є головою кожної абстракції. Він просто визначить характеристики, які слід включити.

Інкапсуляція досягається збереженням даних та поведінки в одній капсулі, яка є класовою, використовуючи модифікатори доступу, такі як громадські, приватні, захищені разом із спадщиною, агрегацією чи складом. Тож ви показуєте лише потрібні речі, і це лише в тій мірі, яку ви хочете показати. тобто громадська, захищена, доброзичлива та приватна фундація ……. напр. GM вирішує використати абстраговану конструкцію автомобіля вище. Але у них є різні продукти, що мають однакові характеристики та працюють практично однаково. Так вони пишуть клас, який розширює вищевказаний абстрактний клас. У ньому йдеться про те, як повинна працювати коробка передач, як повинна працювати перерва, як має працювати кермо. Тоді всі продукти просто використовують цю загальну функціональність. Їм не потрібно знати, як працює коробка передач або спрацьовує обрив або працює рульове колесо.

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

Абстракція --- Приховування реалізації - на дизайні --- Використання інтерфейсу / Абстрактні посилання

Інкапсуляція - Приховування даних - Розвиток --- Використання модифікаторів доступу (державних / приватних)

З цього

Різниця між інкапсуляцією та абстракцією в OOPS

Абстракція та інкапсуляція - дві важливі концепції об'єктно-орієнтованого програмування (OOPS). Інкапсуляція, і абстракція є взаємопов'язаними термінами.

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

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

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

Різниця в реалізації між інкапсуляцією та абстракцією

1. Абстракція реалізується за допомогою інтерфейсу та абстрактного класу, тоді як інкапсуляція реалізується за допомогою приватного та захищеного модифікатора доступу.

2. OOPS використовує інкапсуляцію, щоб забезпечити цілісність типу (тобто, щоб переконатися, що дані використовуються належним чином), не дозволяючи програмістам отримувати доступ до даних не за призначенням. За допомогою інкапсуляції доступ до даних може отримати лише заздалегідь визначена група функцій. Колективний термін для типів даних та операцій (методів), що поєднуються з обмеженнями доступу (публічний / приватний тощо), є класом.

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

• Зведення даних і функцій в єдиний блок (який називається класом) відомий як інкапсуляція. Інкапсуляція, що містить та приховує інформацію про об'єкт, наприклад внутрішні структури даних та код.

Інкапсуляція -

• Приховування складності,
• Зв'язування даних та функцій разом,
• Зробити складний метод приватним,
• Зробити примірник змінної приватним
• Приховування непотрібних даних та функцій від кінцевого користувача.

Інкапсуляція реалізує Абстракцію.

А абстракція -

• Показуючи, що потрібно,
• Дані потрібно абстрагувати від Кінцевого користувача,

Давайте подивимось приклад-

На зображенні нижче показано графічний інтерфейс користувача "Інформація про клієнта, яку потрібно додати в базу даних".

Переглядаючи Зображення, ми можемо сказати, що нам потрібен клас клієнтів.

Крок - 1: Для чого потрібен мій клас клієнтів?

тобто

• 2 змінні для зберігання коду клієнта та імені клієнта.

• 1 Функція додавання коду клієнта та імені клієнта до бази даних.

  простір імен CustomerContent {Клієнт публічного класу {public string CustomerCode = ""; публічний рядок 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();
}
}

Тепер немає необхідності показу Кінцевому користувачеві додаткові методи (перевірити (); створитиDBObject () [Складний і додатковий метод]). Користувачеві потрібно лише бачити та знати про код клієнта, ім'я клієнта та кнопку "ДОПОМИТИ", яка додасть запис .. Кінцевому користувачеві не байдуже, як він додасть дані в базу даних ?.

Крок -3: Приватні додаткові та складні методи, що не передбачають взаємодії кінцевого користувача.

Таким чином, зробити цей складний та додатковий метод приватним, а не загальнодоступним (тобто приховати ці методи) та видалити 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: Приватні додаткові та складні методи, що не передбачають взаємодії кінцевого користувача, - це інкапсуляція.

PS - Код, наведений вище, важкий і швидкий.

Нижній абзац допоміг мені зрозуміти, чим вони відрізняються один від одного:

Інкапсуляція даних - це механізм зв’язування даних, а функції, що їх використовують, та абстрагування даних - це механізм розкриття лише інтерфейсів та приховування деталей реалізації від користувача.

Більше ви можете прочитати тут .

Приховування інформації не є строго необхідним для абстрагування чи інкапсуляції. Інформація може бути проігнорована, але не повинна її ховати.

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

Абстракція вмикається інкапсуляцією. Оскільки ми інкапсулюємо об'єкти, ми можемо думати про них як про речі, які якимось чином пов'язані один з одним, а не занурюючись у найтонші деталі внутрішньої структури об'єкта. Абстракція - це здатність розглянути більшу картину, усунуту від занепокоєння з приводу дрібних деталей.Корінь слова є абстрактним, як у резюме, який з’являється у верхній частині наукової статті, а не абстрактно, як у класі, який може бути використаний лише як похідний підклас.

Я чесно можу сказати, що коли я плескаю зад вниз на стільці, я ніколи не замислююся над тим, як структура цього стільця набере мою вагу. Це досить пристойний стілець, що мені не потрібно переживати за ці деталі. Тож я можу звернути свою увагу на свій комп’ютер. І знову: я не думаю про складові частини мого комп’ютера. Я просто дивлюся на частину веб-сторінки, яка представляє текстову область, яку я можу набрати, і спілкуюся словами, ледь навіть не замислюючись про те, як мої пальці завжди так швидко знаходять потрібні літери на клавіатурі, і як з'єднання в кінцевому рахунку здійснюється між натисканням цих клавіш і публікацією на цьому форумі. Це велика сила абстракції. Оскільки на нижчих рівнях системи можна довіряти роботу з послідовністю та точністю, ми маємо увагу приділити більше роботи.

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це договір на реалізацію, який ми збираємось робити. Впровадження може змінитися протягом певного періоду часу. Самі різні реалізації можуть бути, а можуть і не бути прихованими, але маскуються за абстракцією.

Припустимо, ми визначимо всі 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, вони завжди забезпечуватимуть реалізацію цих API. Як тільки ми пишемо якусь конкретну сутність, то вирішуємо приховати свої внутрішні стани - це інкапсуляція

Я думаю, що інкапсуляція - це спосіб здійснити абстракцію. Перегляньте наступне посилання.

Абстракція та інкапсуляція

Коротко

Використання абстракції -> Використання інкапсуляції та інкапсуляції -> приховування даних

АБО

приховування даних є підмножиною інкапсуляції, а інкапсуляція - підмножиною абстракції

Довідка: http://www.tonymarston.co.uk/php-mysql/abstraction.txt