la plupart des réponses ici se concentrent sur OOP mais l'encapsulation commence beaucoup plus tôt:

• chaque fonction est une encapsulation ; en pseudo-code:

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

  ici, distance résume le calcul de la distance (euclidienne) entre deux points dans un plan: il cache des détails de mise en œuvre. C'est l'encapsulation, pure et simple.

• Abstraction est le processus de généralisation : prendre une mise en œuvre concrète et le rendre applicable à différents types de données, bien que quelque peu liés. L'exemple classique de l'abstraction est la fonction qsort de C pour trier les données:

  la chose à propos de qsort est qu'il ne se soucie pas des données qu'il trie - en fait, il ne sait pas quelles données il trie. Son type d'entrée est plutôt un pointeur non typé ( void* ) qui n'est qu'une façon de dire" Je ne me soucie pas du type de données " (c'est aussi appelé effacement de type). Le point important est que la mise en œuvre de qsort reste toujours la même, quel que soit le type de données. La seule chose que a de changer est la fonction de comparaison, qui diffère du type de données en type de données. qsort donc attend de l'utilisateur qu'il fournisse ladite fonction de comparaison comme argument de fonction.

Encapsulation et abstraction vont main dans la main tellement que vous pourriez faire le point qu'ils sont vraiment inséparables. Pour des raisons pratiques, c'est probablement vrai; cela dit, Voici une encapsulation qui n'est pas très abstraite:

class point {
    numeric x
    numeric y
}

nous encapsulons la coordonnée du point, mais nous ne les abstrayons pas matériellement, au-delà de les regrouper de manière logique.

et voici un exemple d'abstraction qui n'est pas encapsulée:

T pi<T> = 3.1415926535

c'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 du mal à trouver quelque chose comme ça en code réel: l'abstraction utilise presque toujours l'encapsulation. Toutefois, le ci-dessus ne existe en fait en C++(14), via "variable templates (=generic templates for variables); avec une syntaxe légèrement plus complexe, par exemple:

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

Encapsulation cache les détails d'implémentation qui peuvent ou non être pour des comportements génériques ou spécialisés.

Abstraction fournit une généralisation (disons, sur un ensemble de comportements).

Voici une bonne lecture: l'Abstraction, l'Encapsulation, et se Cacher de l'Information par Edward V. Berard de l'Objet de l'Agence.

encapsulation met certaines choses dans une boîte et vous donne un judas; cela vous empêche de mucking avec les engrenages.

abstraction flat-out ignore les détails qui n'ont pas d'importance, comme si les choses ont des engrenages, des cliquets, des volants, ou des noyaux nucléaires; ils "vont" juste

exemples d'encapsulation:

• slips
• boîte à outils
• porte-monnaie
• 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 genre de "choses qui contiennent d'autres choses" abstraction; de noter que la totalité de l'encapsulation en sont des exemples types de conteneurs, mais pas tous les conteneurs d'exposition/de fournir de l'encapsulation. Un panier, par exemple, est un contenant qui n'encapsule pas son contenu.

de nombreuses réponses et leurs exemples sont trompeurs.

Encapsulation est l'empaquetage des fonctions data et fonctionnant sur ces données en un seul composant et limitant l'accès à certains composants de l'objet.

L'Encapsulation signifie que la représentation interne d'un objet est généralement cachée de la vue en dehors de la définition de l'objet.

Abstraction est un mécanisme qui représente les caractéristiques essentielles sans inclure les détails de mise en œuvre.

Encapsulation: -- se cacher de l'Information .

l'Abstraction: -- Mise en cache .

exemple:

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

        foo(int x, int y): a(x), b(y) 
        { }

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

interne la représentation de n'importe quel objet de la classe foo est cachée en dehors de la classe. --> Encapsulation.

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

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

la mise en Œuvre de la méthode add est caché. --> Abstraction.

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

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

