La différence entre l'abstraction et d'encapsulation?

Plus de réponses ici, l'accent sur la programmation orientée objet, mais l'encapsulation commence beaucoup plus tôt:

• Chaque fonction est un l'encapsulation; en pseudo-code:

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

  Ici, distance encapsule le calcul de l' (Euclidienne) de la distance entre deux points dans un plan: il masque les détails de mise en œuvre. C'est l'encapsulation, pure et simple.

• L'Abstraction est le processus de généralisation: la prise d'une mise en œuvre concrète et de le rendre applicable à différentes, mais liées dans une certaine mesure, les types de données. L'exemple classique de l'abstraction est C qsort fonction pour trier les données:

  La chose à propos de qsort est qu'il ne s'inquiète pas des données qu'il trie — en fait, il ne sais pas quelles données il trie. Plutôt, son type d'entrée est un pointeur sans type (void*) qui est juste à C de façon de dire “je n'ai pas de soins sur le type de données” (ce qui est aussi appelé type d'effacement). Le point important est que la mise en œuvre de qsort reste toujours le même, quel que soit le type de données. La seule chose qui a changer, c'est la fonction de comparaison, qui diffère d'un type de données type de données. qsort s'attend donc à l'utilisateur de fournir ladite fonction de comparaison comme un argument de fonction.

D'Encapsulation et d'abstraction aller main dans la main de sorte que beaucoup de sorte que vous pourriez faire le point de qui ils sont vraiment inséparables. Pour des raisons pratiques, c'est probablement vrai; cela dit, voici un modèle qui n'est pas une abstraction:

class point {
    numeric x
    numeric y
}

Nous encapsuler le point de coordonnées, mais nous n'avons pas matériellement abstrait, loin, au-delà de grouper logiquement.

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

T pi<T> = 3.1415926535

C'est un générique variable pi avec une valeur donnée (π), et la déclaration n'est pas le type exact de la variable. Certes, j'avais du mal à trouver quelque chose comme cela dans la vraie code: abstraction pratiquement toujours utilise l'encapsulation. Cependant, le ci-dessus ne existent réellement en C++(14), via variable templates (= modèles génériques pour les variables); avec un peu plus d'une syntaxe complexe, par exemple:

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

Beaucoup de réponses et de leurs exemples sont trompeuses.

L'Encapsulation est l'emballage de données et fonctions opérant sur des données dans un seul composant et de restreindre l'accès à certains les composants de l'objet.

L'Encapsulation signifie que la représentation interne d'un objet est généralement caché de la vue à l'extérieur de l'objet de la définition.

L'Abstraction est un mécanisme qui représentent l'essentiel des fonctionnalités sans y compris les détails de mise en œuvre.

Encapsulation:-- se cacher de l'Information.

Abstraction:-- mise en Œuvre de cacher.

Exemple:

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

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

Représentation interne de l'objet de la foo classe est caché à l'extérieur de la classe. --> Encapsulation.

Tout membre accessible (données/de fonction) d'un objet de foo est restreinte et ne peut être accessible que par cet objet.

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

Mise en œuvre de la méthode add est caché. --> l'Abstraction.

L'Encapsulation moyen-possibilité de cacher des données comme l'utilisation de méthodes getter et setter etc.

L'Abstraction moyen - masquage de la mise en œuvre à l'aide de la classe abstraite et interfaces etc.

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

Encapsulation des données signifie simplement d'emballage et de contrôle d'accès de logiquement des données regroupées dans une classe. Il est généralement associé à un autre mot-clé - Données Cacher. Ceci est réalisé en Java à l'aide de modificateurs d'accès.

Un exemple simple serait de définir une variable privée et donnant accès à l'aide de méthodes getter et setter ou de faire une méthode privée comme c'est seulement l'utilisation est à l'intérieur de la classe. Il n'est pas nécessaire pour l'utilisateur de savoir à propos de ces méthodes et de variables.

Note : Il ne devrait pas être mal compris, que l'encapsulation est tout au sujet des données de cacher uniquement. Quand nous disons que l'encapsulation, l'accent devrait être mis sur le regroupement ou l'emballage, ou le regroupement des données et comportement de l'ensemble.

Abstraction de données sur l'autre main est le concept de la généralisation de sorte que le dessous de la complexité de la logique n'est pas exposé à l'utilisateur. En Java, ceci est réalisé en utilisant interfaces et résumé classes.

