Un moyen simple de comprendre l'encapsulation et l'abstraction
Apprentissage de OOP concepts particulièrement intéressés pour comprendre l'abstraction et l'encapsulation en profondeur.
Déjà vérifié le dessous
Abstraction VS Information Cacher VS Encapsulation
différence entre abstraction et encapsulation?
J'ai trouvé très difficile de comprendre ces concepts avec un extrait de code/classe simple et réel.
Un de mes collègues a dit que l’abstraction n’était rien d’autre que de créer un résumé. class et classe normale qui protège sa variable membre avec la portée est appelé Encapsulation.
Existe-t-il un moyen simple de comprendre et d’aider les autres à comprendre ce qu’ils sont exactement, au lieu de répéter ce qui suit?
L'abstraction et l'encapsulation sont des concepts complémentaires: abstraction se concentre sur le comportement observable d'un objet ... encapsulation se concentre sur l'implémentation qui donne lieu à ce comportement ... L'encapsulation est le plus souvent réalisée par la dissimulation d'informations, qui est le processus de dissimulation de tous les secrets d’objet qui ne le sont pas contribuer à ses caractéristiques essentielles.
Abstraction est un processus dans lequel vous affichez uniquement les données «pertinentes» et «masquez» les détails inutiles d'un objet à l'utilisateur. Considérez votre téléphone mobile, vous devez juste savoir sur quels boutons vous devez appuyer pour envoyer un message ou effectuer un appel. utilisateur.
Encapsulation est le processus de combinaison de données et de fonctions dans une seule unité appelée classe. Dans Encapsulation, les données ne sont pas accédées directement; on y accède par les fonctions présentes dans la classe. En termes plus simples, les attributs de la classe sont privés et des méthodes de lecture et de définition publiques sont fournies pour manipuler ces attributs. Ainsi, l’encapsulation rend possible le concept de masquage de données.
Abstraction cache les informations ou ne fournit que les détails nécessaires au client.
par exemple, les freins de voiture: vous savez que presser les pédales arrêtera le véhicule, mais vous n'avez pas besoin de savoir comment cela fonctionne en interne.
Avantages de l'abstraction Demain, si la mise en œuvre du frein change de frein à tambour à frein à disque, en tant que client, vous n'avez pas besoin de changer (votre code ne changera pas).
Encapsulation lie les données et les comportements dans une seule unité . C'est également un mécanisme de langage pour restreindre l'accès à certains composants (ceci peut être réalisé avec des modificateurs d'accès comme privé, protégé, etc.)
Par exemple Classe a des attributs (c'est-à-dire des données) et des comportements (c'est-à-dire des méthodes qui fonctionnent sur ces données)
Un exemple utilisant C #
//abstraction - exposing only the relevant behavior
public interface IMakeFire
{
void LightFire();
}
//encapsulation - hiding things that the rest of the world doesn't need to see
public class Caveman: IMakeFire
{
//exposed information
public string Name {get;set;}
// exposed but unchangeable information
public byte Age {get; private set;}
//internal i.e hidden object detail. This can be changed freely, the outside world
// doesn't know about it
private bool CanMakeFire()
{
return Age >7;
}
//implementation of a relevant feature
public void LightFire()
{
if (!CanMakeFire())
{
throw new UnableToLightFireException("Too young");
}
GatherWood();
GetFireStone();
//light the fire
}
private GatherWood() {};
private GetFireStone();
}
public class PersonWithMatch:IMakeFire
{
//implementation
}
Tout homme des cavernes peut faire un feu, car il implémente le IMakeFire 'feature'. Avoir un groupe de fabricants de feu (liste), cela signifie que Caveman et PersonWithMatch sont des choix valides.
Cela signifie que
//this method (and class) isn't coupled to a Caveman or a PersonWithMatch
// it can work with ANY object implementing IMakeFire
public void FireStarter(IMakeFire starter)
{
starter.LightFire();
}
Vous pouvez donc avoir beaucoup d'implémenteurs avec beaucoup de détails (propriétés) et de comportement (méthodes), mais dans ce scénario, ce qui compte est leur capacité à faire feu. C'est l'abstraction.
Etant donné que faire un feu nécessite quelques étapes (GetWood, etc.), celles-ci sont masquées de la vue car elles constituent une préoccupation interne de la classe. L'homme des cavernes a beaucoup d'autres comportements publics que le monde extérieur peut appeler. Mais certains détails seront toujours cachés car ils sont liés au travail interne. Ils sont privés et n'existent que pour l'objet, ils ne sont jamais exposés. Ceci est encapsulation
L'abstraction est un terme généralisé. L'encapsulation est un sous-ensemble de l'abstraction.
Abstraction est une méthodologie puissante pour gérer des systèmes complexes. L'abstraction est gérée par des objets bien définis et leur classification hiérarchique.
Par exemple une voiture est en soi un objet bien défini, composé de plusieurs autres objets plus petits, tels qu'un système d'engrenage, un mécanisme de direction, un moteur, qui ont à nouveau leurs propres sous-systèmes. Mais pour l'homme, la voiture est un objet unique, qui peut être géré à l'aide de ses sous-systèmes, même si leurs détails internes sont inconnus Avec l'aimable autorisation
Encapsulation: Le regroupement du membre de données et de la méthode dans une seule unité (c'est-à-dire une classe) est appelé Encapsulation.
L'encapsulation, c'est comme enfermer dans une capsule. Cela englobe les opérations et les données liées à un objet dans cet objet.
L'encapsulation est comme un sac dans lequel vous pouvez conserver votre stylo, votre livre, etc. Cela signifie que c'est la propriété d'encapsuler des membres et des fonctions.
class Bag{
book;
pen;
ReadBook();
}
L’encapsulation consiste à masquer les détails internes d’un objet, c’est-à-dire comment un objet fait quelque chose.
L'encapsulation empêche les clients de voir sa vue interne, où le comportement de l'abstraction est implémenté.
L'encapsulation est une technique utilisée pour protéger les informations contenues dans un objet de l'autre objet.
Cachez les données pour des raisons de sécurité, par exemple en rendant les variables privées, et exposez la propriété pour accéder aux données privées qui seraient publiques.
Ainsi, lorsque vous accédez à la propriété, vous pouvez valider les données et les définir . Courtesy
L'abstraction est le processus par lequel vous "jetez" des détails inutiles d'une entité que vous envisagez de capturer/représenter dans votre conception et ne conservez que les propriétés de cette entité qui sont pertinentes pour votre domaine.
Exemple: pour représenter une voiture, par exemple. le modèle et le prix, l'emplacement actuel et la vitesse actuelle et ignorer la couleur et le nombre de sièges, etc.
L'encapsulation est la "liaison" des propriétés et des opérations qui les manipulent dans une seule unité d'abstraction (à savoir une classe).
Ainsi, la voiture aurait accelaratestop qui manipule l'emplacement et la vitesse actuelle etc.
Eh bien, je vais expliquer l'abstraction avec un exemple du monde réel. Supposons que dans votre maison, vous avez une prise électrique et que de nombreux appareils puissent se connecter à la même prise, mais la prise n'aura jamais idée de l'appareil auquel elle est connectée. En d'autres termes, les détails des appareils sont abstraits (cachés) à la prise.
Vous pensez quoi faire si nous connectons un appareil directement à un fil électrique sans prise? Dites que connecter une ampoule directement à un fil, le fil sait à quel appareil il est connecté et chaque fois que nous devons remplacer l'ampoule, nous devons retirer la connexion de fil de l'ampoule, ce qui signifie que l'ampoule est étroitement couplée au fil. En d'autres termes, bulb et wire connaissent les détails auxquels ils sont connectés, ce qui signifie non abstraits.
Dans le monde orienté objet, l'abstraction fonctionne exactement de la même manière. La classe qui consomme d'autres fonctions/propriétés de classes n'a pas besoin de savoir quelle classe de fonctions/propriété est consommée et tout doit être résumé avec une classe d'interface/abstraite.
Laissez-moi coder le même exemple. Ici, j'ai une classe "ElectricPlug", qui exécute un appareil. Mais la classe "ElectricPlug" n'a aucune idée du périphérique sur lequel elle tourne. Cela peut être n'importe quelle classe implémentant l'interface "IDevice", ce qui signifie que l'implémentation de "RunDevice" est extraite de "ElectricPlug". Voici le code complet,
class Program
{
static void Main(string[] args)
{
ElectricPlug electricPlug = new ElectricPlug(new Bulb());
}
}
public class ElectricPlug
{
private readonly IDevice _device;
public ElectricPlug(IDevice device)
{
_device = device;
}
public void Run()
{
_device.Rundevice();
}
}
public interface IDevice
{
void Rundevice();
}
public class Bulb : IDevice
{
public void Rundevice()
{
Console.WriteLine("Switched on bulb");
}
}
L’encapsulation est ce qu’elle ressemble, une façon de mettre une boîte autour de quelque chose pour protéger son contenu. L'abstraction consiste à extraire les propriétés fonctionnelles de quelque chose, de sorte que vous pouvez effectuer des opérations en n'utilisant que ce que vous avez extrait sans connaître le fonctionnement interne.
Lorsque nous disons que deux substances sont des liquides, nous utilisons "liquide" comme une abstraction des propriétés de ces substances que nous choisissons de discuter. Cette abstraction nous dit ce que nous pouvons faire avec les substances étant donné notre expérience antérieure avec les liquides.
L'abstraction n'a rien à voir avec les hiérarchies. Vous pouvez avoir une autre abstraction comme "métaux" qui extrait les propriétés des substances de manière différente.
Les abstractions oublient les détails. Par conséquent, si vous utilisez une abstraction particulière, vous ne devriez pas poser de questions sur les propriétés de la substance sous-jacente qui ne sont pas attribuées à cette abstraction. Par exemple, si vous prenez du lait et de l'eau et que vous les mélangez, vous avez du mal à demander combien de lait vous avez.
Un foncteur est une abstraction sur quelque chose qui a une certaine notion de carte, c'est-à-dire que vous pouvez exécuter une fonction sur son contenu interne qui transforme le bit interne en toute autre chose. L'extérieur reste le même genre de chose.
Ce qui est utile, c’est que si vous avez une fonction qui fonctionne sur les listes et que vous réalisez que vous ne dépendez que de l’interface de la carte, vous pouvez vous fier à Functor. Votre fonction peut alors fonctionner avec des flux, des promesses, des règles tout ce qui partage cette abstraction.
Les langages fonctionnels comme Haskell ont de très grands pouvoirs d'abstraction qui rendent la réutilisation de code extrême pratique.
Abstraction est comme utiliser un ordinateur.
Vous n'avez absolument aucune idée de ce qui se passe au-delà de ce que vous voyez avec l'interface graphique (GUI) et le matériel externe (écran, par exemple). Toutes ces jolies couleurs et autres. Vous ne présentez que les détails qui vous concernent en tant que consommateur générique.
Encapsulation est l'acte réel de cacher les détails non pertinents.
Vous utilisez votre ordinateur, mais vous ne voyez pas à quoi ressemble son processeur (unité de traitement centrale) (à moins que vous n'essayiez de le percer). Il est caché (ou encapsulé) derrière tout ce chrome et ce plastique.
Dans le contexte des langages OOP (programmation orientée objet), vous avez généralement ce type de configuration:
CLASS {
METHOD {
*the actual code*
}
}
Un exemple "d'encapsulation" serait d'avoir une MÉTHODE que l'utilisateur normal ne peut pas voir (privé). "Abstraction" est l’utilisateur régulier utilisant la MÉTHODE qu’il peut (public) pour utiliser l’utilisateur privé.
Abstraction est un moyen de cacher des détails afin de simplifier une interface. _
Ainsi, en prenant une voiture comme exemple, toutes les commandes d'une voiture sont des abstractions. Cela vous permet de conduire un véhicule sans comprendre les détails sous-jacents des systèmes de direction, d'accélération ou de décélération.
Une abstraction good est une abstraction qui normalise une interface sur plusieurs instances d'un problème similaire. Une abstraction grande peut changer une industrie.
Le volant, la pédale de frein et l'accélérateur modernes sont autant d'exemples de grandes abstractions. Au départ, la direction de la voiture ressemblait davantage à la direction de la bicyclette. Et les freins et les manettes des gaz ont été actionnés à la main. Mais les abstractions que nous utilisons aujourd'hui étaient si puissantes qu'elles ont balayé l'industrie.
-
Encapsulation est un moyen de cacher des détails afin de les protéger des manipulations extérieures.
L’encapsulation empêche le conducteur de manipuler la conduite - de la rigidité de la direction, de la suspension et du freinage aux caractéristiques de l’accélérateur et de la transmission. La plupart des voitures ne fournissent pas d'interface pour changer ces choses. Cette encapsulation garantit que le véhicule fonctionnera comme prévu par le fabricant.
Certaines voitures offrent un petit nombre de modes de conduite - luxe, sport et économie - qui permettent au conducteur de modifier simultanément plusieurs de ces attributs. En fournissant des modes de conduite, le constructeur laisse au conducteur un certain contrôle sur l'expérience tout en l'empêchant de choisir une combinaison d'attributs qui rendraient le véhicule moins agréable ou dangereux. De cette manière, le fabricant cache les détails pour éviter les manipulations dangereuses. C'est l'encapsulation.
L'encapsulation peut être considérée comme un papier d'emballage utilisé pour lier des données et fonctionner ensemble comme une seule unité qui le protège de toutes sortes de saletés externes (j'entends des fonctions externes).
L'abstraction implique l'absence de détails et l'utilisation d'une interface simple pour contrôler un système complexe.
Par exemple, on peut allumer une ampoule en appuyant sur un bouton sans se soucier de l’ingénierie électrique sous-jacente (abstraction).
Cependant, vous ne pouvez pas allumer l'ampoule d'une autre manière. (Encapsulation)
abstraction de données: accéder aux données membres et aux fonctions membres de n’importe quelle classe s’appelle simplement abstraction de données .....
encapsulation: Lier des variables et des fonctions ou 1 peut dire que des membres de données ou des fonctions de membre réunis dans une seule unité est appelée encapsulation de données ....
L'abstraction est Afficher les informations nécessaires à l'utilisateur, où Encapsulation masque les données non souhaitées à l'utilisateur (Produit de l'utilisateur).
Encapsulation implémente l'abstraction.
L'abstraction est le processus où Encapsulation l'implémente réellement . For Eg. Ajout de la logique utilisateur -> nous devons valider l'utilisateur, créer une connexion à la base de données et insérer l'utilisateur. Ainsi, l'utilisateur ne sait pas qu'il faut d'abord appeler la fonction de validation, créer une connexion à la base de données, puis insérer la valeur dans la base de données. Il appelle uniquement la fonction AddUser qui appelle la logique interne de toute la logique, il ne s'agit que d'Encapsulation (regroupement de la fonctionnalité et masquage des méthodes).
Abstraction des données : DA filtre simplement l'élément concret. Par classe, nous pouvons atteindre l'abstraction pure, car avant de créer la classe, nous ne pouvons penser qu'aux informations relatives à la classe.
Encapsulation : C'est un mécanisme par lequel nous protégeons nos données de l'extérieur.
public abstract class Draw {
public abstract void drawShape(); // this is abstraction. Implementation detail need not to be known.
// so we are providing only necessary detail by giving drawShape(); No implementation. Subclass will give detail.
private int type; // this variable cannot be set outside of the class. Because it is private.
// Binding private instance variable with public setter/getter method is encapsulation
public int getType() {
return type;
}
public void setType(int type) { // this is encapsulation. Protecting any value to be set.
if (type >= 0 && type <= 3) {
this.type = type;
} else {
System.out.println("We have four types only. Enter value between 0 to 4");
try {
throw new MyInvalidValueSetException();
} catch (MyInvalidValueSetException e) {
e.printStackTrace();
}
}
}
}
Abstraction est associé à des méthodes pour lesquelles les détails de la mise en œuvre ne sont pas connus, ce qui est une sorte de dissimulation de la mise en œuvre.Encapsulation est liée à une variable d'instance liée à la méthode, un type de masquage de données.