Abstraction est un terme généralisé. c'est-à-dire que L'Encapsulation est un sous-ensemble de L'Abstraction.

Courtoisie

• Abstraction vous permet de vous concentrer sur ce que l'objet fait au lieu de la façon dont il le fait
• Encapsulation signifie cacher les détails internes ou la mécanique de la façon dont un objet fait quelque chose.

comme quand vous conduisez une voiture, vous savez ce que fait la pédale d'accélérateur mais vous pouvez ne pas savoir le processus derrière elle parce qu'elle est encapsulée.

Permettez-moi de donner un exemple dans C#. Supposons que vous ayez un entier:

int Number = 5;
string aStrNumber = Number.ToString();

vous pouvez utiliser une méthode comme Nombre.ToString () qui vous renvoie la représentation des caractères du nombre 5, et stocke cela dans un objet string. La méthode vous dit ce qu'il fait au lieu de comment il le fait.

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

Data Encapsulation signifie simplement envelopper et contrôler l'accès à des données logiquement groupées 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 serait de définir une variable et lui donner accès à l'aide de getter et setter méthodes ou de rendre une méthode privée comme il est seulement l'utilisation est avecing la classe. Il n'est pas nécessaire que l'utilisateur soit au courant de ces méthodes et variables.

Note : il ne faut pas se méprendre sur le fait que l'encapsulation ne concerne que la dissimulation de données. Lorsque nous parlons d'encapsulation, l'accent devrait être mis sur le groupement ou l'empaquetage ou le groupement de données et de comportements liés ensemble.

Abstraction de données d'un autre côté est le concept de généralisation de sorte que la logique sous-jacente complexe n'est pas exposée à l'utilisateur. En Java, ceci est réalisé en utilisant les classes interfaces et abstract .

exemple -

disons que nous avons un animal d'interface 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 la fonction makeSound (). Maintenant, disons que nous avons un animal(nous obtenons cela d'un 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 façon de force brute est de vérifier l'objet reçu à identifier c'est le type, puis typecast il à ce type D'Animal et puis appel makeSound() sur elle. Mais d'une façon plus soignée est de résumés chose . Utilisez Animal comme référence polymorphique et call makeSound () dessus. À runtime selon ce que le type d'objet réel est fonction appropriée sera invoquée.

plus de détails ici .

logique complexe est dans le circuit imprimé qui est encapsulé dans un tactile et une interface agréable(boutons) est fourni pour l'abstraire à l'utilisateur.

ce sont des concepts quelque peu flous qui ne sont pas uniques à 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 - cacher et/ou restreindre l'accès à certaines parties d'un système, tout en exposant les interfaces nécessaires.

Abstraction - considérer quelque chose dont certaines caractéristiques ont été enlevées, en dehors des réalités concrètes, des objets spécifiques, ou des instances réelles, réduisant ainsi la complexité.

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

la principale différence est que abstraction est un moyen de représenter les choses plus simplement (souvent pour rendre la représentation plus largement applicable), alors que l'encapsulation est une méthode pour changer la façon dont d'autres choses interagissent avec quelque chose.

Longue Réponse

Encapsulation

voici un exemple d'encapsulation qui, espérons-le, rend les choses plus claires:

ici nous avons un Arduino Uno, et un Arduino Uno dans une enceinte. Une enceinte est une grande représentation de ce qu'est l'encapsulation.

L'Encapsulation vise à protéger certains composants contre les influences et les connaissances extérieures, ainsi qu'à exposer les composants avec lesquels d'autres choses devraient interagir. En termes de programmation, cela implique Cacher l'information bien que modificateurs d'accès , qui modifient la mesure dans laquelle certaines variables et/ou propriétés peuvent être lues et écrites.

