Différence entre abstraction et encapsulation?
Quelle est la différence précise entre encapsulation et abstraction?
La plupart des réponses ici se concentrent sur OOP 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 d'un plan: il masque les détails de la mise en œuvre. C'est 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, bien que relativement apparentés. L’exemple classique d’abstraction est la fonction
qsortde C pour trier les données:La chose à propos de
qsortest qu’elle ne se soucie pas des données qu’elle trie - en fait, elle ne sait pas quelles sont les données qu’elle trie. Son type d’entrée est plutôt un pointeur sans type (void*), ce qui est simplement une façon pour C de dire: «Je ne me soucie pas du type de données» (on parle également de type effacement). Le point important est que l'implémentation deqsortreste toujours la même, quel que soit le type de données. La seule chose que a à modifier 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 en tant qu'argument de fonction.
L'encapsulation et l'abstraction vont de pair si bien qu'on pourrait dire qu'elles sont vraiment inséparables. Pour des raisons 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 abstenons pas matériellement, au-delà du regroupement logique.
Et voici un exemple d’abstraction qui n’est pas une encapsulation:
T pi<T> = 3.1415926535
Ceci est 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 bien du mal à trouver quelque chose comme cela dans le code réel: l’abstraction utilise presque toujours l’encapsulation. Cependant, les existe ci-dessus existent réellement en C++ (14), via modèles de variable (= 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};
Encapsulation masque les détails de l'implémentation, qu'il s'agisse ou non de comportements génériques ou spécialisés.
Abstraction fournit une généralisation (par exemple, sur un ensemble de comportements).
Voici une bonne lecture: Abstraction, encapsulation et dissimulation d'informations par Edward V. Berard de Object Agency.
l'encapsulation met certaines choses dans une boîte et vous donne un judas; cela vous évite de vous perdre avec les engrenages.
l’abstraction ignore totalement les détails qui n’importent pas, comme si les choses ont des engrenages, des rochets, des volants-moteurs ou des noyaux nucléaires; ils viennent "partir"
exemples d'encapsulation:
- caleçon
- boîte à outils
- portefeuille
- sac à main
- capsule
- carbonite congelée
- une boîte avec ou sans bouton
- un burrito (techniquement, la tortilla autour du burrito)
exemples d'abstraction:
- "groupes de choses" est une abstraction (que nous appelons l'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 d'encapsulation. Un panier, par exemple, est un conteneur qui n’encapsule pas son contenu.
Beaucoup de réponses et leurs exemples sont trompeurs.
Encapsulation est le regroupement de données et fonctions fonctionnant sur ces données dans un seul composant et restreint l'accès à certains composants de l'objet.
Encapsulation signifie que la représentation interne d'un objet est généralement masquée hors de la définition de l'objet.
Abstraction est un mécanisme qui représente les fonctionnalités essentielles sans inclure les détails de la mise en œuvre.
Encapsulation:-- Cacher les informations.
Abstraction:-- Dissimulation de l'implémentation.
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 la classe foo est masquée en dehors de la classe. -> Encapsulation.
Tout membre accessible (données/fonction) d'un objet de foo est restreint et n'est accessible que par cet objet.
foo foo_obj(3, 4);
int sum = foo_obj.add();
L'implémentation de la méthode add est masquée. -> Abstraction.
Encapsulation signifie masquer des données, telles que l'utilisation de getter et setter, etc.
Abstraction signifie cacher une implémentation en utilisant des classes abstraites et des interfaces, etc.
L'abstraction est un terme généralisé. L'encapsulation est un sous-ensemble de l'abstraction.
- L'abstraction vous permet de vous concentrer sur ce que fait l'objet au lieu de le faire.
- L'encapsulation signifie cacher les détails internes ou la mécanique de la manière 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 cette pédale car elle est encapsulée.
Laissez-moi vous donner un exemple en C #. Supposons que vous ayez un entier:
int Number = 5;
string aStrNumber = Number.ToString();
vous pouvez utiliser une méthode telle que Number.ToString () qui vous renvoie une représentation en caractères du nombre 5 et la stocke dans un objet chaîne. La méthode vous dit ce qu'elle fait au lieu de savoir comment.
Beaucoup de bonnes réponses sont fournies ci-dessus, mais je vais présenter mon point de vue (Java) ici.
Data Encapsulation signifie simplement encapsuler et contrôler l'accès aux données groupées logiquement dans une classe. Il est généralement associé à un autre mot clé - Data Hiding. Ceci est réalisé en Java en utilisant modificateurs d'accès .
Un exemple simple consisterait à définir une variable privée et à y accéder à l’aide de méthodes getter et setter ou à rendre une méthode privée car elle n’est utilisée que par la classe. Il n'est pas nécessaire que l'utilisateur connaisse ces méthodes et ces variables.
Note: Il ne faut pas se méprendre sur le fait que l'encapsulation consiste uniquement à cacher des données. Lorsque nous parlons d’encapsulation, l’accent doit être mis sur le regroupement, l’emballage ou le regroupement de données et de comportements associés.
Data Abstraction, en revanche, est un concept de généralisation afin que la logique complexe sous-jacente ne soit pas exposée à l'utilisateur. En Java, ceci est réalisé en utilisant interfaces et abstract classes.
Exemple -
Disons que nous avons un interface Animal et qu'il a 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 (). Maintenant, disons 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 incombe à l’utilisateur d’imprimer le son de l’animal. Une méthode brutale consiste à vérifier l'objet reçu pour identifier son type, puis typecast pour qu'il soit de type Animal, puis call makeSound (). Mais une manière plus ordonnée consiste à résumer des choses. Utilisez Animal comme référence polymorphe et appelez-le makeSound (). Lors de runtime, la fonction invoquée correspond au type d'objet réel.
Plus de détails ici .
Une logique complexe se trouve dans la carte de circuit imprimé qui est encapsulée dans un pavé tactile et une interface de Nice (boutons) est fournie pour la résumer à l'utilisateur.
PS: Les liens ci-dessus sont vers mon blog personnel.
Encapsulation : masque les détails d'implémentation non désirés/non attendus/de propriété des utilisateurs réels de l'objet . E.g.
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 fournir une généralisation et donc une manière commune 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 abstraction et 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.
Pensez à une classe qui envoie un courrier électronique ... elle utilise l'abstraction pour se présenter à vous comme une sorte de messager, de sorte que vous pouvez appeler emailSender.send (mail, destinataire). Ce qu’il fait réellement - choisir POP3/SMTP, les serveurs d’appel, la traduction MIME, etc., est extrait. Vous ne voyez que votre messager.
Encapsulation: L'idée de sécuriser et de cacher des données et des méthodes qui sont privées à un objet. Il s'agit davantage de créer quelque chose d'indépendant et infaillible.
Prends-moi, par exemple. J'encapsule mon rythme cardiaque du reste du monde. Parce que je ne veux pas que quelqu'un d'autre change cette variable, et je n'ai besoin de personne pour la configurer afin que je puisse fonctionner. C'est d'une importance vitale pour moi, mais vous n'avez pas besoin de savoir ce que c'est et vous ne vous en souciez probablement pas.
Regardez autour de vous, vous constaterez que presque tout ce que vous touchez est un exemple d'abstraction et d'encapsulation. Par exemple, votre téléphone vous présente l’abstraction de pouvoir prendre ce que vous dites et le dire à quelqu'un d’autre - dissimulant le GSM, l’architecture du processeur, les fréquences radio et un million d’autres choses que vous ne comprenez pas ou que vous ne voulez pas. Il encapsule également certaines données vous concernant, telles que 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. Regardons l'exemple de l'allumage 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 du guichet automatique. Le client n'a pas besoin de savoir comment la machine lit le PIN et traite la transaction, il n'a qu'à entrer le code PIN, prendre l'argent et partir.
Encapsulation: Traite avec cacher les données sensibles d'une classe donc en privatisant une partie. C'est un moyen de garder certaines informations privées à ses clients en leur interdisant l'accès de l'extérieur.
AbstractionetEncapsulationen utilisant un seul exemple généralisé
---------------------------------------------------- -------------------------------------------------- ----------------------------------
Nous utilisons tous la calculatrice pour le calcul de problèmes complexes!
Un autre exemple:
Supposons que je crée une classe Rectangle immuable comme ceci:
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é largeur et hauteur (l'accès est en quelque sorte restreint), mais je n'ai pas résumé quoi que ce soit (d'accord, j'ai peut-être ignoré l'emplacement du rectangle dans l'espace de coordonnées , mais c’est un défaut de l’exemple).
Une bonne abstraction implique généralement une bonne encapsulation.
Un exemple d'abstraction correcte est une classe de connexion de base de données générique. Son interface publique ne dépend pas de la base de données, elle est très simple et me permet néanmoins de faire ce que je veux avec la connexion. Et vous voyez? Il y a aussi une encapsulation, car la classe doit avoir tous les descripteurs et appels de bas niveau à l'intérieur.
Abstraction: Abstraction signifie montrer What partie de la fonctionnalité.
Encapsulation: Encapsulation signifie masquer la partie How 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 de l'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);
}
}
On appelle " encapsulation de données" un mécanisme qui empêche les données d'un objet particulier de ne pas être utilisées de manière intentionnelle ou accidentelle par des fonctions externes.
L'acte de représenter des caractéristiques essentielles sans inclure les détails de l'arrière-plan ou les explications est connu sous le nom de abstraction
Prenons l'exemple d'une pile. Cela pourrait être implémenté en utilisant un tableau ou une liste chaînée. Mais les opérations qu’il supporte sont Push et Pop.
Now abstraction n'expose que 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 extraites? C’est là que encapsulation entre en jeu. Par exemple, les classes en C++ utilisent les spécificateurs d’accès permettant d’empêcher tout accès et toute modification accidentels. De plus, en rendant les interfaces susmentionnées publiques, cela garantit que le seul moyen de manipuler la pile consiste à utiliser 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). En d'autres termes, le code et les données sont liés, liés ou encapsulés.
Abstraction --- masquer l'implémentation - à la conception --- Utilisation des classes Interface/Abstract
Encapsulation - Cacher des données --At développement --- Utilisation de modificateurs d'accès (public/privé)
L'encapsulation englobe la complexité dans une capsule qui est une classe et donc une encapsulation… .__ Alors que l'abstraction est la caractéristique d'un objet qui se différencie des autres….
L'abstraction peut être obtenue en rendant la classe abstraite ayant une ou plusieurs méthodes abstraites. Ce qui n’est rien d’autre que la caractéristique qui devrait être mise en œuvre par la classe qui l’élargit. Lorsque vous inventez/concevez une voiture, vous définissez des caractéristiques telles qu'une voiture devrait avoir 4 portes, une ouverture, un volant, etc. L'implémentation n'est pas la tête de l'abstraction. Il ne fera que définir les caractéristiques qui devraient être incluses.
L’encapsulation est réalisée en conservant les données et le comportement dans une capsule de classe en utilisant des modificateurs d’accès tels que public, privé, protégé ainsi que l’héritage, l’agrégation ou la composition. Donc, vous ne montrez que les choses requises, cela aussi, seulement dans la mesure où vous voulez le montrer. c'est-à-dire ka funda publique, protégée, conviviale et privée …… GM décide d'utiliser le design abstrait de la voiture ci-dessus. Mais ils ont différents produits ayant les mêmes caractéristiques et fonctionnant presque de la même manière. 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, les freins ou la direction. Les produits individuels peuvent sûrement avoir plus de fonctionnalités telles que la climatisation, le verrouillage automatique, etc.
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.
Je vais essayer de démontrer l'encapsulation d'une manière simple .. Voyons voir ..
- Le regroupement de données et de fonctions dans une seule unité (appelée classe .__) est appelé encapsulation. Encapsulation contenant et masquant les informations Sur un objet, telles que les structures de données internes et le code
L'encapsulation est -
- Cacher la complexité,
- Reliant Données et Fonction ensemble,
- Rendre la méthode compliquée privée,
- Rendre privé la variable d'instance,
- Masquer les données et les fonctions inutiles de l'utilisateur final.
Encapsulation implémente l'abstraction.
Et l'abstraction est -
- Montrer 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 utilisateur graphique intitulée "Les 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 de clientèle.
Étape 1: De quoi ma classe de clientèle a-t-elle besoin?
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 du client dans la base de données.
namespace CustomerContent { Classe publique Customer { Chaîne publique CustomerCode = ""; Chaîne publique CustomerName = ""; .//mon code de base de données ira ici }
Maintenant, seule la méthode ADD ne fonctionnera pas ici seule.
Étape -2: Comment la validation fonctionnera-t-elle, fonction ADD?
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 d’afficher 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 va ajouter 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 compliquées et supplémentaires privées au lieu de public (masquer ces méthodes) et supprimer obj.Validate (); obj.CreateDBObject (); du programme principal en classe, nous réalisons l’encapsulation.
En d'autres termes, simplifier l'interface pour l'utilisateur final est l'encapsulation.
Alors maintenant, le code ressemble à celui 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 ma classe de clientèle a-t-elle besoin? 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 Encapsulation.
P.S. - Le code ci-dessus est dur et rapide.
De ceci
Différence entre encapsulation et abstraction dans OOPS
L'abstraction et l'encapsulation sont deux concepts importants de la programmation orientée objet (OOPS). Encapsulation et Abstraction sont des termes interdépendants.
Différence réelle entre encapsulation et abstraction
Encapsuler signifie cacher. L'encapsulation est aussi appelée masquage de données. Vous pouvez penser à une encapsulation comme une capsule (un comprimé de médicament) qui cache un médicament à l'intérieur. L'encapsulation est un enveloppement qui ne fait que masquer des propriétés et des méthodes. L'encapsulation est utilisée pour cacher le code et les données dans une seule unité afin de protéger les données de l'extérieur. La classe est le meilleur exemple d'encapsulation.
L'abstraction consiste à ne montrer 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 des classes abstraites. La classe abstraite représente une vue abstraite des méthodes et des propriétés de la classe.
Différence de mise en oeuvre entre encapsulation et abstraction
L'abstraction est implémentée à l'aide d'une interface et d'une classe abstraite, tandis que Encapsulation est implémentée à l'aide d'un modificateur d'accès privé et protégé.
OOPS utilise l'encapsulation pour imposer 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 de fonctions prédéterminé peut accéder aux données. Le terme collectif pour les types de données et les opérations (méthodes) associées aux restrictions d'accès (public/privé, etc.) est une classe.
Le paragraphe ci-dessous m'a aidé à comprendre en quoi elles diffèrent les unes des autres:
L'encapsulation de données est un mécanisme permettant de regrouper les données et le fichier les fonctions qui les utilisent et l’abstraction des données est un mécanisme de afficher uniquement les interfaces et masquer les détails de la mise en œuvre de 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 nécessairement être cachées.
L'encapsulation est la capacité de traiter quelque chose comme une seule chose, même s'il peut être composé 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 de cette chaise, chacune ayant un design et une fonction spécifiques, toutes étant parfaitement ajustées pour permettre à mon à quelques mètres du sol.
Abstraction est activé par encapsulation. Parce que nous encapsulons des objets, nous pouvons les considérer comme des choses qui se rapportent les unes aux autres d’une manière ou d’une autre 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 le tableau dans son ensemble, sans se soucier des petits détails. La racine de la Parole est abstraite comme dans le résumé qui apparaît au sommet d'un document scientifique, pas comme dans une classe qui ne peut être instanciée que comme une sous-classe dérivée.
En toute honnêteté, je peux affirmer que, lorsque je me couche sur ma chaise, je ne pense jamais à la façon dont la structure de cette chaise me tiendra en échec. C'est une chaise assez décente pour que je n'ai pas à m'inquiéter 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 ne fais que regarder une partie d'une page Web qui représente une zone de texte dans laquelle je peux taper, et je communique en mots, en pensant à peine à la façon dont mes doigts trouvent toujours les bonnes lettres si rapidement sur le clavier, et comment la connexion est finalement faite entre la saisie de ces clés et la publication sur ce forum. C'est le grand pouvoir de l'abstraction. Étant donné que l'on peut faire confiance aux niveaux inférieurs du système pour travailler avec cohérence et précision, nous devons veiller à ce que le travail soit 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 non utiles des utilisateurs L'encapsulation consiste à lier des données dans une capsule (une classe) .
Le processus d'abstraction et d'encapsulation tous deux génèrent des interfaces.
Une interface générée via l’encapsulation masque les détails de la mise en œuvre.
Une interface générée via l'abstraction devient applicable à davantage de types de données, par rapport à l'abstraction antérieure.
Abstraction est un contrat pour la mise en œuvre que nous allons effectuer. La mise en œuvre peut être modifiée avec le temps. Les différentes implémentations elles-mêmes peuvent ou non être cachées, mais sont masquées derrière l'abstraction.
Supposons que nous définissions toute la APIs d'une classe dans une interface, puis demandions aux utilisateurs de notre code de dépendre de la APIs définie de la interface. Nous sommes libres d'améliorer ou de modifier la mise en œuvre. Nous devons seulement respecter le contrat établi. Les utilisateurs ne sont pas couplés avec notre implémentation.
Nous EXPOSONS toutes les règles (méthodes) NÉCESSAIRES dans l'abstraction , la mise en œuvre des règles est laissée aux entités implémenteurs, de même que la mise en œuvre ne fait pas partie de l'abstraction. C’est juste la signature et la déclaration qui fait l’abstraction.
Encapsulation est simplement MASQUANT les détails internes en réduisant l'accès aux états et aux comportements. Une classe encapsulée peut avoir ou non une Abstraction bien définie.
Java.util.List est une abstraction de Java.util.ArrayList. Les états internes de Java.util.ArrayList marqué avec des modificateurs d'accès non public est l'encapsulation.
Edit Supposons qu'une classe Container.nava implements IContainer, IContainer puisse déclarer des méthodes telles que addElement, removeElements, contains, etc. Ici IContainer représente l'abstraction de sa classe d'implémentation. L'abstraction déclare les API de la classe, d'un module ou d'un système au monde extérieur. Ces API deviennent la contract. Ce système peut être ou ne pas être développé pour le moment. Les utilisateurs du système peuvent désormais compter sur les API déclarées et sont certains que tout système mettant en œuvre un tel contrat adhérera toujours aux API déclarées, ils fourniront toujours une implémentation tge pour ces API. Une fois que nous écrivons une entité concrète, nous décidons de masquer nos états internes.
J'essaie de tracer une ligne ici entre abstraction et encapsulation, selon moi. L'abstraction est plus une chose conceptuelle où l'encapsulation est une des implémentations de l'abstraction. Comme on peut cacher des données sans encapsulation, par exemple en utilisant des constantes ou des variables privées; nous pouvons donc avoir une encapsulation avec masquage de données, mais le masquage de données n’est pas toujours une encapsulation . Dans la partie de code ci-dessous, j'essaie de décrire la forme la plus simple de ces concepts.
// Abstraction
interface IOperation
{
int SquareNumber();
}
public class Operation
{
// Data hiding
private int number;
public Operation(int _number)
{
this.number = _number;
}
// Encapsulation
public int SquareNumber()
{
return number * number;
}
}
En action,
IOperation obj = new Operation(2);
// obj.number <--- can't access because hidden from world using private access modifier but not encapsulated.
obj.SquareNumber(); // cannot access internal logic to calculate square because logic is hidden using encapsulation.
En bref
Abstraction use -> Encapsulation & Encapsulation use -> masquage des données
OR
data hiding est un sous-ensemble de Encapsulation et Encapsulation est un sous-ensemble de Abstraction
Référence: http://www.tonymarston.co.uk/php-mysql/abstraction.txt
Je pense que l'encapsulation est un moyen d'implémenter l'abstraction. Regardez le lien suivant.
Abstraction et Encapsulation sont toutes deux connues pour la dissimulation de données. Mais il y a une grande différence.
Encapsulation
L'encapsulation est un processus de liaison ou d'encapsulation des données et des codes qui agit sur les données dans une seule unité appelée Classe.
L'encapsulation résout le problème au niveau de la mise en œuvre.
En classe, vous pouvez masquer des données à l'aide de modificateurs d'accès privés ou protégés.
Abstraction
L'abstraction est le concept de cacher des détails non pertinents. En d'autres termes, simplifiez la complexité du système en masquant les détails inutiles à l'utilisateur.
L'abstraction résout le problème au niveau de la conception.
Vous pouvez obtenir une abstraction en créant une classe d'interface et abstraite en Java.
En Ruby, vous pouvez réaliser une abstraction en créant des modules.
Ex: Nous utilisons (collectons, cartographions, réduisons, trions ...) les méthodes du module Enumerable avec Array et Hash in Ruby.
Laissez-moi essayer ceci avec un exemple de code simple
Abstraction = masquage des données + encapsulation
// Abstraction
interface IOperation
{
int GetSumOfNumbers();
}
internal class OperationEven : IOperation
{
// data hiding
private IEnumerable<int> numbers;
public OperationEven(IEnumerable<int> numbers)
{
this.numbers = numbers;
}
// Encapsulation
public int GetSumOfNumbers()
{
return this.numbers.Where(i => i % 2 == 0).Sum();
}
}
En bref:
Abstraction est une technique qui nous aide à identifier quelles informations spécifiques sont essentielles et quelles informations doivent être masquées.
Encapsulation est alors la technique pour inclure les informations de manière à masquer les détails et les détails d'implémentation d'un objet.
Abstraction
L'abstraction est le processus d'extraction des propriétés et des champs communs de toutes les implémentations existantes et prévues.
Par exemple: Car est une abstraction pour Sedan, Hatchback, VUS, Coupe, Décapotable .Car aurait toutes les propriétés et tous les champs communs à tous les types de voitures.
Encapsulation
L'encapsulation est le processus qui consiste à masquer à l'utilisateur des détails indésirables. Ce terme vient de la capsule. Tout comme la médecine est cachée de l'utilisateur à l'intérieur de la capsule. Détails de diverses machines et équipements et appareils allant des mixeurs, vélos, machines à laver, radio, télévision aux avions. Vous ne voulez pas que tous les détails de la machine soient visibles pour l'utilisateur.
En termes de programmation: Considérons une classe Car . Dans l'exemple ci-dessous, tout ce que l'utilisateur doit savoir est de tourner la clé (méthode turnKey ()), il ne connaît pas les fonctions internes. L'utilisateur n'a pas besoin de connaître les fonctions internes ni les composants internes.
Dans ce cas, toutes les méthodes privées sont des fonctions internes et les champs privés tels que "Piston p1" sont des données internes que l'utilisateur n'a pas besoin de connaître.
public class Car{
private void startMotor(){ //do something }
private void generateVoltage(){ //do something }
private void sparkPlugIgnition(){ //do something }
private void fuelFlowFromTankToInjector(){ //do something }
private void pushPistonsDown() {
p1.doAction();
p2.doAction();
//do something }
private void moveCrankShaft(){ //do something }
private Piston p1;
private Piston p2;
public void turnKey(){
startMotor();
generateVoltage();
sparkPlugIgnition();
fuelFlowFromTankToInjector();
pushPistonsDown();
moveCrankShat();
...
}
}