Encapsulation vs masquage de données - Java
Interviewer: Qu'est-ce que l'encapsulation et comment y parvenir en Java?
Me: Encapsulation est un mécanisme permettant de masquer des informations au client. Les informations peuvent être des données ou une mise en œuvre ou un algorithme. Nous y parvenir à l'aide de modificateurs d'accès.
Intervieweur: Ceci cache des données. Comment pouvons-nous réaliser l'encapsulation en Java?
Moi : uummmm
Question concrète: Hormis les modificateurs d'accès, comment implémenter l'encapsulation en Java?
Plus généralement, encapsulation désigne simplement le regroupement des données (par exemple d'un objet) avec les opérations sur ces données. Vous avez donc une classe encapsulant des données - champs - avec les méthodespour manipuler ces données.
Mais l’encapsulation est aussi parfois utilisée de la même manière que votre réponse, et l’un des avantages du regroupement de données et de méthodes est de masquer la mise en oeuvre.
Je suppose une meilleure réponse que utilisez simplement des méthodes et rendez tous les champs privés est: utilisez des interfaces. Ainsi, les opérations sur un objet sont purement basées sur le contrat d'interface et ne sont aucunement liées aux champs ou aux méthodes d'assistance utilisées pour implémenter ce contrat en interne.
Encapsulation
En général Encapsulation signifie regrouper des éléments similaires, aussi simple que cela.
Par exemple, prenons une classe Student dans laquelle nous aurons des variables d’instance et des comportements/méthodes des élèves agissant sur ces variables d’instance à un endroit.
Pourquoi c'est important? Nous ne voulons pas que notre code soit disséminé dans notre code Base.
Si nous disons que nous devons apporter des modifications, nous devons trouver les variantes (de ces modifications) à tous les endroits. En regroupant des éléments similaires, nous évitons simplement de tels scénarios et cela contribue également à rendre notre code Bundled plus ciblé.
Masquage des données
Il fournit simplement un moyen de protéger vos données du monde extérieur. Disons que si je rendais mon variable d'instance publique, tout le monde peut en changer l'état. Mais si nous rendons notre variable d'instance privée/protégée, nous empêchons en réalité des entités extérieures d'y apporter des modifications.
Comparaison/discussion
Maintenant, la question se pose de savoir en quoi nous protégeons nos variables.
Encore une fois, nous devons comprendre que Encapsulation est simplement le conteneur dans lequel nous devons placer nos articles similaires.
Son juste agir comme une Black Box au monde extérieur. En dehors du monde (je veux dire clients/consommateurs: en utilisant notre classe Student), je ne connais pas les détails internes/détails d'implémentation de la classe Student et, en réalité, ils ne devraient pas se soucier des détails internes/d'implémentation de la classe. Ils veulent juste des méthodes/API afin de pouvoir les utiliser dans leur application cliente.
Donc, mon point est que tous les comportements/variables liés aux élèves sont placés dans une boîte noire que nous appelons cela en tant que classe. Maintenant, il appartient au concepteur de la classe quels sont les éléments de la classe qui doivent être cachés et ce qui ne doit pas être caché du monde extérieur.
Revenons maintenant à la question. En Java: nous rendons nos variables privées, cela signifie qu'elles sont protégées par une classe. Si nous voulons que nos variables d'instance soient accessibles dans tout le package, elles sont protégées par le package. Tout au long du projet, ils sont publics. Donc, ce que je veux dire, c’est que pour cacher des données, il vous faut une sorte de conteneur dans lequel vous placerez vos données et que vous cacherez par rapport à un conteneur.
Donc, ce que je ressens Cacher des données n’est pas possible sans Encapsulation . Vous ne pouvez pas cacher vos données sans les mettre dans un conteneur. Encore une fois, je vous rappelle que je mets ceci dans le contexte du langage orienté objet.
Mais oui L'encapsulation est possible sans cacher vos données. Mettez toutes les choses en public et vous pouvez voir l'effet.
Encapsulation: Prenons l'exemple d'une capsule. Si vous l'ouvrez, il contient beaucoup d'ingrédients. Encapsulation de programmation orientée objet est également comme ça. Comme son nom l'indique, "Encapsulation" consiste à encapsuler (en faire une capsule) tous les membres de données, attributs et méthodes correspondantes dans une seule capsule.
Comment faites-vous: Disons que vous avez créé une classe nommée "Car". Maintenant, la voiture a un prix et un modèle de couleur. Ce sont des attributs, et il a une méthode d'exécution. Donc, ici, vous avez encapsulé tous ces attributs et méthodes d’un véhicule nommé "Voiture". Lorsque vous créez une instance de car like so
Car myCar = new Car();
Vous pouvez accéder à tous les attributs de Car à l'aide de la variable myCar.
" Masquage des données ": le masquage des données est contrôlé en Java à l'aide de modificateurs d'accès. Pour accéder aux données membres, vous utilisez ACCESSORS tout en modifiant les données, vous utilisez " Mutators ". Java ne fournit pas d’accesseurs ni de mutateurs, vous les créez vous-même (getters et setters). Alors que C # fournit les propriétés pour le faire.
Je déteste faire cela mais, de Wikipedia :
Dans les langages de programmation, l’encapsulation est utilisée pour faire référence à l’un des deux notions apparentées mais distinctes, et parfois à la combinaison dont:
- Un mécanisme de langage pour restreindre l'accès à certains composants de l'objet.
- Une construction de langage qui facilite le regroupement de données avec les méthodes (ou d'autres fonctions) opérant sur ces données
Votre explication allait plus dans le sens de la première notion, l'intervieweur cherchait quelque chose sur la seconde.
L'encapsulation de données fait référence au mécanisme consistant à conserver toutes les propriétés et la méthode liées dans une seule entité.
Exemple: Une voiture. Il conserve les roues directrices, les pneus, le moteur et tous les éléments connexes dans une seule entité collective appelée Car.
Dans les langages de programmation, encapsulation est obtenu avec classes. Une classe contient toutes les propriétés et méthodes associées dans one single entity conçue pour effectuer une tâche spécifique.
Données masquant fait référence à masquant les détails sans importance de l'utilisateur et ne lui montre que les données pertinentes.
Exemple: lorsque nous appuyons sur les freins ou l'accélérateur dans une voiture, nous ne savons pas ce qui se passe derrière la scène (comment sa vitesse augmente ou comment son application des freins sur les pneus). Tout ce que nous savons, c'est que nous disposons des freins et de l'accélérateur pour obtenir le résultat souhaité.
En programmation, cela se fait à l'aide de modificateurs d'accès. Les membres Private sont non accessibles de l'extérieur de la classe et seuls les membres public sont accessibles aux utilisateurs. Les membres privés ne sont accessibles qu’à partir de membres de la classe, fournissant ainsi le security permettant aux membres privés d’être directement évalués depuis l’extérieur de la classe.
La question semble trompeuse, je doute que quelqu'un d'autre que l'intervieweur puisse éventuellement y répondre et il y a de fortes chances que sa réponse soit fausse. Plus important encore, on ignore ce que la question est censée évaluer ou découvrir.
Pourtant, j’y ai réfléchi et voici ce qui, à mon avis, pourrait être ma tentative de répondre à la question.
Avec modificateurs d'accès
En Java, l’encapsulation est implémentée en masquant des détails à l’aide des modificateurs d’accessibilité (à savoir public, protected, private, etc.). Avec ces niveaux d’accessibilité, vous contrôlez le niveau de masquage des informations. Moins le niveau est restrictif, plus la modification est coûteuse quand elle se produit et plus la classe est couplée à d’autres classes dépendantes (classes d’utilisateur, sous-classes).À l’évidence, l’encapsulation est plus que la dissimulation d’un état. En Java, vous pouvez masquer des classes et des interfaces entières, ainsi que leur état et leurs comportements, en masquant ainsi les détails de la mise en œuvre d'une API complète.
Par exemple, la méthode Arrays.asList() renvoie une implémentation List, mais nous ne nous soucions pas de quelle implémentation, tant qu'elle répond à l'interface publique List, non? L'implémentation peut être changée à l'avenir sans nous affecter, les utilisateurs de la méthode, mais l'implémentation réelle nous est cachée.
Jusqu'ici, il semblerait que l'encapsulation dépend entièrement de la capacité d'un langage de programmation à masquer des détails, et par conséquent, cela ne pourrait pas être réalisé sans modificateurs d'accès, n'est-ce pas?
Sans modificateurs d'accès
Cependant, comment un langage comme Python réalise-t-il l’encapsulation alors qu’il n’a pas de modificateurs d’accès? Tout est public en Python? Cela signifie-t-il que l'encapsulation n'est pas possible?
Que se passe-t-il si, par convention, nous définissons l'interface publique de nos composants et n'accédons ensuite à l'état et au comportement des objets que par l'intermédiaire de leur interface publique? Évidemment, pour cela, nous avons besoin d’une compréhension claire des abstractions dans notre domaine de problèmes et de la façon dont elles sont censées être consommées par nos utilisateurs.
Pour moi, il me semble que la question de l’entrevue visait à évaluer l’encapsulation en tant que concept plus large, dépendant de la définition d’abstractions très claires, et non pas simplement en tant que sous-produit d’une caractéristique linguistique comme les modificateurs d’accès.
Le rôle de l'abstraction
C'est pourquoi, à mon avis, pour bien comprendre l'encapsulation, il faut d'abord comprendre l'abstraction.
Pensez, par exemple, au niveau d'abstraction dans le concept de voiture. Une voiture est complexe dans sa mise en œuvre interne. Ils ont plusieurs sous-systèmes, comme un système de transmission, un système de freinage, un système de carburant, etc.
Cependant, nous avons simplifié son abstraction et nous interagissons avec toutes les voitures du monde via l'interface publique de leur abstraction. Nous savons que toutes les voitures ont un volant dans lequel nous contrôlons la direction, elles ont une pédale qui accélère et contrôle la vitesse de la voiture, et une autre qui dit que lorsque vous appuyez sur cette touche, vous la bloquez et que vous avez un levier de vitesse qui vous permettent de contrôler si vous avancez ou reculez. Ces caractéristiques constituent le interface publique} de l'abstraction de la voiture. Le matin, vous pouvez conduire une berline, puis en sortir et conduire un SUV dans l'après-midi, comme si c'était la même chose.
Ce n’est pas que vous ne pouvez pas ouvrir le capot et voir comment tout cela fonctionne. Cependant, peu d'entre nous connaissent les détails de la mise en œuvre de toutes ces fonctionnalités sous-jacentes, et la vérité est que nous n'avons pas besoin de connaître ces détails pour conduire une voiture. Toutes ces choses sont encapsulées sous l'abstraction de la voiture. Nous avons seulement besoin de connaître l'interface publique de l'abstraction.
Pensez au temps où les voitures n’avaient pas de système directionnel hydraulique. Un jour, les constructeurs automobiles l’ont inventé et ils ont décidé de l’intégrer dans les voitures à partir de là. Néanmoins, cela n'a pas changé la manière dont les utilisateurs interagissaient avec eux. Tout au plus, les utilisateurs ont constaté une amélioration de l'utilisation du système directionnel. Un tel changement était possible parce que la implémentation interne d'une voiture était encapsulée.
Cela montre clairement qu'en masquant les détails de la manière dont les systèmes directionnels ont été mis en œuvre, ils pourraient le modifier en toute sécurité sans affecter l'interface publique de la voiture et, partant, sans affecter la manière dont les utilisateurs interagi avec elle.
Maintenant, imaginez que les constructeurs automobiles aient décidé de placer le bouchon du réservoir de carburant sous la voiture et non sur l’un de ses côtés. Vous achetez une de ces nouvelles voitures et lorsque vous tombez en panne d'essence, vous allez à la station-service et vous ne trouvez pas le bouchon. Tout à coup, vous vous rendez compte que vous êtes sous la voiture, mais vous ne pouvez pas l'atteindre avec le tuyau de la pompe à essence. Maintenant, nous avons rompu le contrat d’interface publique et, par conséquent, le monde entier s’écroule, il tombe en morceaux parce que les choses ne fonctionnent pas comme prévu. Un changement comme celui-ci coûterait des millions. Nous aurions besoin de changer toutes les pompes à essence dans le monde. Lorsque nous cassons l'encapsulation, nous devons payer un prix.
Comme vous pouvez le constater, l’encapsulation a pour objectif de {minimiser l’interdépendance et faciliter le changement}. Vous maximisez l'encapsulation en minimisant l'exposition des détails d'implémentation. L'état d'une classe ne doit être accessible que via son interface publique.
La beauté de l’encapsulation réside dans le {pouvoir de changer des choses sans toucher ses utilisateurs}.
Nous pourrions dire que cet objectif ultime dépend d'une planification et d'une conception soigneuses. En Java, les modificateurs d'accès sont un moyen de donner vie à ces idées, mais dans un langage où cette fonctionnalité n'existe pas, il est également possible de réaliser une encapsulation.
We could say that this ultimate goal depends on careful planning and design. In Java, access modifiers are a way to bring these ideas to life, but in language where this feature does not exist, it is equally possible to achieve encapsulation.
En principe, l'encapsulation de données est un processus alors que le masquage de données est une technique . Dans l'encapsulation, les données peuvent être publiques ou privées, mais dans le masquage de données, les données sont uniquement privées. Ainsi, le masquage des données utilise Encapsulation, mais il utilise également différentes techniques pour que les données ne soient autorisées que pour un accès autorisé . J'espère que cela aidera!
Dans la classe, les attributs et les comportements sont placés ensemble. Une encapsulation signifie que lorsque vous créez une classe, cela signifie que vous réalisez le principe d'encapsulation. Parce que les données et les comportements sont encapsulés dans la classe. La dissimulation de données est donc une partie importante du terme - encapsulation. Et cela signifie des points d'accès de l'objet.
- ENCAPSULATION est le regroupement des données (champs) et du comportement (méthodes) dans des classes.
- Vous devez maintenant fournir un contrôle d'accès sur les données à l'aide de modificateurs d'accès (privé/protégé/public ou par défaut), ce qui correspond à DATA HIDING . Il protège les données du monde extérieur où vous ne souhaitez pas fournir l'accès.
- De plus, afin de cacher la complexité des opérations, vous devez utiliser des interfaces pour obtenir ABSTRACTION.
La définition la plus simple de l'encapsulation est "Relier les données et le code qui exploite les données dans une seule unité", de sorte que les données ne puissent pas être consultées directement par le monde extérieur.
Dans un langage de structure tel que c, les données sont déclarées au début du bloc et utilisées directement, accessibles ouvertement (tous les tom, dick et harry peuvent accéder aux données) . Le masquage de données est un concept permettant de limiter Dick et Harry.
L’encapsulation est l’un des moyens de masquer les données . Vous pouvez masquer les données en regroupant des données et des fonctions (Encapsulation).
Comment réaliser en Java, voyez tous les exemples de fonction getter (), setter () en Java .
Encapsulation signifie que les membres de données et la méthode (comportement) sont liés dans une seule unité et que vous pouvez dire [encapsulation = masquage des données + abstraction] autant d'informations utiles que nécessaire.
La classe est un élément entièrement encapsulé en Java
Cacher des données signifie que vous déclarez que les variables de données sont privées pour les protéger contre tout accès non autorisé, mais que vous donniez une méthode de définition publique et une méthode de lecture publique à la validation.
Comme je le vois, Encapsulation renvoie à l’idée de données de liaison et méthode à un single unité appeléeclass. Cependant, il existedeux critères principauxpour lier des données et des méthodes. L'un d'entre eux est la dissimulation d'informations, mais pas le seul. Pour être parfaitement concis je dirais que les deux critères principaux sont
- Couplage faible (assurer en dissimulant des informations)
- Haute cohésion
Encapsulation: L’encapsulation est l’un des piliers de OOPS, elle est également super-active pour les deux autres termes, masquage et abstraction des données. (Cacher les données, comme le terme le désigne. Les données ne peuvent être stockées que dans des variables. Pour cacher les données du monde externe, nous utilisons le concept de masquage de données. Public, privé, protégé. Ce sont trois modificateurs d'accès qui nous sont fournis pour le masquage de données. La valeur par défaut est limité à package. Protégé limité à la classe héritée.) ** Les variables privées ne sont accessibles qu'à l'intérieur de la classe, ce qui signifie que s'il existe une classe interne, les variables privées peuvent également être appelées directement. Seules les classes internes statiques peuvent appeler des variables statiques.
J'arrive maintenant à l'abstraction (ce qui signifie intangible). L'abstraction est également considérée comme le processus permettant de masquer l'implémentation à l'utilisateur et de ne fournir que le résultat final. Exemple: nous avons une classe de personnes qui a la propriété «Poids». Cette propriété est assez délicate car nous ne pouvons accepter moins de 0% de poids pour une personne. De plus, nous ne pouvons pas accepter plus de 500 kg. Donc, masquer l'implémentation de ceux-ci sera dans la méthode setter. L'abstraction est ce qui cache les détails de la mise en œuvre.
** Et le package complet, c’est-à-dire rendre l’objet privé et mettre en œuvre la logique dans setter et getter, est appelé ENCAPSULATION.
J'ai vu beaucoup de discussions déjà entamées, pour simplifier, si j'ai bien compris:
Encapsulation Garantit que le comportement d'un objet ne peut être affecté que par son API . Il nous permet de contrôler l'impact qu'une modification apportée à un objet aura sur d'autres parties du système il n'y a pas de dépendances inattendues entre composants non liés. Le modificateur d'accès peut être utilisé pour réaliser Encapsulation.
Cacher les informations Cache la façon dont un objet implémente ses fonctionnalités derrière l'abstraction De son API. Cela nous permet de travailler avec des abstractions plus élevées en ignorant les détails de niveau inférieur, qui ne sont pas liés à la tâche à accomplir. L'abstraction au niveau de la conception peut être utilisée pour dissimuler des données.
Le processus de définition d'une classe en cachant ses données d'un accès direct au membre de classe extérieur et en fournissant l'accès uniquement par le biais d'une méthode de définition et d'accesseur accessible au public via une validation appropriée est appelé Encapsulation.
Encapsulation L'encapsulation est un concept de programmation orienté objet qui lie les données et les fonctions qui manipulent les données, et qui protège à la fois des interférences extérieures et des utilisations abusives. Les données L’encapsulation a conduit à l’important concept OOP de dissimulation de données.
Si une classe n'autorise pas le code appelant à accéder aux données d'objet internes et ne permet l'accès que par des méthodes, il s'agit d'une forme forte de abstraction ou dissimulation d'informations connue sous le nom d'encapsulation. Certains langages (Java, par exemple) permettent aux classes d'appliquer des restrictions d'accès explicitement, par exemple en désignant des données internes avec le privé mot clé et méthodes de désignation destinés à être utilisés par du code situé en dehors du classe avec le mot clé public. Les méthodes peuvent aussi être conçues pour le public, niveaux privés ou intermédiaires tels que protected (qui autorise l'accès de la même classe et de ses sous-classes, mais pas des objets d'une autre classe ). Dans d'autres langages (comme Python), ceci n'est imposé que par convention (par exemple, les méthodes privées peuvent avoir des noms qui commencent par par un trait de soulignement). L'encapsulation empêche le code externe d'être concerné par le fonctionnement interne d'un objet. Cela facilite refactoring de code, permettant par exemple à l'auteur de la classe de changer la façon dont les objets de cette classe représentent leurs données en interne sans changer de code externe (tant que les appels de méthode "publics" fonctionnent de la même manière). Cela encourage également les programmeurs à mettre tout le code qui concerne un certain ensemble de données dans la même classe, qui organise pour faciliter la compréhension par les autres programmeurs . L'encapsulation est une technique qui encourage le découplage.
Le processus de liaison des éléments de données et des méthodes correspondantes dans une seule unité n’est autre que l’encapsulation.
Encapsulation = Masquage des données + Abstraction
L'abstraction dit que ce qui devait interagir avec l'objet.
Encapsulation signifie encapsuler les propriétés, l'état et les comportements des objets dans une seule unité logique appelée classe.
Le masquage des données indique que masquer l'implémentation interne des objets désigne les méthodes et propriétés privées, les objets utilisés pour conserver leur état.
Cacher des données signifie que nous assurons la sécurité des données au sein de la classe.
Abstraction signifie cacher le code en définissant des fonctions membres.
L'encapsulation est la combinaison de l'abstraction et de la dissimulation de données, ce qui signifie que nous sommes encapsuler les données et le code associé à ces données. Pour la classe ex de haricot
class student {
private int age; // Data Hiding
public setAge(){} // Abstraction
public getAge(){} // Abstraction
}
la classe d'étudiants est encapsulée.
encapsulation = masquage des données + abstraction