mais au-delà de cela, encapsulation vise également à fournir ces interfaces externes beaucoup plus efficacement. Avec notre exemple Arduino, cela pourrait inclure les boutons et l'écran nice qui rend l'interaction de l'utilisateur avec l'appareil beaucoup plus simple. Ils fournissent à l'utilisateur des moyens simples pour affecter l'appareil comportement et obtenir de précieuses informations sur son fonctionnement qui autrement serait beaucoup plus difficile.

dans la programmation, cela implique le regroupement de divers composants dans une construction séparable, comme un function , class , ou object . Il s'agit également de fournir les moyens d'interagir avec ces concepts, ainsi que des méthodes pour obtenir des informations utiles à leur sujet.

Encapsulation aide les programmeurs dans de nombreux des moyens supplémentaires, dont le moindre n'est pas l'amélioration de la maintenabilité et de la testabilité du code.

Abstraction

bien que beaucoup d'autres réponses ici aient défini l'abstraction comme une généralisation, je pense personnellement que cette définition est malavisée. Je dirais que la généralisation est en fait un type spécifique de abstraction, et non 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 à l'abstraction:

diriez-vous que l'image est un arbre? Les Chances sont que vous. Mais est-ce 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 que c'est une abstraction d'un vrai arbre. Notez que plusieurs détails visuels de l'arbre sont omis. De plus, il ne pousse pas, ne consomme pas d'eau et ne produit pas d'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 voici l'essence 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.

dans la programmation, nous pourrions utiliser cela à notre avantage en créant une classe Tree avec des méthodes pour simuler la croissance, la consommation d'eau et la production d'oxygène. Notre création serait quelque chose qui représente notre expérience des arbres réels, et ne comprend que les éléments qui nous tiennent vraiment à cœur pour notre simulation particulière. Nous utilisons l'abstraction comme une façon de représenter notre expérience de quelque chose avec les octets et les mathématiques.

Classes Abstraites

Abstraction dans la programmation nous permet également de considérer des points communs entre plusieurs types d'objets "concrets" (types qui existent réellement) et de définir ces points communs au sein d'une entité unique. Par exemple , notre classe Tree peut hériter d'une abstract class Plant , qui a plusieurs propriétés et méthodes qui sont applicables à toutes nos classes de plantes, mais supprime ceux qui sont spécifiques à chaque type de plante. Cela peut considérablement réduire la duplication du code et améliorer la maintenabilité.

la différence pratique entre un abstract class et un class simple est que conceptuellement il n'y a pas de cas" réel "du abstract class . Il ne serait pas logique de construire un objet Plant parce que ce n'est pas assez spécifique. Chaque "réel " Plant est aussi un type plus spécifique de Plant .

Aussi, si nous voulons que notre programme soit plus réaliste, on peut vouloir considérez le fait que notre classe Tree pourrait être elle-même trop abstraite. En réalité, chaque Tree est un type plus spécifique de Tree , donc nous pourrions créer des classes pour ces types tels que Birch , Maple , etc. qui héritent de notre, peut-être maintenant abstract , Tree classe.

JVM

un autre bon exemple d'abstraction est le Java Virtual Machine (JVM) , qui fournit un ordinateur virtuel ou abstrait pour le code Java à exécuter. Il enlève essentiellement tous les composants spécifiques à la plate-forme d'un système, et fournit une interface abstraite de "l'ordinateur" sans égard à n'importe quel système en particulier.

La Différence

L'Encapsulation diffère de l'abstraction en ce qu'elle n'a rien à voir avec la façon dont quelque chose est "réel" ou "précis". Il ne supprimer les composants de quelque chose pour le rendre plus simple ou plus largement applicable. Il peut plutôt Cacher certains composants pour atteindre un but similaire.

Encapsulation : cache des détails de mise en œuvre non désirés/non attendus/de propriété des utilisateurs réels de l'objet. par exemple

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 : c'est une façon de généraliser et donc de travailler en commun 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 à la situation.

