Quelle est la différence précise entre l'encapsulation et l'abstraction?

La plupart des réponses se concentrent ici sur la POO mais l'encapsulation commence beaucoup plus tôt:

• Chaque fonction est une encapsulation ; en pseudocode:

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

  Ici, distanceencapsule le calcul de la distance (euclidienne) entre deux points dans un plan: il masque les détails d'implémentation. C'est de l'encapsulation, pure et simple.

• L'abstraction est le processus de généralisation : prendre une implémentation concrète et la rendre applicable à différents types de données, quoique quelque peu liés. L'exemple classique d'abstraction est laqsortfonctionde Cpour trier les données:

  Le problème, qsortc'est qu'il ne se soucie pas des données qu'il trie - en fait, il ne sait pas quelles données il trie. Au contraire, son type d'entrée est un pointeur sans type ( void*) qui est juste la façon de C de dire "Je ne me soucie pas du type de données" (cela est aussi appelé effacement de type). Le point important est que l'implémentation de qsortreste toujours la même, quel que soit le type de données. La seule chose qui doit changer est la fonction de comparaison, qui diffère d'un type de données à l'autre. qsortattend donc de l'utilisateur qu'il fournisse ladite fonction de comparaison comme argument de fonction.

L'encapsulation et l'abstraction vont de pair à tel point que vous pourriez faire valoir qu'elles sont vraiment inséparables. À des fins pratiques, cela est probablement vrai; Cela dit, voici une encapsulation qui n'est pas vraiment une abstraction:

class point {
    numeric x
    numeric y
}

Nous encapsulons les coordonnées du point, mais nous ne les éloignons pas matériellement, au-delà de les grouper logiquement.

Et voici un exemple d'abstraction qui n'est pas de l'encapsulation:

T pi<T> = 3.1415926535

Il s'agit d'une variable générique pi avec une valeur donnée (π), et la déclaration ne se soucie pas du type exact de la variable. Certes, j'aurais du mal à trouver quelque chose comme ça dans du vrai code: l'abstraction utilise presque toujours l'encapsulation. Cependant, ce qui précède n'existe effectivement en C ++ (14), via des modèles variables (= modèles génériques pour les variables); avec une syntaxe légèrement plus complexe, par exemple:

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

L'encapsulation cache les détails d'implémentation qui peuvent ou non concerner des comportements génériques ou spécialisés.

L'abstraction fournit une généralisation (disons, sur un ensemble de comportements).

Voici une bonne lecture: abstraction, encapsulation et dissimulation d'informations par Edward V. Berard de l'Object Agency.

De nombreuses réponses et leurs exemples sont trompeurs.

L'encapsulation est le regroupement de données et de fonctions opérant sur ces données dans un seul composant et limitant l'accès à certains des composants de l'objet.
L'encapsulation signifie que la représentation interne d'un objet est généralement cachée à l'extérieur de la définition de l'objet.

L'abstraction est un mécanisme qui représente les caractéristiques essentielles sans inclure les détails de mise en œuvre.

Encapsulation: - Masquage des informations .
Abstraction: - Mise en œuvre masquée .

Exemple:

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

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

La représentation interne de tout objet de fooclasse est cachée en dehors de la classe. -> Encapsulation.
Tout membre accessible (données / fonction) d'un objet de fooest restreint et n'est accessible qu'à cet objet uniquement.

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

L'implémentation de la méthode addest masquée. -> Abstraction.

l'encapsulation met certaines choses dans une boîte et vous donne un judas; cela vous empêche de nettoyer avec les engrenages.

l'abstraction à plat ignore les détails qui n'ont pas d'importance, comme si les choses ont des engrenages, des rochets, des volants ou des noyaux nucléaires; ils "vont"

exemples d'encapsulation:

• slip
• boîte à outils
• portefeuille
• Sac à main
• capsule
• carbonite congelée
• une boîte, avec ou sans bouton dessus
• un burrito (techniquement, la tortilla autour du burrito)

exemples d'abstraction:

• "groupes de choses" est une abstraction (que nous appelons agrégation)
• "les choses qui contiennent d'autres choses" est une abstraction (que nous appelons composition)
• "conteneur" est un autre type d'abstraction de "choses qui contiennent d'autres choses"; notez que tous les exemples d'encapsulation sont des types de conteneurs, mais tous les conteneurs ne présentent / ne fournissent pas l'encapsulation. Un panier, par exemple, est un conteneur qui n'encapsule pas son contenu.

L'encapsulation cache des données comme l'utilisation de getter et setter, etc.

L'abstraction signifie masquer l'implémentation à l'aide d'une classe abstraite et d'interfaces, etc.

L'abstraction est un terme généralisé. c'est-à-dire que l'encapsulation est un sous-ensemble de l'abstraction.

• Exemple 2:
  L' architecte de la solution est la personne qui crée la conception technique abstraite de haut niveau de la solution entière, et cette conception est ensuite remise à l' équipe de développement pour la mise en œuvre .

  Ici, l'architecte de la solution agit comme un résumé et l'équipe de développement agit comme une encapsulation.

• Exemple 3: encapsulation (mise en réseau) des données utilisateur

Courtoisie

Abstraction (ou modularité) - Les types permettent aux programmeurs de penser à un niveau supérieur au bit ou à l'octet, sans se soucier de l'implémentation de bas niveau. Par exemple, les programmeurs peuvent commencer à considérer une chaîne comme un ensemble de valeurs de caractères plutôt que comme un simple tableau d'octets. Plus haut encore, les types permettent aux programmeurs de penser et d'exprimer des interfaces entre deux sous-systèmes de toute taille. Cela permet plus de niveaux de localisation afin que les définitions requises pour l'interopérabilité des sous-systèmes restent cohérentes lorsque ces deux sous-systèmes communiquent. La source

Beaucoup de bonnes réponses sont fournies ci-dessus, mais je vais présenter mon point de vue (Java) ici.

L'encapsulation des données signifie simplement encapsuler et contrôler l'accès aux données regroupées logiquement dans une classe. Il est généralement associé à un autre mot clé - Masquage des données . Ceci est réalisé en Java en utilisant des modificateurs d'accès .

Un exemple simple serait de définir une variable privée et de lui donner accès à l'aide de méthodes getter et setter ou de rendre une méthode privée car elle n'est utilisée qu'avec la classe. Il n'est pas nécessaire que l'utilisateur connaisse ces méthodes et variables.

Remarque : Il ne faut pas oublier que l'encapsulation concerne uniquement le masquage des données. Lorsque nous parlons d'encapsulation, l'accent devrait être mis sur le regroupement, le regroupement ou le regroupement des données et comportements associés.

L'abstraction des données, d' autre part, est un concept de généralisation afin que la logique complexe sous-jacente ne soit pas exposée à l'utilisateur. En Java, cela est réalisé en utilisant des interfaces et des classes abstraites .

Exemple -

Disons que nous avons une interface Animal et une fonction makeSound () . Il existe deux classes concrètes Dog et Cat qui implémentent cette interface. Ces classes concrètes ont des implémentations distinctes de la fonction makeSound (). Disons maintenant que nous avons un animal (nous l'obtenons d'un module externe). Tout ce que l'utilisateur sait, c'est que l'objet qu'il reçoit est un animal et qu'il est de la responsabilité de l'utilisateur d'imprimer le son de l'animal. Une façon de force brute est de vérifier l'objet reçu pour identifier le type de, puis typecast à ce type d'animaux, puis appelez makeSound () sur elle. Mais une façon plus nette consiste à résumer les choses . Utilisez Animal commeréférence polymorphe et appelez makeSound () dessus. Au moment de l'exécution, en fonction du type d'objet réel, la fonction appropriée sera invoquée.

Plus de détails ici .

La logique complexe est dans la carte de circuit imprimé qui est encapsulée dans un pavé tactile et une belle interface (boutons) est fournie pour l'abstraire à l'utilisateur.