Exemple -

Permet de dire que nous avons un interface Animal et il a une fonction makeSound(). Il y a deux classes de béton Chien et Chat qui implémentent cette interface. Ces classes concrètes ont des implémentations distinctes de makeSound() fonction. Maintenant, disons que nous avons un animal(Nous obtenir ce à partir de certains module externe). Tout utilisateur sait, c'est que l'objet qu'il reçoit est un Animal et il est de la responsabilité des utilisateurs d'imprimer l'animal de son. Une force brute consiste à vérifier l'objet reçu à identifier c'est type, puis transtypage à ce type d'Animal et puis appel makeSound() sur celui-ci. Mais d'une façon plus soignée est à résumés chose. L'utilisation de l'Animal comme un polymorphe de référence et appel makeSound() sur celui-ci. Au runtime selon ce qui est l'Objet réel est de type correct de la fonction sera appelée.

Plus de détails ici.

Logique complexe est dans le circuit imprimé, qui est encapsulé dans un pavé tactile et une belle interface(boutons) est fourni à l'abstrait à l'utilisateur.

PS: les liens sont sur mon blog personnel.

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

---

Réponse Courte

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

Abstraction - compte tenu de quelque chose avec certaines caractéristiques supprimés, à l'exception de réalités concrètes, des objets spécifiques, ou des cas réels, réduisant ainsi la complexité.

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

Le principal différence est que l'abstraction est une façon de représenter les choses plus simplement (souvent pour rendre la représentation plus largement applicable), considérant que l'encapsulation est un procédé de modification de la façon dont d'autres choses interagir avec quelque chose.

---

Réponse Longue

Encapsulation

Voici un exemple d'encapsulation qui je l'espère rend les choses plus claires:

Ici, nous avons un Arduino Uno, et un Arduino Uno dans une enceinte. Une enceinte est une excellente représentation de ce que l'encapsulation est tout au sujet.

Encapsulation vise à protéger certaines composantes des influences extérieures et de connaissances ainsi que d'exposer les composants qui doivent interface avec. En termes de programmation, cela implique se cacher de l'information si modificateurs d'accès, qui changent la mesure dans laquelle certaines variables et/ou les propriétés peuvent être lues et écrites.

Mais au-delà, l'encapsulation vise également à fournir ces interfaces externes de manière beaucoup plus efficace. Avec notre Arduino exemple, cela peut inclure les beaux boutons et de l'écran qui rend l'utilisateur de l'interaction avec le dispositif beaucoup plus simple. Ils fournissent à l'utilisateur des moyens simples pour affecter le comportement du périphérique et obtenir de précieuses informations sur son fonctionnement qui autrement serait beaucoup plus difficile.

Dans la programmation, cela implique le regroupement des diverses composantes dans une séparables construire, comme un function, class, ou object. Elle vise aussi à fournir les moyens d'interagir avec ces constructions, ainsi que les méthodes pour obtenir des informations utiles à leur sujet.

Encapsulation permet aux programmeurs dans de nombreux de nombreux moyens supplémentaires, pas moins de ce qui est de l'amélioration du code de la maintenabilité et de la testabilité.

Abstraction

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

Voici comment j'aime à penser de l'abstraction:

Diriez-vous de l'image il y a un arbre? Les Chances sont que vous. Mais est-il vraiment un arbre? Eh bien, bien sûr que non! C'est un tas de pixels mis à ressembler à quelque chose qu'on pourrait appeler un arbre. On pourrait dire qu'il représente une abstraction d'un vrai arbre. Notez que plusieurs détails visuels de l'arbre sont omis. Aussi, il ne grandit pas, consomment de l'eau, ou de produire de l'oxygène. Comment pourrait-il? c'est juste un tas de couleurs sur un écran, représentés par des octets dans la mémoire de votre ordinateur.

Et ici, c'est l'essence même de l'abstraction. C'est une façon de simplifier les choses afin qu'elles soient plus faciles à comprendre. Chaque idée dans votre tête est une abstraction de la réalité. Votre image mentale d'un arbre n'est pas plus un arbre actuelle que ce jpeg est.