Envisager une classe qui envoie un e-mail... il utilise l'abstraction pour se montrer à vous comme une sorte de garçon messager, de sorte que vous pouvez appeler emailSender.envoyer(mail, le destinataire). Ce qu'il fait réellement - choisir POP3 / SMTP, appeler des serveurs, la traduction de MIME, etc, est abstraite. Tu ne vois que ton 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 plutôt de faire quelque chose d'indépendant et infaillible.

Prenez-moi, par exemple. Je encapsuler 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 pas besoin que quelqu'un d'autre la règle pour que je puisse fonctionner. Son importance vitale pour moi, Mais tu n'as pas besoin de savoir ce que c'est, et tu t'en fous probablement de toute façon.

regardez autour de vous vous constaterez que presque tout ce que vous touchez est un exemple à la fois d'abstraction et d'encapsulation. Votre téléphone, par exemple, vous présente l'abstraction de pouvoir prendre ce que vous dites et le dire à quelqu'un d'autre - couvrant le GSM, l'architecture du processeur, les fréquences radio, et un million d'autres choses que vous ne comprenez pas ou dont vous ne vous souciez pas. Il contient également certaines données vous, comme les numéros de série, codes d'identification, les fréquences, etc.

tout Cela fait du monde un meilleur endroit pour vivre :D

Abstraction: seules les informations nécessaires sont indiquées. 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 en cours de chargement (cette 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 NIP et traite la transaction, il n'a qu'à entrer le NIP, prendre l'argent et partir.

Encapsulation: concerne la dissimulation des données sensibles d'un clas et donc la privatisation d'une partie de celui-ci. C'est une façon de garder certaines informations confidentielles de ses clients, en leur permettant pas d'accéder de l'extérieur.

autre exemple:

supposons que j'ai créé une classe de 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 limité), mais je n'ai pas résumé quoi que ce soit (OK, peut-être que j'ai ignoré où le rectangle est situé dans l'espace de coordonnées, mais c'est un défaut de l'exemple).

bon l'abstraction implique généralement une bonne encapsulation.

un exemple de bonne abstraction est une classe générique de connexion de base de données. Son interface publique est agnostique-base de données, et est très simple, mais me permet de faire ce que je veux avec la connexion. Et vous voyez? Il y a aussi encapsulation là, parce que la classe doit avoir toutes les poignées de bas niveau et les appels à l'intérieur.

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

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

nous utilisons tous la calculatrice pour le calcul de problèmes complexes !

un mécanisme qui empêche les données d'un objet particulier à l'abri d'une utilisation abusive intentionnelle ou accidentelle par des fonctions externes est appelé " data Encapsulation"

l'acte de représenter des caractéristiques essentielles sans inclure les détails ou explications de l'arrière-plan est connu sous le nom de abstraction

Abstraction: Abstraction signifie montrer What partie de la fonctionnalité.

Encapsulation: Encapsulation signifie cacher 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
    }
}

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);
    }
}

Encapsulation est enveloppant la complexité dans une capsule qui est classe et donc de l'Encapsulation… Tandis que l'abstraction est les caractéristiques d'un objet qui se différencie d'un autre objet...

l'Abstraction peut être obtenu au moyen de la classe abstraite ayant une ou plusieurs méthodes abstraites. Ce qui n'est rien d'autre que la caractéristique qui doit être mise en œuvre par la classe qui l'étend. par exemple, lorsque vous inventer / concevoir une voiture, vous définissez une caractéristique comme voiture devrait avoir 4 portes, casser, volant etc ... donc quiconque utilise cette conception devrait inclure ces caractéristiques. L'implémentation n'est pas la tête de l'abstraction. Il se contentera de définir les caractéristiques à inclure.