PS: Les liens ci-dessus sont vers mon blog personnel.

• L'abstraction vous permet de vous concentrer sur ce que fait l'objet plutôt que sur la façon dont il le fait
• L'encapsulation signifie cacher les détails internes ou la mécanique de la façon dont un objet fait quelque chose.

Comme lorsque vous conduisez une voiture, vous savez ce que fait la pédale d'accélérateur, mais vous ne connaissez peut-être pas le processus derrière elle car elle est encapsulée.

Permettez-moi de donner un exemple en C #. Supposons que vous ayez un entier:

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

vous pouvez utiliser une méthode comme Number.ToString () qui vous renvoie une représentation des caractères du nombre 5 et la stocke dans un objet chaîne. La méthode vous indique ce qu'elle fait au lieu de la façon dont elle le fait.

Ce sont des concepts quelque peu flous qui ne sont pas propres à l'informatique et à la programmation. Je voudrais proposer quelques réflexions supplémentaires qui pourraient aider les autres à comprendre ces concepts importants.

Réponse courte

Encapsulation - Masquer et / ou restreindre l'accès à certaines parties d'un système, tout en exposant les interfaces nécessaires.

Abstraction - Considérer quelque chose avec certaines caractéristiques supprimées, en dehors des réalités concrètes, des objets spécifiques ou des instances réelles, réduisant ainsi la complexité.

La principale similitude est que ces techniques visent à améliorer la compréhension et l'utilité.

Le principal différence est que l' abstraction est un moyen de représenter les choses plus simplement (souvent pour rendre la représentation plus largement applicable), tandis que l'encapsulation est une méthode pour changer la façon dont d'autres choses interagissent avec quelque chose.

Longue réponse

Encapsulation

Voici un exemple d'encapsulation qui, nous l'espérons, clarifie les choses:

Ici, nous avons un Arduino Uno et un Arduino Uno dans un boîtier. Un boîtier est une excellente représentation de ce qu'est l'encapsulation.

L'encapsulation vise à protéger certains composants contre les influences et connaissances extérieures ainsi qu'à exposer les composants avec lesquels d'autres choses devraient interagir. En termes de programmation, cela implique cacher l' information que les modificateurs d'accès , qui modifient la mesure dans laquelle certaines variables et / ou des propriétés peuvent être lues et écrites.

Mais au-delà, l'encapsulation vise également à fournir ces interfaces externes beaucoup plus efficacement. Avec notre exemple Arduino, cela pourrait inclure les beaux boutons et l'écran qui rendent l'interaction de l'utilisateur avec l'appareil beaucoup plus simple. Ils fournissent à l'utilisateur des moyens simples d'affecter le comportement de l'appareil et d'obtenir des informations utiles sur son fonctionnement qui seraient autrement beaucoup plus difficiles.

Dans la programmation, cela implique le regroupement des différents composants dans une construction séparée, comme un function, classouobject . Il comprend également la fourniture des moyens d'interagir avec ces constructions, ainsi que des méthodes pour obtenir des informations utiles à leur sujet.

L'encapsulation aide les programmeurs de nombreuses façons supplémentaires, notamment l'amélioration de la maintenabilité et de la testabilité du code.

Abstraction

Bien que de nombreuses autres réponses définissent ici l'abstraction comme une généralisation, je pense personnellement que cette définition est erronée. Je dirais que la généralisation est en fait un type d' abstraction spécifique , et non l'inverse. En d'autres termes, toutes les généralisations sont des abstractions, mais toutes les abstractions ne sont pas nécessairement des généralisations.

Voici comment j'aime penser l'abstraction:

Diriez-vous que l'image représente un arbre? Il y a de fortes chances que vous le fassiez. Mais est-ce vraiment un arbre? Bien sûr que non! C'est un tas de pixels faits pour ressembler à quelque chose que nous pourrions appeler un arbre. On pourrait dire qu'il représente une abstraction d'un arbre réel. Notez que plusieurs détails visuels de l'arborescence sont omis. De plus, il ne pousse pas, ne consomme pas d'eau et ne produit pas d'oxygène. Comment est-ce possible? c'est juste un tas de couleurs sur un écran, représenté par des octets dans la mémoire de votre ordinateur.

