Quelle est la différence entre l'abstraction et l'encapsulation?
Dans les entretiens, on m'a demandé d'expliquer la différence entre abstraction et encapsulation. Ma réponse a été dans les lignes de
Abstraction nous permet de représenter le monde réel complexe de la manière la plus simple. C'est le processus d'identification des qualités et des comportements pertinents qu'un objet devrait posséder; en d'autres termes, représenter la fonctionnalité nécessaire sans représenter les détails de l'arrière-plan.
L'encapsulation est un processus qui masque tous les détails internes d'un objet au monde réel extérieur. Le mot "encapsulation", c'est comme "enfermer" dans une "capsule". Il empêche les clients de voir sa vue interne où le comportement de l'abstraction est implémenté.
Je pense qu'avec la réponse ci-dessus, l'intervieweur était convaincu, mais on m'a ensuite demandé si l'objectif des deux objectifs était caché, pourquoi il était nécessaire d'utiliser l'encapsulation. A cette époque, je n'avais pas de bonne réponse à cela.
Que devrais-je ajouter pour que ma réponse soit plus complète?
L'abstraction consiste à séparer l'interface de la mise en œuvre. (Nous nous moquons qu'est-ce que c'est, nous nous soucions que cela fonctionne d'une certaine manière.)
L’encapsulation consiste à interdire l’accès ou la connaissance des structures internes d’une implémentation. (Nous ne nous soucions pas ou n'avons pas besoin de voir comment ça marche, seulement que c'est le cas.)
Certaines personnes utilisent l'encapsulation comme synonyme d'abstraction, qui est incorrecte (IMO). Il est possible que votre intervieweur ait pensé cela. Si tel était le cas, vous parliez chacun de deux choses différentes lorsque vous parliez d '"encapsulation".
Il convient de noter que ces concepts sont représentés différemment dans différents langages de programmation. Quelques exemples:
- En Java et en C #, les interfaces (et, dans une certaine mesure, les classes abstraites) fournissent une abstraction, tandis que les modificateurs d'accès fournissent une encapsulation.
- C'est essentiellement la même chose en C++, sauf que nous n'avons pas d'interfaces, nous n'avons que des classes abstraites.
- En JavaScript, le typage de canard fournit une abstraction et la fermeture fournit une encapsulation. (La convention de dénomination peut également fournir une encapsulation, mais cela ne fonctionne que si toutes les parties acceptent de la suivre.)
C'est simple!
Prenons l'exemple de la télévision - c'est Encapsulation , parce que:
La télévision est chargée de différentes fonctionnalités que je ne connais pas car elles sont complètement cachées.
Tout ce qui est caché, comme la musique, la vidéo, etc., est réuni dans une capsule que nous appelons une télévision.
Maintenant, l’abstraction est Quand nous savons quelque chose et qui peut nous aider à manipuler quelque chose dont nous ne savons pas comment cela fonctionne en interne.
Par exemple: Une télécommande pour la télévision est une abstraction, parce que
- Avec la télécommande, nous savons qu’appuyer sur les touches numériques changera les chaînes. Nous ne sommes pas au courant de ce qui se passe réellement en interne. Nous pouvons manipuler la chose cachée mais nous ne savons pas comment cela se fait en interne.
Par programmation, lorsque nous pouvons accéder aux données cachées d’une manière ou d’une autre et que nous savons quelque chose, c’est l’abstraction.
Sans télécommande, nous ne pouvons rien changer à la télévision. Nous devons voir ce qui est affiché car toutes les commandes sont masquées.
Abstraction
Exposer l'entité au lieu des détails de l'entité.
"Les détails sont là, mais nous ne les considérons pas. Ils ne sont pas nécessaires."
Exemple 1:
Différents calculs: Addition, multiplication, soustraction, division, carré, péché, cos, tan.
Nous ne montrons pas les détails de la façon dont nous calculons le Sin, Cos ou Tan. Nous venons de montrer la calculatrice et ses diverses méthodes, qui doivent être utilisées par l'utilisateur.
Exemple 2:
L'employé a: Prénom, nom, deuxième prénom. Il peut se connecter (), se déconnecter (), faire DoWork ().
De nombreux processus peuvent être en cours pour la journalisation des employés, tels que la connexion à la base de données, l'envoi de l'identifiant et du mot de passe d'un employé, la réception d'une réponse de la base de données. Bien que les détails ci-dessus soient présents, nous les masquerons et exposerons uniquement "Employé".
Encapsulation
Enfermant. Traiter plusieurs caractéristiques/fonctions comme une seule unité au lieu d’individus .. Ainsi, le monde extérieur se référera directement à cette unité plutôt qu’à ses détails.
"Les détails sont là, nous les considérons, mais ne les montrons pas, mais plutôt ce que vous devez voir."
Exemple 1:
Au lieu de l'appeler comme Addition, Soustraction, Multiplication, Division, nous l'appellerons maintenant comme une calculatrice.
Exemple 2:
Toutes les caractéristiques et opérations sont maintenant référées par l’employé, telles que "John". John a un nom. John peut faireWork (). John peut se connecter ().
Cache
Cacher l'application du monde extérieur ... Pour que le monde extérieur ne voie pas ce qui ne devrait pas être vu.
"Les détails sont là, nous les considérons, mais nous ne les montrons pas. Vous n'avez pas besoin de les voir."
Exemple 1:
Votre besoin: addition, soustraction, multiplication, division. Vous pourrez le voir et obtenir le résultat.
Vous n'avez pas besoin de savoir où les opérandes sont stockés. Ce n'est pas votre exigence.
En outre, chaque instruction que je suis en train d'exécuter n'est pas non plus votre exigence.
Exemple 2:
John aimerait connaître son pourcentage de présence. Donc, GetAttendancePercentage () sera appelé.
Cependant, cette méthode nécessite des données enregistrées dans la base de données. Par conséquent, il appellera FetchDataFromDB (). FetchDataFromDB () n'est PAS requis pour être visible au monde extérieur.
Par conséquent, nous allons le cacher. Cependant, John.GetAttendancePercentage () sera visible du monde extérieur.
Abstraction, encapsulation et dissimulation se complètent.
Comme nous créons un niveau d'abstraction par rapport aux détails, ceux-ci sont encapsulés. Et parce qu'ils sont enfermés, ils sont cachés.
Différence entre abstraction et encapsulation: -
Abstraction
- L'abstraction résout le problème au niveau de la conception.
- L'abstraction sert à masquer les données indésirables et à fournir des données pertinentes.
- L'abstraction vous permet de vous concentrer sur ce que fait l'objet au lieu de savoir comment il le fait.
- Abstraction- Disposition externe, utilisée en termes de conception . Par exemple: - Apparence extérieure d'un téléphone mobile, comme s'il avait un écran d'affichage et des touches du clavier pour composer un numéro.
Encapsulation
- L'encapsulation résout le problème au niveau de la mise en œuvre.
- L'encapsulation consiste à cacher le code et les données dans une seule unité afin de protéger les données du monde extérieur.
- L'encapsulation signifie cacher les détails internes ou la mécanique de la manière dont un objet fait quelque chose.
- Encapsulation - Disposition interne utilisée pour la mise en œuvre . Par exemple: - Détail de la mise en œuvre interne d'un téléphone mobile, comment les boutons du clavier et l'écran d'affichage sont connectés les uns aux autres à l'aide de circuits.
Encapsulation
L’encapsulation de ce que vous avez appris à chercher sur Google est un concept qui consiste à combiner les données et opérations associées dans une seule capsule ou ce que nous pourrions dire d’une classe en POO, de sorte qu'aucun autre programme ne puisse modifier les données qu'il contient ou son implémentation de méthode, à un moment particulier. Seules les méthodes getter et setter peuvent fournir un accès aux variables d'instance.
Notre code peut être utilisé par d'autres et les futures améliorations ou corrections de bugs sont susceptibles. L'encapsulation permet de s'assurer que tous les changements de code que nous apportons dans notre code ne cassent pas le code de ceux qui l'utilisent.
L'encapsulation ajoute à la maintenabilité, la flexibilité et l'extensibilité du code.
L'encapsulation permet de masquer l'implémentation derrière une interface.
Abstraction
L'abstraction est le processus consistant à cacher la mise en œuvre derrière une interface. Nous sommes donc simplement conscients du comportement réel, mais pas de la façon dont la réflexion fonctionne en interne. L'exemple le plus courant pourrait être le cas où une clé serait insérée dans la serrure et la déverrouillerait facilement. Donc, l'interface ici est le trou de serrure, alors que nous ne savons pas comment les leviers à l'intérieur de la serrure se coordonnent pour obtenir le déverrouillage.
Pour être plus clair, l'abstraction peut être expliquée par la possibilité d'utiliser la même interface pour différents objets. Différentes implémentations de la même interface peuvent exister, tandis que les détails de chaque implémentation sont masqués par l’encapsulation.
Enfin, la réponse à toutes les confusions jusqu’à présent - La partie masquée concerne l’encapsulation, tandis que la partie exposée concerne l’abstraction.
Je sais qu'il y a beaucoup de réponses devant moi avec une variété d'exemples.
Eh bien voici mon opinion l’abstraction s’intéresse de la réalité .
Dans abstraction nous cachons quelque chose pour réduire la complexité de celle-ci Et dans encapsulation nous cachons quelque chose pour protéger les données.
Nous définissons donc l’encapsulation comme l’emballage de données et de méthodes dans une entité unique appelée classe.
En Java, l’encapsulation est réalisée à l’aide de getters et de setters, et pas seulement en encapsulant des données et des méthodes. nous définissons également un moyen d’accéder à ces données ..__ et lors de l’accès aux données, nous les protégeons également.
Techinical serait par exemple de définir un poids d’appel de variable de données privé. Maintenant, nous savons que le poids ne peut être nul ou inférieur à zéro dans un scénario réel.
Imaginez qu’il n’y ait pas d’obstacles et de passeurs, quelqu'un aurait facilement pu lui attribuer une valeur négative en tant que membre public de la classe.
Maintenant la différence finale en utilisant un exemple du monde réel,
Considérons un circuit composé d’interrupteurs et de boutons . Nous enroulons tous les fils dans une boîte de circuit de manière à pouvoir protéger une personne en évitant tout contact direct ( encapsulation ).
Nous ne nous soucions pas de la façon dont ces fils sont connectés les uns aux autres, nous voulons juste une interface pour allumer et éteindre les interrupteurs. Cette interface est fournie par des boutons ( abstraction )
Abstraction: L'abstraction est un processus dans lequel vous collectez ou rassemblez des données pertinentes et supprimez des données non pertinentes. (Et si vous avez atteint l'abstraction, l'encapsulation est également réalisée.)
Encapsulation: / Encapsulation est un processus dans lequel vous enroulez des fonctions et des membres dans une seule unité. Signifie que vous cachez les détails de la mise en œuvre. Cela signifie que l'utilisateur peut accéder en faisant un objet de classe, il/elle ne peut pas voir les détails.
Exemple:
public class Test
{
int t;
string s;
public void show()
{
s = "Testing";
Console.WriteLine(s);
Console.WriteLine(See()); // No error
}
int See()
{
t = 10;
return t;
}
public static void Main()
{
Test obj = new Test();
obj.Show(); // there is no error
obj.See(); // Error:- Inaccessible due to its protection level
}
}
Dans l'exemple ci-dessus, l'utilisateur ne peut accéder qu'à la méthode Show () à l'aide de obj, c'est-à-dire Abstraction.
Et la méthode See () appelle en interne dans la méthode Show () qui est une encapsulation, car l'utilisateur ne sait pas ce qui se passe dans la méthode Show ().
Encapsulation: / Supposons que j'ai des documents confidentiels, maintenant je cache ces documents à l'intérieur d'un casier afin que personne ne puisse y accéder, il s'agit d'encapsulation.
Abstraction: Un énorme incident a eu lieu qui a été résumé dans le journal. Maintenant, le journal ne mentionne que les détails les plus importants de l'incident réel, c'est de l'abstraction. En outre, le titre de l'incident met en évidence des détails encore plus spécifiques sur une seule ligne, fournissant ainsi un niveau d'abstraction plus élevé sur l'incident. Les points forts d'un match de football/cricket peuvent également être considérés comme une abstraction de l'ensemble du match.
Par conséquent, l'encapsulation masque les données pour protéger leur intégrité et l'abstraction souligne des détails plus importants.
En termes de programmation nous pouvons voir qu'une variable peut être incluse est la portée d'une classe en tant que classe privée, ce qui l'empêche d'accéder directement à l'extérieur, il s'agit de - encapsulation . Alors qu'une fonction peut être écrite dans une classe pour échanger deux nombres. Maintenant, les nombres peuvent être échangés soit en utilisant une variable temporaire, soit par une manipulation de bits, soit en utilisant une opération arithmétique, mais le but de l'utilisateur est de recevoir les numéros échangés quelle que soit la méthode utilisée pour l'échange (ceci est abstraction .
Abstraction: dans le cas d’une couche d’abstraction matérielle, vous disposez d’interfaces simples pour déclencher le matériel (par exemple, tourner à gauche et à droite) sans connaître les détails matériels. Donc cacher la complexité du système. C'est une vue simplifiée du monde réel.
Encapsulation: masquage des objets internes. L'objet est une abstraction du monde réel. Mais les détails de cet objet (comme les structures de données ...) peuvent être cachés via une encapsulation.
RÉSUMÉ: "Vue d’un problème qui extrait les informations essentielles Pertinentes pour un but particulier et ignore le reste des informations Les." [IEEE, 1983]
ENCAPSULATION: "L'encapsulation ou, de manière équivalente, la dissimulation d'informations fait référence à la pratique consistant à inclure dans un objet tout ce dont il a besoin, et En outre, de manière à ce qu'aucun autre objet n'ait besoin de Être conscient de cette structure interne . "
Abstraction fait référence à l'acte de représenter des caractéristiques essentielles sans inclure les détails de l'arrière-plan ou les explications.
L'encapsulation est une technique utilisée pour masquer les propriétés et les comportements d'un objet et pour permettre un accès extérieur uniquement selon les besoins. Cela empêche d'autres objets de modifier ou d'accéder directement aux propriétés ou aux méthodes de l'objet encapsulé.
Différence entre abstraction et encapsulation
1. L’abstraction se concentre sur la vue extérieure d’un objet (c’est-à-dire l’interface). L’encapsulation (masquage d’informations) empêche les clients de voir sa vue interne, où le comportement de l’abstraction est implémenté.
2. L'abstraction résout le problème du côté conception tandis qu'Encapsulation est l'implémentation.
3. L'encapsulation est le produit livrable de l'abstraction. Encapsulation parle à peine de regrouper votre abstraction pour répondre aux besoins des développeurs.
L’abstraction est l’un des nombreux avantages de l’encapsulation de données . Nous pouvons aussi dire que l’encapsulation des données est un moyen de mettre en œuvre Abstraction .
À mon avis, l’encapsulation est une idée du programmeur qui cache la complexité du code du programme en utilisant un spécificateur d’accès.
Où Abstraction est la séparation de la méthode et de l'objet en fonction de leur fonction et de leur comportement. Par exemple, la voiture a des feuilles, des roues, une pause, un phare.
Mon opinion de l'abstraction n'est pas dans le sens de cacher des détails de mise en œuvre ou d'arrière-plan!
L'abstraction nous donne l'avantage de traiter avec une représentation du monde réel plus facile à manipuler, pouvant être réutilisée, pouvant être combinée à d'autres composants de notre programme plus ou moins complexe. Nous devons donc découvrir que how nous choisissons une paix complète du monde réel, suffisamment complète pour représenter le sens de notre algorithme et de nos données. La implementation de l'interface peut masquer les détails, mais cela ne fait pas partie du travail que nous devons faire pour extraire quelque chose.
Pour moi, le plus important pour l'abstraction est:
- réduction de la complexité
- réduction de taille/quantité
- division de domaines non liés en composants clairs et indépendants
Tout cela n'a pour moi rien à voir avec la dissimulation des détails de l'arrière-plan!
Si vous pensez trier certaines données, l’abstraction peut avoir pour résultat:
- un algorithme de tri, indépendant de la représentation des données
- une fonction de comparaison indépendante des données et de l'algorithme de tri
- une représentation de données générique, indépendante des algorithmes utilisés
Tout cela n'a rien à voir avec la dissimulation d'informations.
Abstraction : Masquage des données . Encapsulation : Liaison des données.
En ce qui concerne iOS, on peut dire que les fichiers Objective C (c'est-à-dire .h et .m) utilisent une abstraction ainsi qu'une encapsulation.
Abstraction
Le fichier d'en-tête (.h) expose uniquement les fonctions et les membres publics au monde extérieur. Personne ne sait comment ils sont utilisés à moins d'avoir le fichier d'implémentation avec eux. C'est le fichier .m qui contient toute la logique d'utilisation et de mise en œuvre. "La mise en œuvre reste non exposée".
Encapsulation
La propriété (@property) encapsule l'attribut de gestion de la mémoire (atomique, fort, retenu, faible) d'un iVar.
À mon avis, les deux termes sont liés dans un certain sens et mélangés les uns aux autres. "Encapsulation" fournit un moyen de regrouper des champs liés, des méthodes dans une classe (ou un module) pour envelopper les choses liées. À partir de ce moment, il fournit des données masquées de deux manières:
Grâce aux modificateurs d'accès.
Purement pour cacher l’état de la classe/de l’objet.
Abstraction de certaines fonctionnalités.
une. Grâce aux interfaces/classes abstraites, la logique complexe à l'intérieur de la classe ou du module encapsulé peut être abstraite/généralisée pour être utilisée par l'extérieur.
b. Grâce aux signatures de fonction. Oui, même les signatures de fonction exemple d'abstraction. Parce que les appelants ne connaissent que la signature et les paramètres (le cas échéant) et ne savent rien de la manière dont la fonction est exécutée. Il ne se soucie que de la valeur retournée.
De même, "Abstraction" pourrait être une façon d’encapsuler en regroupant/enveloppant le comportement dans une interface (ou une classe abstraite ou même une classe normale).
L'encapsulation est utilisée pour deux raisons principales:
1.) Cacher et protéger les données (l’utilisateur de votre classe ne peut modifier les données que par les méthodes fournies).
2.) Combinaison des données et des méthodes utilisées pour manipuler les données ensemble en une seule entité (capsule) ... Je pense que la deuxième raison est la réponse que votre enquêteur voulait entendre.
D'autre part, une abstraction est nécessaire pour exposer uniquement les informations nécessaires à l'utilisateur et masquer les détails inutiles (par exemple, masquer l'implémentation de méthodes afin que l'utilisateur ne soit pas affecté si la mise en œuvre est modifiée).
Un programme comprend principalement deux parties: DATA et PROCESS. L'abstraction masque les données en cours afin que personne ne puisse les modifier. L'encapsulation cache des données partout pour qu'elles ne puissent pas être affichées ... J'espère que cela clarifie votre doute.
L'essentiel sur l'abstraction est que le code client fonctionne selon un modèle différent logique/abstrait. Ce modèle différent peut être plus ou moins complexe que l'implémentation ne se trouve dans aucune utilisation client donnée.
Par exemple, "Iterator" résume (ou généralise) le parcours séquencé de 0 ou plusieurs valeurs - en C++, il se manifeste par begin(), */-> (déréférencement), end(), pre/post ++ et éventuellement --, puis il y a +, +=, [] , std::advance etc .. Cela fait beaucoup de bagages si le client peut dire incrémenter un size_t le long d'un tableau de toute façon. L'essentiel est que l'abstraction permette de découpler le code client devant effectuer une telle traversée de la nature exacte du "conteneur" ou de la source de données fournissant les éléments. L’itération est une notion de niveau supérieur qui limite parfois la manière dont la traversée est effectuée (par exemple, un itérateur direct ne peut avancer d’un élément à la fois), mais les données peuvent ensuite être fournies par un ensemble de sources plus important (par exemple à partir d’un clavier où il n'y a même pas de "conteneur" au sens de valeurs stockées simultanément). Le code client peut généralement basculer vers une autre source de données abstraite par le biais de ses propres itérateurs, avec un minimum de modifications, voire aucune modification, et même polymorphiquement vers d’autres types de données, de manière implicite ou explicite, avec un élément tel que std::iterator_traits<Iterator>::value_type available.
Ceci est très différent de l'encapsulation, qui consiste à rendre certaines données ou fonctions moins accessibles, de sorte que vous sachiez qu'elles ne sont utilisées qu'indirectement à la suite d'opérations sur l'interface publique. L'encapsulation est un outil essentiel pour maintenir invariants sur un objet, ce qui signifie tout ce que vous voulez conserver après chaque opération publique - si le code client peut simplement atteindre et modifier votre objet, vous ne pouvez pas appliquer d'invariants. . Par exemple, une classe peut envelopper une chaîne, en s'assurant qu'après chaque opération, les lettres minuscules sont remplacées par des majuscules, mais si le code client peut atteindre et mettre une lettre minuscule dans la chaîne sans l'implication des fonctions membres de la classe, l'invariant ne peut pas être appliqué.
Pour souligner davantage la différence, considérons par exemple un membre de données privatestd::vector<Timing_Sample> qui est chargé accidentellement d'opérations sur l'objet contenant, avec un rapport vidé sur la destruction. L'effet secondaire de données et de destructeur n'interagissant en aucune manière avec le code client de l'objet et les opérations sur l'objet ne contrôlant pas intentionnellement le comportement de chronométrage, il n'y a pas d'abstraction de cette fonctionnalité de génération de rapports de temps mais une encapsulation. Un exemple d'abstraction serait de déplacer le code de synchronisation dans une classe séparée qui pourrait encapsuler vector (le rendre private) et fournir simplement une interface comme add(const Timing_Sample&) et report(std::ostream&) - les opérations logiques/abstraites nécessaires impliquées dans l'utilisation de cette instrumentation, avec le effet secondaire souhaitable que le code extrait sera souvent réutilisable pour un code client ayant des besoins fonctionnels similaires.