Encapsulation est réalisée en gardant les données et le comportement dans une capsule qui est la classe et en utilisant des modificateurs d'accès comme public, privé, protégé ainsi que l'héritage, l'agrégation ou la composition. Donc vous ne montrez que les choses nécessaires, cela aussi, seulement dans la mesure où vous voulez montrer. c.-à-d. public, protégé, amical et privé ka funda…… par exemple, GM décide d'utiliser le design abstrait de la voiture ci-dessus. Mais ils ont divers produits ayant les mêmes caractéristiques et de faire presque la même fonctionnalité. Ils écrivent donc une classe qui étend la classe abstraite ci-dessus. Il indique comment la boîte de vitesses devrait fonctionner, comment les pauses devraient fonctionner, comment le volant devrait fonctionner. Ensuite, tous les produits utilisent simplement cette fonctionnalité commune. Ils n'ont pas besoin de savoir comment l'engin la boîte fonctionne ou la casse fonctionne ou la direction fonctionne wheal. Produit indivisible peut certainement avoir plus de caractéristiques comme A / C ou Auto lock etc.....

sont tous deux puissants; mais l'utilisation de l'abstraction exige plus de compétences que l'encapsulation et les applications/produits plus grands ne peuvent pas survivre sans l'abstraction.

Abstraction---masquage de la mise en œuvre--à la conception - - - utilisation de l'Interface/calsses abstraites

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