Et voici l'essence de l'abstraction. C'est une façon de simplifier les choses pour qu'elles soient plus faciles à comprendre. Chaque idée qui vous passe par la tête est une abstraction de la réalité. Votre image mentale d'un arbre n'est pas plus un arbre réel que ce jpeg.

En programmation, nous pourrions utiliser cela à notre avantage en créant une Treeclasse avec des méthodes pour la croissance simulée, la consommation d'eau et la production d'oxygène. Notre création serait quelque chose qui représente notre expérience des arbres réels, et ne comprend que les éléments qui nous intéressent vraiment pour notre simulation particulière. Nous utilisons l'abstraction comme moyen de représenter notre expérience de quelque chose avec des octets et des mathématiques.

Classes abstraites

L'abstraction en programmation nous permet également de considérer les points communs entre plusieurs types d'objets «concrets» (types qui existent réellement) et de définir ces points communs au sein d'une entité unique. Par exemple, notre Treeclasse peut hériter d'un abstract class Plant, qui a plusieurs propriétés et méthodes qui s'appliquent à toutes nos classes de type plante, mais supprime celles qui sont spécifiques à chaque type de plante. Cela peut réduire considérablement la duplication de code et améliore la maintenabilité.

La différence pratique entre an abstract classet plain classest que, conceptuellement, il n'y a pas d'instances "réelles" de abstract class. Cela n'aurait pas de sens de construire un Plantobjet car ce n'est pas assez précis. Chaque "vrai" Plantest aussi un type plus spécifique de Plant.

De plus, si nous voulons que notre programme soit plus réaliste, nous pourrions considérer le fait que notre Treeclasse peut être trop abstraite elle-même. En réalité, tout Treeest un type plus spécifique Tree, afin que nous puissions créer des classes pour ces types tels que Birch, Mapleetc. , qui hériteront de notre, peut - être maintenant abstract, Treeclasse.

JVM

Un autre bon exemple d'abstraction est la machine virtuelle Java (JVM) , qui fournit un ordinateur virtuel ou abstrait sur lequel le code Java peut s'exécuter. Il enlève essentiellement tous les composants spécifiques à la plate-forme d'un système et fournit une interface abstraite d '"ordinateur" sans égard à aucun système en particulier.

La différence

L'encapsulation diffère de l'abstraction en ce qu'elle n'a rien à voir avec le caractère «réel» ou «précis» de quelque chose. Il ne supprime pas les composants de quelque chose pour le rendre plus simple ou plus largement applicable. Il peut plutôt masquer certains composants pour atteindre un objectif similaire.

Encapsulation : cache les détails d'implémentation indésirables / inattendus / exclusifs aux utilisateurs réels de l'objet. par exemple

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. */

Abstraction : Est un moyen de généralisation et donc une manière courante de travailler avec des objets d'une grande diversité. par exemple

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

Différence entre l'abstraction et l'encapsulation.

Abstraction: L'idée de présenter quelque chose d'une manière simplifiée / différente, qui est soit plus facile à comprendre et à utiliser, soit plus pertinente pour la situation.

Considérons une classe qui envoie un e-mail ... elle utilise l'abstraction pour se montrer comme une sorte de messager, vous pouvez donc appeler emailSender.send (mail, destinataire). Ce qu'il fait réellement - choisit POP3 / SMTP, les serveurs d'appel, la traduction MIME, etc., est résumé. Vous ne voyez que votre messager.

Encapsulation: l'idée de sécuriser et de masquer des données et des méthodes qui sont privées à un objet. Il s'agit davantage de rendre quelque chose d'indépendant et infaillible.