Dans la programmation, nous pourrions l'utiliser à notre avantage en créant un Tree classe avec des méthodes de simulations de croissance, consommant de l'eau, et la production d'oxygène. Notre création serait quelque chose qui correspond à notre expérience du réel arbres, et ne comprend que les éléments que nous nous soucions vraiment pour notre simulation. Nous utilisons l'abstraction comme une façon de représenter notre expérience de quelque chose avec des octets et des mathématiques.

Les Classes Abstraites

L'Abstraction dans la programmation nous permet également de considérer les points communs entre plusieurs "béton" types d'objets (les types qui existent réellement) et de définir les points communs au sein d'une entité unique. Par exemple, notre Tree classe peut hériter d'une abstract class Plant, qui a plusieurs propriétés et méthodes qui sont applicables à l'ensemble de notre usine-comme pour les classes, mais supprime ceux qui sont spécifiques à chaque type de plante. Cela peut réduire considérablement la duplication de code, et améliore la maintenabilité.

La différence pratique d'un abstract class et la plaine class est que, conceptuellement, il n'y a pas de "vrai" cas de la abstract class. Il n'est pas judicieux de construire un Plant objet, car ce n'est pas assez précis. Tous les "vrais" Plant est également un plus type spécifique de Plant.

Aussi, si nous voulons que notre programme soit plus réaliste, on pourrait envisager le fait que notre Tree de classe peut-être trop abstrait lui-même. En réalité, tous les Tree est un plus type spécifique de Tree, afin que nous puissions créer des classes pour les types comme Birch, Maple, etc. qui héritent de nos, peut-être maintenant abstract, Tree classe.

JVM

Un autre bon exemple de l'abstraction est la Java Virtual Machine (JVM), qui fournit un service virtuel ou le résumé de l'ordinateur pour le code Java pour exécuter sur. Essentiellement, il enlève tout de la plate-forme de composantes spécifiques d'un système, et fournit une interface abstraite de "ordinateur", sans égard à aucun système en particulier.

La Différence

Encapsulation diffère de l'abstraction en ce qu'il n'a rien à voir avec la façon dont le 'réel' ou 'précise' est une chose. Il n'a pas supprimer composants de quelque chose pour le rendre plus simple ou plus largement applicable. Plutôt il peut cacher certains composants pour atteindre un but similaire.

Différence Entre l'Abstraction et d'Encapsulation.

Abstraction: Seule information nécessaire est indiqué. Concentrons-nous sur l'exemple de la commutation sur un ordinateur. L'utilisateur n'a pas à savoir ce qui se passe pendant que le système est toujours en cours de chargement (que l'information est cachée à l'utilisateur).

Prenons un autre exemple, celui de l'ATM. Le client n'a pas besoin de savoir comment la machine lit le code PIN et les processus de la transaction, tout ce qu'il doit faire est d'entrer le code PIN, prendre l'argent et partir.

Encapsulation: Traite avec de cacher les données sensibles d'un clas donc la privatisation d'une partie d'elle. C'est une façon de garder certaines informations confidentielles de ses clients, en leur permettant pas d'accéder de l'extérieur.

Abstraction et Encapsulation en utilisant un seul exemple général

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

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

Abstraction : Abstraction des moyens de montrer What partie de la fonctionnalité.

Encapsulation : Encapsulation des moyens pour masquer la How partie de la fonctionnalité.

Permet de prendre 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
    }
}

Programme de la classe de l'Application de la 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);
    }
}

De l'Abstraction--- Masquage de mise en Œuvre--lors de la Conception,---à l'Aide de/l'Interface Abstraite calsses

Encapsulation--Masquage des Données, Au Développement---l'Utilisation des modificateurs d'accès(public/privé)

De cette

Différence entre l'Encapsulation et d'Abstraction dans OOPS

D'Abstraction et d'Encapsulation sont deux importants de la Programmation Orientée Objet (OUPS) des concepts. Encapsulation et d'Abstraction les deux sont interdépendants termes.

La Vie réelle Différence Entre l'Encapsulation et d'Abstraction

Encapsuler les moyens à cacher. L'Encapsulation est également appelé de données se cacher.Vous pouvez penser à l'Encapsulation comme une capsule (médecine tablette) qui cache la médecine à l'intérieur. L'Encapsulation est l'emballage, se cache des propriétés et des méthodes. L'Encapsulation est utilisée pour masquer le code et les données dans une seule unité pour protéger les données à partir de l'extérieur du monde. La classe est le meilleur exemple d'encapsulation.