prenons l'exemple d'une pile. Il peut être implémenté en utilisant un tableau ou une liste liée. Mais les opérations qu'il supporte sont push et pop. Maintenant l'abstraction n'expose que les interfaces push et pop. La représentation sous-jacente est caché(est-il 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 est faite pour les données abstraites? C'est là que l'Encapsulation. For E. les classes g en C++ utilisent spécificateurs d'accès qui assurent que l'accès et la modification accidentels sont évités. Et aussi en rendant les interfaces mentionnées ci-dessus publiques, cela garantit que la seule façon de manipuler la pile est à travers l'interface bien définie. Dans le processus, il a couplé les données et le code de la manipuler. (Ne laissons pas les fonctions d'ami impliquées ici.). C'est le code et les données sont collées ou attaché ou encapsulé

à Partir de ce

la 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. L'Encapsulation et L'Abstraction sont des termes interdépendants.

la Vie Réelle Différence Entre l'Encapsulation et d'Abstraction

encapsulé cacher. L'Encapsulation est aussi appelée dissimulation de données.Vous pouvez penser Encapsulation comme une capsule (comprimé de médicament) qui cache la médecine à l'intérieur. L'Encapsulation est enveloppante, cachant simplement les propriétés et les méthodes. L'Encapsulation est utilisée pour cacher le code et les données dans une seule unité pour protéger les données de l'extérieur du monde. La classe est le meilleur exemple d'encapsulation.

Abstraction se réfère à montrer seulement 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 faire la classe abstraite. Classe abstraite représente la vue abstraite des méthodes et propriétés de la classe.

implémentation Difference Between Encapsulation and Abstraction

1. l'Abstraction est mis en œuvre à l'aide de l'interface et la classe abstraite tandis que l'Encapsulation est mis en œuvre à l'aide de private et protected access modificateur.

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 dans un non-prévu. Grâce à l'encapsulation, seul un groupe prédéterminé de fonctions peut accéder aux données. Le terme collectif pour les types de données et les opérations (méthodes) regroupé avec les restrictions d'accès (public/privé, etc.) est une classe.

je vais essayer de démontrer l'Encapsulation d'une manière simple.. Permet de voir..

• le regroupement des données et des fonctions en une seule unité (appelée class) est connu sous le nom d'encapsulation. Encapsulation contenant et se cachant informations sur un objet, telles que les structures de données internes et code.

Encapsulation est -

• Masquage De La Complexité,
• données et fonction de liaison ensemble,
• Complexes, la Méthode du Privé,
• Faire de la Variable d'Instance Privée,
• cacher des données et des fonctions inutiles à L'utilisateur final.

Encapsulation implémente l'Abstraction.

et L'Abstraction est -

• Montrant Ce Qui Est Nécessaire,
• besoins en matière de Données à l'abrégé de l'Utilisateur Final,

voyons un exemple -

L'Image ci-dessous montre un GUI de"données client à ajouter dans une base de données".

en regardant l'Image nous pouvons dire que nous avons besoin d'une classe de client.

Étape-1: Quels sont les besoins de ma classe de clients?

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.

  espace de noms CustomerContent { public class Customer { public string CustomerCode = ""; public string CustomerName = ""; public void AJOUTER() { // mon code DB ira ici }

maintenant, N'ajouter que la méthode ne fonctionnera pas Ici seul.

Étape 2: Comment la validation va-t-elle fonctionner, ajouter la fonction agir?

nous vous aurez besoin du code de connexion de 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();
}
}

il n'est plus nécessaire de montrer les méthodes supplémentaires(Validate(); CreateDBObject() [méthode compliquée et supplémentaire] ) à l'utilisateur final.L'utilisateur final n'a besoin que de voir et de connaître le Code client, le nom du client et le bouton Ajouter qui ajoutera l'enregistrement.. L'utilisateur final ne se soucie pas de la façon dont il va ajouter les données à la base de données?.

Step -3: privé l'extra et compliqué méthodes qui n'impliquent pas L'Interaction de l'utilisateur final.

donc rendre ces méthodes compliquées et supplémentaires en tant que privé plutôt Public(I. e cacher ces méthodes) et la suppression de l'obj.Validate (); obj.CreateDBObject (); à partir du programme main in class, Nous réalisons L'Encapsulation.

en d'autres termes, la simplification de L'Interface à L'utilisateur final est L'Encapsulation.

donc maintenant le code ressemble comme 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: quels sont les besoins de ma classe de clients? est L'Abstraction.

Step -3: Step -3: Private 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.

le paragraphe ci-dessous 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 de données est un mécanisme de exposer seulement les interfaces et cacher les détails de l'implémentation la part de l'utilisateur.

vous pouvez lire la suite ici .

la dissimulation d'informations n'est pas strictement requise pour l'abstraction ou l'encapsulation. L'Information peut être ignorée, mais elle ne doit pas nécessairement être cachée.

Encapsulation est la capacité de traiter quelque chose comme une seule chose, même si elle peut être composée de nombreuses parties complexes ou des idées. par exemple, je peux dire que je suis assis dans une "chaise" plutôt que de faire référence aux nombreuses parties différentes de cette chaise chacun avec un la conception et la fonction, tout s'assemble dans le but précisément de bien mes fesses à quelques pieds du sol.

Abstraction est activée par encapsulation. Parce que nous encapsulons des objets, nous pouvons les considérer comme des choses qui se rapportent les uns aux autres d'une manière ou d'une autre plutôt que de nous enliser dans les détails subtils de la structure interne de l'objet. L'Abstraction est la capacité de considérer la vue d'ensemble, retiré de inquiétude sur les petits détails. la racine du mot est abstraite comme dans le résumé qui apparaît en haut d'un papier savant, et non abstraite comme dans une classe qui ne peut être instanciée que comme une sous-classe dérivée.

je peux honnêtement dire que quand je pose mon cul dans ma chaise, Je ne pense jamais à la façon dont la structure de cette chaise attrapera et tiendra Mon poids. C'est une chaise assez décente pour que je n'ai pas à m'inquiéter de ces détails. Donc, je peux tourner mon attention vers mon ordinateur. Et encore une fois, je ne pense pas aux composants de mon ordinateur. Je suis juste en train de regarder une partie d'une page Web qui représente une zone de texte que je peux taper, et je communique avec des mots, à peine même en pensant à comment mes doigts trouvent toujours les bonnes lettres si rapidement sur le clavier, et comment la connexion est finalement faite entre le tapotement de ces touches et l'affichage sur ce forum. C'est le grand pouvoir de l'abstraction. Parce que les niveaux inférieurs du système peuvent être de confiance pour travailler avec constance et précision, nous avons une attention à épargner pour un plus grand travail.

Encapsulation (données et Code de liaison)

• L'Encapsulation est le mécanisme qui lie le code et les données qu'il manipule, et qui protège à la fois contre les interférences extérieures et les abus.

• Dans un langage orienté-objet, le code et les données peuvent être combinés de telle manière qu'une "boîte noire" est créé. Lorsque le code et les données sont liées dans cette la mode, un objet est créé. En d'autres termes, un objet est le dispositif qui supporte l'encapsulation.

• L'Encapsulation conduit à la notion de dissimulation de données, mais la notion d'encapsulation ne doit pas se limiter à la dissimulation d'informations.

• L'Encapsulation représente clairement la capacité de regrouper des données et des fonctionnalités connexes au sein d'une seule entité autonome appelée classe.

Abstraction (Cacher comment les données stockées et cacher comment la fonction est mise en œuvre) "

• l'abstraction des données est un processus qui consiste à représenter les caractéristiques essentielles sans inclure les détails de la mise en œuvre.

• L'Abstraction est l'une des caractéristiques les plus puissantes et vitales de la programmation orientée objet.

• L'idée principale derrière l'abstraction de données est de donner une séparation claire entre les propriétés du type de données et les détails associés à la mise en œuvre. Cette séparation est réalisée afin que les propriétés du type de données abstraites soient visibles à l'interface utilisateur et que les détails de l'implémentation soient cachés.

• l'Abstraction est la séparation de la logique des propriétés de détails de mise en œuvre. Par exemple, la conduite de la voiture est une propriété logique et la conception de le moteur est le détail de l'implémentation.

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 cache des données non utiles aux utilisateurs et l'encapsulation est lient ensemble des données dans une capsule (une classe). Je pense que l'encapsulation est une façon d'atteindre l'abstraction.

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

une interface générée par encapsulation cache des détails d'implémentation.

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

Abstraction est un contrat pour la mise en œuvre que nous allons faire. La mise en œuvre peut changer 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 tous les APIs d'une classe dans un interface puis que nous demandions aux utilisateurs de notre code de s'appuyer sur le APIs défini du interface . Nous sont libres d'améliorer ou de modifier la mise en œuvre que nous devons suivre le contrat fixé. Les utilisateurs ne sont pas couplé avec notre mise en œuvre.

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 exécutantes, également la mise en œuvre ne fait pas partie de l'abstraction. C'est juste la signature et déclaration ce qui fait de l'abstraction.

Encapsulation est simplement Cacher les détails internes en réduisant l'accès des États et des comportements. Une classe encapsulée peut ou non avoir Abstraction bien défini .

java.util.List est une abstraction pour java.util.ArrayList . Les états internes de java.util.ArrayList étant marqués avec des modificateurs d'accès non public est encapsulation.

Modifier Supposons qu'une classe Container.nava implements IContainer , IContainer peut déclarer des méthodes comme addElement , removeElements , contains , etc. Ici IContainer représente l'abstraction pour sa classe d'implémentation. L'Abstraction est la déclaration des API de la classe ou d'un module ou d'un système au monde extérieur. Ces APIs deviennent le contract . Ce système pourrait être ou ne pas être encore développé. Les utilisateurs du système peuvent désormais dépendre des API déclarées et sont sûrs de tout système la mise en œuvre d'un tel contrat sera toujours conforme aux IPA déclarés, ils fourniront toujours la mise en œuvre tge pour ces IPA. Une fois que nous écrivons quelque entité concrète puis décider de cacher nos états internes est encapsulation

on pourrait soutenir que l'abstraction est une technique qui nous aide à identifier quelles informations spécifiques devraient être visibles, et quelles informations devraient être cachées. L'Encapsulation est alors la technique d'empaquetage de l'information de manière à masquer ce qui doit être caché et à rendre visible ce qui est censé être visible.