Prends-moi, par exemple. J'encapsule ma fréquence cardiaque du reste du monde. Parce que je ne veux pas que quelqu'un d'autre modifie cette variable, et je n'ai besoin de personne d'autre pour la définir afin que je puisse fonctionner. C'est extrêmement important pour moi, mais vous n'avez pas besoin de savoir ce que c'est, et vous ne vous en souciez probablement pas de toute façon.

Regardez autour de vous, vous constaterez que presque tout ce que vous touchez est un exemple d'abstraction et d'encapsulation. Votre téléphone, par exemple, vous présente l'abstraction de pouvoir prendre ce que vous dites et le dire à quelqu'un d'autre - couvrant le GSM, l'architecture du processeur, les fréquences radio et un million d'autres choses que vous ne comprenez pas ou dont vous ne vous souciez pas. Il encapsule également certaines données de vous, comme les numéros de série, les numéros d'identification, les fréquences, etc.

Tout cela fait du monde un endroit plus agréable où vivre: D

Abstraction: seules les informations nécessaires sont affichées. Concentrons-nous sur l'exemple de la mise sous tension d'un ordinateur. L'utilisateur n'a pas besoin de savoir ce qui se passe pendant le chargement du système (cette information est cachée à l'utilisateur).

Prenons un autre exemple, celui de l'ATM. Le client n'a pas besoin de savoir comment la machine lit le code PIN et traite la transaction, il lui suffit de saisir le code PIN, de prendre l'argent et de partir.

Encapsulation: traite de la dissimulation des données sensibles d'une classe et donc de la privatisation d'une partie de celle-ci. C'est un moyen de garder certaines informations privées pour ses clients en ne leur permettant pas d'accéder de l'extérieur.

Un autre exemple:

Supposons que j'ai créé une classe Rectangle immuable comme celle-ci:

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

Maintenant, il est évident que j'ai encapsulé la largeur et la hauteur (l'accès est en quelque sorte restreint), mais je n'ai pas résumé (d'accord, j'ai peut-être ignoré où se trouve le rectangle dans l'espace des coordonnées, mais c'est un défaut de la exemple).

Une bonne abstraction implique généralement une bonne encapsulation.

Un exemple de bonne abstraction est une classe de connexion de base de données générique. Son interface publique est indépendante de la base de données et est très simple, mais me permet de faire ce que je veux avec la connexion. Et tu vois? Il y a également une encapsulation, car la classe doit avoir tous les descripteurs et appels de bas niveau à l'intérieur.

Abstractionet Encapsulationen utilisant un seul exemple généralisé

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

Nous utilisons tous la calculatrice pour le calcul de problèmes complexes!

Un mécanisme qui empêche les données d'un objet particulier à l'abri d'une mauvaise utilisation intentionnelle ou accidentelle par des fonctions externes est appelé " encapsulation de données"

L'acte de représenter des caractéristiques essentielles sans inclure les détails ou les explications de fond est connu sous le nom d' abstraction

Abstraction: l' abstraction signifie montrer une Whatpartie des fonctionnalités.

Encapsulation: encapsulation signifie masquer la Howpartie de la fonctionnalité.

Prenons un exemple très simple

/// <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
    }
}

Classe de programme d'application console

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

Prenons l'exemple d'une pile. Il pourrait être implémenté à l'aide d'un tableau ou d'une liste liée. Mais les opérations qu'il prend en charge sont push and pop.

Maintenant, l' abstraction expose uniquement les interfaces push et pop. La représentation sous-jacente est masquée (s'agit-il d'un tableau ou d'une liste chaînée?) Et une interface bien définie est fournie. Maintenant, comment vous assurez-vous qu'aucun accès accidentel n'est fait aux données abstraites? C'est là que l' encapsulation entre en jeu. Par exemple, les classes en C ++ utilisent les spécificateurs d'accès qui garantissent que l'accès et la modification accidentels sont empêchés. Et aussi, en rendant publiques les interfaces susmentionnées, cela garantit que la seule façon de manipuler la pile est via l'interface bien définie. Dans le processus, il a couplé les données et le code qui peut les manipuler (n'impliquons pas les fonctions ami ici). Autrement dit, le code et les données sont liés ensemble ou liés ou encapsulés.