L'Abstraction désigne à afficher uniquement les informations nécessaires à l'utilisateur prévu. Comme le nom le suggère, l'abstraction est la "forme abstraite de tout". Nous utilisons l'abstraction dans les langages de programmation à faire abstraction de la classe. Classe abstraite représente la vue abstraite des méthodes et propriétés de la classe.

Mise en œuvre de la Différence Entre l'Encapsulation et d'Abstraction

1. Abstraction est mis en œuvre à l'aide de l'interface et la classe abstraite tandis que l'Encapsulation est mis en œuvre en utilisant privé et protégé modificateur d'accès.

2. OUPS fait de l'utilisation de l'encapsulation pour appliquer l'intégrité d'un type (c'est à dire à s'assurer que les données est utilisé de manière appropriée) en empêchant les programmeurs d'accéder à des données non destinées manière. Grâce à l'encapsulation, seulement un certain groupe de fonctions peuvent accéder aux données. Le terme collectif pour les types de données et les opérations (méthodes) regroupés avec les restrictions d'accès (public/privé, etc.) est une classe.

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

Encapsulation des données est un mécanisme de regroupement des données, et la
les fonctions qui les utilisent et à l'abstraction des données est un mécanisme de
exposer uniquement les interfaces et de cacher les détails d'implémentation
la part de l'utilisateur.

Vous pouvez en lire plus ici.

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

Le processus d'Abstraction et d'Encapsulation de générer à la fois des interfaces.

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

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

Je Pense que l'Encapsulation est une façon de mettre en œuvre l'abstraction. Jetez un oeil sur le lien suivant.

L'Abstraction et Encapsulation

J'essaie de tracer une ligne entre l'abstraction et d'encapsulation, selon moi, l'Abstraction est plus conceptuel de la chose, où que l'encapsulation est l'un de l'abstraction de la mise en œuvre. Puisque l'on peut masquer des données sans encapsulation, par exemple en utilisant des constantes ou des variables; ainsi nous pouvons avoir encapsulation avec les données de la clandestinité, mais les données à cacher n'est pas toujours encapsulation. Ci-dessous le morceau de code que j'essaie de dépeindre 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;
        }
    }

Dans l'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.

D'Abstraction et d'Encapsulation, les deux sont savoir pour les données de la clandestinité. Mais il y a une grande différence.

Encapsulation

L'Encapsulation est un processus de liaison ou l'enveloppement des données et les codes qui opère sur les données en une seule unité appelée Classe.

L'Encapsulation permet de résoudre le problème au niveau de mise en œuvre.

En classe, vous pouvez masquer des données en utilisant privés ou protégés des modificateurs d'accès.

Abstraction

L'Abstraction est la notion de masquage des détails sans importance. En d'autres mots, système complexe simple en cachant les détails inutiles de l'utilisateur.

L'Abstraction permet de résoudre le problème au niveau de la conception.

Vous pouvez réaliser l'abstraction par la création de l'interface et la classe abstraite Java.

En ruby, vous pouvez réaliser l'abstraction par la création de modules.

Ex: Nous utilisons (collecte, de carte, de réduire, trier...) les méthodes de Énumérable module de Tableau de Hachage et de rubis.

En bref:

Abstraction est une technique qui nous aide à identifier laquelle des informations spécifiques est essentielle, et l'information qui doit être caché.

Encapsulation est alors la technique pour isoler les informations, de manière à cacher les détails et les détails d'implémentation d'un objet.

Il y a des différences entre

ABSTRAACTION

et

ENCAPSULATION

1.    First difference between Abstraction and Encapsulation is that, Abstraction is implemented in Java using interface and abstract class while Encapsulation is implemented using private, package-private and protected access modifier.

2.    Data abstraction simply means generalizing something to hide the complex logic that goes underneath where Encapsulation is DATA HIDING.


3.    Encapsulation is combining related logic data (variables and methods) where as Abstraction is hiding internal implementation details and expose only relevant details to the user. In a way you can Abstraction is achieved by Encapsulation.

Une chose, peut-être une chose fondamentale que d'autres réponses oublier de mentionner est que, encapsulation EST l'abstraction. Par conséquent, il n'est pas précis pour mettre en contraste les deux et chercher les différences, mais plutôt à regarder encapsulation comme une forme d'abstraction.