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

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

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

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

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

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

  Дело в том, 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 или создание метода private, поскольку он используется только внутри класса. Пользователю не нужно знать об этих методах и переменных.

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

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

Пример -

Допустим, у нас есть интерфейс Animal и функция makeSound () . Есть два конкретных класса Dog и Cat, которые реализуют этот интерфейс. Эти конкретные классы имеют отдельные реализации функции makeSound (). Теперь допустим, что у нас есть животное (мы получаем это из какого-то внешнего модуля). Все, что пользователь знает, это то, что объект, который он получает, является неким животным, и пользователь несет ответственность за печать звука животного. Один из способов грубой силы - проверить полученный объект, чтобы определить его тип, затем типизировать его к этому типу Animal и затем вызвать 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 (mail, получатель). То, что он на самом деле делает - выбирает POP3 / SMTP, вызывая серверы, перевод MIME и т. Д., Абстрагируется. Ты видишь только своего посыльного.

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

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

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

Все это делает мир лучшим местом для жизни: D

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

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

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

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

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

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

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

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

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 решает использовать абстрактную конструкцию автомобиля выше. Но у них есть различные продукты, имеющие одинаковые характеристики и выполняющие практически одинаковую функциональность. Поэтому они пишут класс, который расширяет указанный выше абстрактный класс. В нем рассказывается, как должна работать коробка передач, как должен работать тормоз, как должен работать руль. Тогда все продукты просто используют эту общую функциональность. Им не нужно знать, как работает коробка передач, работает ли она или работает ли рулевая тяга.

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

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

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

Из этого

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

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

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

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

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

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

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

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

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

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

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

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

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

А абстракция это -

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

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

На изображении ниже показан графический интерфейс «Данные клиента, которые нужно добавить в базу данных».

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

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

т.е.

• 2 переменные для хранения кода клиента и имени клиента.

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

  пространство имен CustomerContent {публичный класс Customer {публичная строка CustomerCode = ""; публичная строка CustomerName = ""; public void ADD () {// мой код БД будет здесь}

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

Шаг -2: Как будет работать валидация, функция ДОБАВИТЬ?

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

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 вместо 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: Приватный - дополнительные и сложные методы, которые не включают взаимодействие с конечным пользователем, - это инкапсуляция.

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