L'encapsulation enveloppe la complexité dans une capsule qui est classe et donc encapsulation… Alors que l'abstraction est les caractéristiques d'un objet qui se différencient d'un autre objet ...

L'abstraction peut être obtenue en faisant un résumé de classe ayant une ou plusieurs méthodes abstraites. Ce qui n'est rien d'autre que la caractéristique qui devrait être implémentée par la classe qui l'étend. Par exemple, lorsque vous inventez / concevez une voiture, vous définissez des caractéristiques telles que la voiture doit avoir 4 portes, un frein, un volant, etc. La mise en œuvre n'est pas la tête de l'abstraction. Il ne fera que définir les caractéristiques à inclure.

L'encapsulation est obtenue en conservant les données et le comportement dans une capsule de classe et en utilisant des modificateurs d'accès tels que public, privé, protégé avec l'héritage, l'agrégation ou la composition. Donc, vous ne montrez que les choses requises, cela aussi, uniquement dans la mesure où vous voulez les montrer. c.-à-d. public, protégé, amical et privé ka funda …… par exemple, GM décide d'utiliser la conception abstraite de la voiture ci-dessus. Mais ils ont divers produits ayant les mêmes caractéristiques et faisant presque les mêmes fonctionnalités. Ils écrivent donc une classe qui étend la classe abstraite ci-dessus. Il indique comment la boîte de vitesses devrait fonctionner, comment la pause devrait fonctionner, comment le volant devrait fonctionner. Ensuite, tous les produits utilisent simplement cette fonctionnalité commune. Ils n'ont pas besoin de savoir comment fonctionne la boîte de vitesses ou si elle fonctionne ou si la direction fonctionne correctement.

Les deux sont puissants; mais l'utilisation de l'abstraction nécessite plus de compétences que l'encapsulation et de plus grandes applications / produits ne peuvent pas survivre sans abstraction.

Abstraction --- Masquage de l'implémentation - lors de la conception --- Utilisation de l'interface / Résumé calsses

Encapsulation - Masquage des données - Au développement --- Utilisation de modificateurs d'accès (public / privé)

De cela

Différence entre l'encapsulation et l'abstraction dans OOPS

L'abstraction et l'encapsulation sont deux concepts importants de programmation orientée objet (OOPS). L'encapsulation et l'abstraction sont des termes interdépendants.

Différence réelle entre l'encapsulation et l'abstraction

Encapsuler signifie se cacher. L'encapsulation est également appelée masquage des données. Vous pouvez penser que l'encapsulation est une capsule (comprimé de médicament) qui cache le médicament à l'intérieur. L'encapsulation est enveloppante, cachant simplement les propriétés et les méthodes. L'encapsulation est utilisée pour masquer le code et les données dans une seule unité pour protéger les données de l'extérieur du monde. La classe est le meilleur exemple d'encapsulation.

L'abstraction consiste à n'afficher que les détails nécessaires à l'utilisateur prévu. Comme son nom l'indique, l'abstraction est la "forme abstraite de tout". Nous utilisons l'abstraction dans les langages de programmation pour créer une classe abstraite. La classe abstraite représente une vue abstraite des méthodes et des propriétés de la classe.

Différence de mise en œuvre entre l'encapsulation et l'abstraction

1. L'abstraction est implémentée à l'aide de l'interface et de la classe abstraite tandis que l'encapsulation est implémentée à l'aide d'un modificateur d'accès privé et protégé.

2. OOPS utilise l'encapsulation pour faire respecter l'intégrité d'un type (c'est-à-dire pour s'assurer que les données sont utilisées de manière appropriée) en empêchant les programmeurs d'accéder aux données de manière non intentionnelle. Grâce à l'encapsulation, seul un groupe prédéterminé de fonctions peut accéder aux données. Le terme collectif pour les types de données et les opérations (méthodes) regroupés avec les restrictions d'accès (public / privé, etc.) est une classe.

Je vais essayer de démontrer l'encapsulation d'une manière simple .. Voyons voir ..

• L'encapsulation des données et des fonctions dans une seule unité (appelée classe) est connue sous le nom d'encapsulation. Encapsulation contenant et masquant des informations sur un objet, telles que les structures de données internes et le code.

L'encapsulation est -

• Masquer la complexité,
• Relier les données et la fonction ensemble,
• Rendre la méthode compliquée privée,
• Rendre la variable d'instance privée,
• Masquage des données et fonctions inutiles de l'utilisateur final.

L'encapsulation implémente l'abstraction.

Et l'abstraction est -

• Montrant ce qui est nécessaire,
• Les données doivent être abstraites de l'utilisateur final,

Voyons un exemple-

L'image ci-dessous montre une interface graphique de "Détails du client à ajouter dans une base de données".

En regardant l'image, nous pouvons dire que nous avons besoin d'une classe client.

Étape - 1: De quoi a besoin ma classe client?

c'est à dire

• 2 variables pour stocker le code client et le nom du client.

• 1 Fonction pour ajouter le code client et le nom client dans la base de données.

  espace de noms CustomerContent {public class Customer {public string CustomerCode = ""; chaîne publique CustomerName = ""; public void ADD () {// mon code DB ira ici}

Maintenant, seule la méthode ADD ne fonctionnera pas seule ici.

Étape -2: Comment fonctionnera la validation, la fonction ADD fonctionnera?

Nous aurons besoin du code de connexion à la base de données et du code de validation (méthodes supplémentaires).

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

Désormais, il n'est plus nécessaire de montrer les méthodes supplémentaires (Validate (); CreateDBObject () [méthode compliquée et supplémentaire]) à l'utilisateur final. l'enregistrement .. L'utilisateur final ne se soucie pas de COMMENT il ajoutera les données à la base de données?.

Étape -3: Privilégiez les méthodes supplémentaires et compliquées qui n'impliquent pas l'interaction de l'utilisateur final.

Donc, rendre ces méthodes Complicated et Extra privées plutôt que publiques (c'est-à-dire masquer ces méthodes) et supprimer l'obj.Validate (); obj.CreateDBObject (); du programme principal en classe, nous obtenons l'encapsulation.

En d'autres termes, simplifier l'interface pour l'utilisateur final est l'encapsulation.

Alors maintenant, le code ressemble à ci-dessous -

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

Résumé :

Étape -1: De quoi a besoin ma classe client? est l'abstraction.

Étape -3: Étape -3: Privilégiez les méthodes supplémentaires et compliquées qui n'impliquent pas l'interaction de l'utilisateur final est l'encapsulation.

PS - Le code ci-dessus est dur et rapide.

Le paragraphe ci-dessous m'a aidé à comprendre comment ils diffèrent les uns des autres:

L'encapsulation des données est un mécanisme de regroupement des données, et les fonctions qui les utilisent et l'abstraction des données sont un mécanisme permettant d'exposer uniquement les interfaces et de masquer les détails d'implémentation à l'utilisateur.

Vous pouvez en lire plus ici .

La dissimulation d'informations n'est pas strictement requise pour l'abstraction ou l'encapsulation. Les informations peuvent être ignorées, mais ne doivent pas être cachées.

L'encapsulation est la capacité de traiter quelque chose comme une chose unique, même si elle peut être composée de nombreuses parties ou idées complexes. Par exemple, je peux dire que je suis assis sur une "chaise" plutôt que de faire référence aux nombreuses parties différentes de cette chaise, chacune avec un design et une fonction spécifiques, toutes s'emboîtant précisément dans le but de tenir confortablement mes fesses à quelques pieds loin du sol.

L'abstraction est activée par encapsulation. Parce que nous encapsulons des objets, nous pouvons les considérer comme des choses qui se rapportent les unes aux autres plutôt que de s'enliser dans les détails subtils de la structure interne de l'objet. L'abstraction est la capacité de considérer la situation dans son ensemble, sans souci des petits détails.La racine du mot est abstraite comme dans le résumé qui apparaît en haut d'un article scientifique, pas abstraite comme dans une classe qui ne peut être instanciée qu'en tant que sous-classe dérivée.

Je peux honnêtement dire que lorsque je mets mes fesses dans ma chaise, je ne pense jamais à la façon dont la structure de cette chaise attrapera et maintiendra mon poids. C'est une chaise assez décente pour que je n'ai pas à me soucier de ces détails. Je peux donc tourner mon attention vers mon ordinateur. Et encore une fois, je ne pense pas aux composants de mon ordinateur. Je regarde juste une partie d'une page Web qui représente une zone de texte que je peux taper, et je communique avec des mots, sans même penser à la façon dont mes doigts trouvent toujours les bonnes lettres si rapidement sur le clavier, et comment la connexion est finalement établie entre le fait d'appuyer sur ces touches et de publier sur ce forum. C'est le grand pouvoir de l'abstraction. Parce que les niveaux inférieurs du système peuvent être fiables pour fonctionner avec cohérence et précision, nous avons une attention particulière pour un travail plus important.

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

l'abstraction masque les données inutiles des utilisateurs et l'encapsulation lie les données dans une capsule (une classe). Je pense que l'encapsulation est un moyen de réaliser l'abstraction.

Les processus d'abstraction et d'encapsulation génèrent tous deux des interfaces.

Une interface générée via l'encapsulation masque les détails de mise en œuvre.

Une interface générée via l'abstraction devient applicable à plusieurs types de données, par rapport à avant l'abstraction.

Abstractionest un contrat pour la mise en œuvre que nous allons faire. La mise en œuvre peut être modifiée au fil du temps. Les différentes implémentations elles-mêmes peuvent être masquées ou non, mais sont masquées derrière l'abstraction.

Supposons que nous définissions tous les éléments APIsd'une classe dans un interfacepuis demandons aux utilisateurs de notre code de dépendre de la définition APIsde la interface. Nous sommes libres d'améliorer ou de modifier la mise en œuvre seulement nous devons suivre le contrat défini. Les utilisateurs ne sont pas couplés à notre implémentation.

Nous EXPOSONS toutes les règles (méthodes) NÉCESSAIRES en abstraction , la mise en œuvre des règles est laissée aux entités implémentantes, également la mise en œuvre ne fait pas partie de l'abstraction. C'est juste la signature et la déclaration qui font l'abstraction.

EncapsulationCACHE simplement les détails internes en réduisant l'accès aux états et aux comportements. Une classe encapsulée peut ou non être bien définie Abstraction.

java.util.Listest une abstraction pour java.util.ArrayList. Les états internes d' java.util.ArrayListêtre marqués avec non publicdes modificateurs d'accès sont l'encapsulation.

Modifier Supposons une classe Container.nava implements IContainer, IContainerpeut déclarer des méthodes comme addElement, removeElements, contains, etc. Ici IContainerreprésente l'abstraction pour sa classe d' implémentation. L'abstraction consiste à déclarer les API de la classe ou d'un module ou d'un système au monde extérieur. Ces API deviennent le contract. Ce système peut être ou non encore développé. Les utilisateurs du système peuvent désormais dépendre des API déclarées et sont sûrs que tout système mettant en œuvre un tel contrat respectera toujours les API déclarées, ils fourniront toujours une implémentation de tge pour ces API. Une fois que nous écrivons une entité concrète, décider de cacher nos états internes est une encapsulation

Je pense que l'encapsulation est un moyen de mettre en œuvre l'abstraction. Jetez un œil au lien suivant.

Abstraction et encapsulation

En bref

Utilisation de l'abstraction -> Encapsulation et utilisation de l'encapsulation -> masquage des données

OU

le masquage des données est un sous-ensemble de l'encapsulation et l' encapsulation est un sous-ensemble de l'abstraction

Référence: http://www.tonymarston.co.uk/php-mysql/abstraction.txt