Was ist der genaue Unterschied zwischen Kapselung und Abstraktion?

Die meisten Antworten hier konzentrieren sich auf OOP, aber die Kapselung beginnt viel früher:

• Jede Funktion ist eine Kapselung ; im Pseudocode:

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

  Hier wird distancedie Berechnung des (euklidischen) Abstands zwischen zwei Punkten in einer Ebene zusammengefasst: Es werden Implementierungsdetails ausgeblendet. Dies ist schlicht und einfach Verkapselung.

• Abstraktion ist der Prozess der Verallgemeinerung : Nehmen Sie eine konkrete Implementierung und machen Sie sie auf verschiedene, wenn auch etwas verwandte Datentypen anwendbar. Das klassische Beispiel für Abstraktion ist dieqsortFunktion vonCzum Sortieren von Daten:

  Die Sache qsortist, dass es sich nicht um die Daten kümmert, die es sortiert - tatsächlich weiß es nicht, welche Daten es sortiert. Der Eingabetyp ist vielmehr ein typloser Zeiger ( void*), mit dem C nur sagt: „Der Datentyp ist mir egal“ (dies wird auch als Typlöschung bezeichnet). Der wichtige Punkt ist, dass die Implementierung von qsortunabhängig vom Datentyp immer gleich bleibt. Das einzige, was sich ändern muss, ist die Vergleichsfunktion, die sich von Datentyp zu Datentyp unterscheidet. qsorterwartet daher, dass der Benutzer diese Vergleichsfunktion als Funktionsargument bereitstellt.

Verkapselung und Abstraktion gehen so weit Hand in Hand, dass Sie darauf hinweisen können, dass sie wirklich untrennbar miteinander verbunden sind. Aus praktischen Gründen ist dies wahrscheinlich richtig; Das heißt, hier ist eine Kapselung, die keine große Abstraktion ist:

class point {
    numeric x
    numeric y
}

Wir kapseln die Koordinate des Punktes, aber wir abstrahieren sie nicht materiell, sondern gruppieren sie logisch.

Und hier ist ein Beispiel für eine Abstraktion, die keine Kapselung ist:

T pi<T> = 3.1415926535

Dies ist eine generische Variable pi mit einem bestimmten Wert (π), und die Deklaration kümmert sich nicht um den genauen Typ der Variablen. Zugegeben, es fällt mir schwer, so etwas in echtem Code zu finden: Abstraktion verwendet praktisch immer Kapselung. Das Obige existiert jedoch tatsächlich in C ++ (14) über Variablenvorlagen (= generische Vorlagen für Variablen); mit einer etwas komplexeren Syntax, zB:

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

Durch die Kapselung werden die Implementierungsdetails ausgeblendet, die für allgemeine oder spezielle Verhaltensweisen gelten können oder nicht.

Abstraktion bietet eine Verallgemeinerung (z. B. über eine Reihe von Verhaltensweisen).

Hier ist eine gute Lektüre: Abstraktion, Kapselung und Verstecken von Informationen von Edward V. Berard von der Object Agency.

Viele Antworten und ihre Beispiele sind irreführend.

Kapselung ist das Packen von Daten und Funktionen, die mit diesen Daten arbeiten, in eine einzelne Komponente und das Einschränken des Zugriffs auf einige Komponenten des Objekts.
Kapselung bedeutet, dass die interne Darstellung eines Objekts außerhalb der Objektdefinition im Allgemeinen nicht sichtbar ist.

Abstraktion ist ein Mechanismus, der die wesentlichen Merkmale ohne Einbeziehung von Implementierungsdetails darstellt.

Kapselung: - Verstecken von Informationen .
Abstraktion: - Implementierung versteckt .

Beispiel:

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

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

Die interne Darstellung eines fooKlassenobjekts ist außerhalb der Klasse verborgen. -> Kapselung.
Jedes zugängliche Mitglied (Daten / Funktion) eines Objekts von fooist eingeschränkt und kann nur von diesem Objekt aufgerufen werden.

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

Die Implementierung der Methode addist ausgeblendet. -> Abstraktion.

Die Kapselung packt einige Dinge in eine Schachtel und gibt Ihnen ein Guckloch. Dies hält Sie davon ab, mit den Zahnrädern zu spielen.

Bei der Abstraktion werden die Details ignoriert, die keine Rolle spielen, z. B. ob die Dinge Zahnräder, Ratschen, Schwungräder oder Kernkerne haben. sie "gehen" einfach

Beispiele für die Einkapselung:

• Unterhose
• Werkzeugkasten
• Brieftasche
• Handtasche
• Kapsel
• gefrorener Karbonit
• eine Box mit oder ohne Knopf
• ein Burrito (technisch gesehen die Tortilla um den Burrito)

Beispiele für Abstraktion:

• "Gruppen von Dingen" ist eine Abstraktion (die wir Aggregation nennen)
• "Dinge, die andere Dinge enthalten" ist eine Abstraktion (die wir Komposition nennen)
• "Container" ist eine andere Art von "Dinge, die andere Dinge enthalten" Abstraktion; Beachten Sie, dass alle Einkapselungsbeispiele Arten von Behältern sind, aber nicht alle Behälter eine Einkapselung aufweisen / bereitstellen. Ein Korb ist beispielsweise ein Container, der seinen Inhalt nicht einschließt.

Kapselung bedeutet, Daten wie Getter und Setter usw. zu verbergen.

Abstraktion bedeutet, die Implementierung mit abstrakten Klassen und Schnittstellen usw. zu verbergen.

Abstraktion ist ein allgemeiner Begriff. dh die Kapselung ist eine Teilmenge der Abstraktion.

• Beispiel 2:
  Der Lösungsarchitekt ist die Person, die das abstrakte technische Design der gesamten Lösung auf hoher Ebene erstellt. Dieses Design wird dann zur Implementierung an das Entwicklungsteam übergeben .

  Hier fungiert der Lösungsarchitekt als Zusammenfassung und das Entwicklungsteam als Kapselung.

• Beispiel 3: Kapselung (Vernetzung) von Benutzerdaten

Höflichkeit

Abstraktion (oder Modularität) - Mithilfe von Typen können Programmierer auf einer höheren Ebene als das Bit oder Byte denken, ohne sich um die Implementierung auf niedriger Ebene zu kümmern. Zum Beispiel können Programmierer beginnen, sich eine Zeichenfolge als einen Satz von Zeichenwerten anstatt als ein bloßes Array von Bytes vorzustellen. Noch höher ist, dass Typen es Programmierern ermöglichen, über Schnittstellen zwischen zwei Subsystemen beliebiger Größe nachzudenken und diese auszudrücken. Dies ermöglicht mehr Lokalisierungsebenen, so dass die für die Interoperabilität der Subsysteme erforderlichen Definitionen konsistent bleiben, wenn diese beiden Subsysteme kommunizieren. Quelle

Viele gute Antworten sind oben angegeben, aber ich werde hier meinen (Java-) Standpunkt vorstellen.

Datenkapselung bedeutet einfach, den Zugriff auf logisch gruppierte Daten in einer Klasse zu verpacken und zu steuern. Es ist im Allgemeinen mit einem anderen Schlüsselwort verknüpft - Data Hiding . Dies wird in Java mithilfe von Zugriffsmodifikatoren erreicht .

Ein einfaches Beispiel wäre, eine private Variable zu definieren und mit Getter- und Setter-Methoden Zugriff darauf zu gewähren oder eine Methode privat zu machen, da sie nur mit der Klasse verwendet wird. Der Benutzer muss diese Methoden und Variablen nicht kennen.

Hinweis : Es sollte nicht missverstanden werden, dass es bei der Kapselung nur um das Verstecken von Daten geht. Wenn wir von Kapselung sprechen, sollte der Schwerpunkt auf der Gruppierung oder Verpackung oder Bündelung verwandter Daten und Verhaltensweisen liegen.

Datenabstraktion ist andererseits ein Konzept der Verallgemeinerung, so dass die darunter liegende komplexe Logik dem Benutzer nicht ausgesetzt wird. In Java wird dies durch die Verwendung von Schnittstellen und abstrakten Klassen erreicht.

Beispiel -

Nehmen wir an, wir haben eine Schnittstelle Animal und eine Funktion makeSound () . Es gibt zwei konkrete Klassen Dog und Cat , die diese Schnittstelle implementieren. Diese konkreten Klassen haben separate Implementierungen der Funktion makeSound (). Nehmen wir jetzt an, wir haben ein Tier (wir bekommen dies von einem externen Modul). Alles, was der Benutzer weiß, ist, dass das Objekt, das er empfängt, ein Tier ist und es in der Verantwortung des Benutzers liegt, den Tierklang zu drucken. Ein Brute - Force - Weg ist es, das Objekt empfangen zu überprüfen , zu identifizieren seine Art, dann Typumwandlung es zu diesem Tiertyp und dann ruft makeSound () auf sich. Ein besserer Weg ist jedoch die Dinge abstrahieren . Verwenden Sie Tier alspolymorphe Referenz abhängig vom richtigen Objekttyp die richtige Funktion aufgerufen.und rufe makeSound () darauf auf. Zur Laufzeit

Weitere Details hier .

Komplexe Logik befindet sich in der Leiterplatte, die in ein Touchpad eingekapselt ist, und eine schöne Oberfläche (Tasten) wird bereitgestellt, um sie dem Benutzer zu abstrahieren.

PS: Die obigen Links führen zu meinem persönlichen Blog.

• Mit Abstraktion können Sie sich darauf konzentrieren, was das Objekt tut, anstatt wie es es tut
• Kapselung bedeutet, die internen Details oder Mechanismen zu verbergen, wie ein Objekt etwas tut.

Wie wenn Sie ein Auto fahren, wissen Sie, was das Gaspedal tut, aber Sie kennen möglicherweise nicht den Prozess dahinter, weil es gekapselt ist.

Lassen Sie mich ein Beispiel in C # geben. Angenommen, Sie haben eine Ganzzahl:

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

Sie können eine Methode wie Number.ToString () verwenden, die Ihnen die Zeichendarstellung der Zahl 5 zurückgibt und diese in einem Zeichenfolgenobjekt speichert. Die Methode sagt Ihnen, was es tut, anstatt wie es es tut.

Dies sind etwas unscharfe Konzepte, die nicht nur für Informatik und Programmierung gelten. Ich möchte einige zusätzliche Gedanken anführen, die anderen helfen können, diese wichtigen Konzepte zu verstehen.

Kurze Antwort

Kapselung - Verstecken und / oder Einschränken des Zugriffs auf bestimmte Teile eines Systems, während die erforderlichen Schnittstellen verfügbar gemacht werden.

Abstraktion - Betrachtet man etwas, bei dem bestimmte Merkmale entfernt wurden, abgesehen von konkreten Realitäten, bestimmten Objekten oder tatsächlichen Instanzen, wodurch die Komplexität verringert wird.

Die Hauptähnlichkeit besteht darin, dass diese Techniken darauf abzielen, das Verständnis und den Nutzen zu verbessern.

Der Hauptunterschied besteht darin , dass Abstraktion ist ein Mittel darstellt , die Dinge einfach (oft die Darstellung breiter anwendbar zu machen), während die Verkapselung ein Verfahren zum Ändern der Art und Weise andere Dinge Interact mit etwas ist.

Lange Antwort

Verkapselung

Hier ist ein Beispiel für die Kapselung, das die Dinge hoffentlich klarer macht:

Hier haben wir einen Arduino Uno und ein Arduino Uno in einem Gehäuse. Ein Gehäuse ist eine großartige Darstellung dessen, worum es bei der Kapselung geht.

Die Kapselung zielt darauf ab, bestimmte Komponenten vor äußeren Einflüssen und Wissen zu schützen sowie Komponenten freizulegen, mit denen andere Dinge in Verbindung stehen sollten. In Bezug auf die Programmierung beinhaltet dies das Ausblenden von Informationen durch Zugriffsmodifikatoren , die das Ausmaß ändern, in dem bestimmte Variablen und / oder Eigenschaften gelesen und geschrieben werden können.

Darüber hinaus zielt die Kapselung auch darauf ab, diese externen Schnittstellen viel effektiver bereitzustellen. In unserem Arduino-Beispiel könnten dies die netten Schaltflächen und der Bildschirm sein, die die Interaktion des Benutzers mit dem Gerät viel einfacher machen. Sie bieten dem Benutzer einfache Möglichkeiten, das Verhalten des Geräts zu beeinflussen und nützliche Informationen über dessen Betrieb zu erhalten, die sonst viel schwieriger wären.

In Programmierung beinhaltet dies die Gruppierung der verschiedenen Komponenten in ein trennbares Konstrukt, wie beispielsweise ein function, classoder object. Es umfasst auch die Bereitstellung der Mittel zur Interaktion mit diesen Konstrukten sowie Methoden, um nützliche Informationen über sie zu erhalten.

Die Kapselung hilft Programmierern auf viele weitere Arten, nicht zuletzt durch eine verbesserte Wartbarkeit und Testbarkeit des Codes.

Abstraktion

Obwohl viele andere Antworten hier Abstraktion als Verallgemeinerung definierten, denke ich persönlich, dass Definition falsch ist. Ich würde sagen, dass Verallgemeinerung tatsächlich eine bestimmte Art von Abstraktion ist, nicht umgekehrt. Mit anderen Worten sind alle Verallgemeinerungen Abstraktionen, aber alle Abstraktionen sind nicht unbedingt Verallgemeinerungen.

So denke ich gerne über Abstraktion:

Würden Sie sagen, das Bild dort ist ein Baum? Die Chancen stehen gut, dass Sie würden. Aber ist es wirklich ein Baum? Na klar nicht! Es sind ein paar Pixel, die so aussehen, als würden wir einen Baum nennen. Wir könnten sagen, dass es eine Abstraktion eines echten Baumes darstellt. Beachten Sie, dass einige visuelle Details des Baums weggelassen werden. Außerdem wächst es nicht, verbraucht kein Wasser und produziert keinen Sauerstoff. Wie könnte es? Es ist nur eine Reihe von Farben auf einem Bildschirm, die durch Bytes in Ihrem Computerspeicher dargestellt werden.

Und hier ist das Wesen der Abstraktion. Dies ist eine Möglichkeit, Dinge zu vereinfachen, damit sie leichter zu verstehen sind. Jede Idee, die dir durch den Kopf geht, ist eine Abstraktion der Realität. Ihr mentales Bild eines Baumes ist nicht mehr ein tatsächlicher Baum als dieses JPEG.

Bei der Programmierung können wir dies zu unserem Vorteil nutzen, indem wir eine TreeKlasse mit Methoden für simuliertes Wachsen, Wasserverbrauch und Sauerstoffproduktion erstellen . Unsere Kreation wäre etwas, das unsere Erfahrung mit tatsächlichen Bäumen darstellt und nur die Elemente enthält, die uns für unsere spezielle Simulation wirklich wichtig sind. Wir verwenden die Abstraktion, um unsere Erfahrung von etwas mit Bytes und Mathematik darzustellen.

Abstrakte Klassen

Die Abstraktion bei der Programmierung ermöglicht es uns auch, Gemeinsamkeiten zwischen mehreren "konkreten" Objekttypen (tatsächlich existierende Typen) zu berücksichtigen und diese Gemeinsamkeiten innerhalb einer eindeutigen Entität zu definieren. Zum Beispiel kann unsere TreeKlasse von einer erben abstract class Plant, die mehrere Eigenschaften und Methoden hat, die für alle unsere pflanzenähnlichen Klassen gelten, aber diejenigen entfernt , die für jeden Pflanzentyp spezifisch sind. Dies kann die Duplizierung von Code erheblich reduzieren und die Wartbarkeit verbessern.

Der praktische Unterschied zwischen a abstract classund plain classbesteht darin, dass es konzeptionell keine "echten" Instanzen von gibt abstract class. Es wäre nicht sinnvoll, ein PlantObjekt zu konstruieren, da dies nicht spezifisch genug ist. Jedes "echte" Plantist auch eine spezifischere Art von Plant.

Wenn wir möchten, dass unser Programm realistischer ist, sollten wir auch die Tatsache berücksichtigen, dass unsere TreeKlasse selbst möglicherweise zu abstrakt ist. In Wirklichkeit ist jeder Treeeine spezifischere Art von Tree, so dass wir Klassen für jene Typen wie usw. erstellen Birchkönnen Maple, die von unserer, vielleicht jetzt abstract, TreeKlasse erben .

JVM

Ein weiteres gutes Beispiel für die Abstraktion ist die Java Virtual Machine (JVM) , die einen virtuellen oder abstrakten Computer für die Ausführung von Java-Code bereitstellt. Es entfernt im Wesentlichen alle plattformspezifischen Komponenten eines Systems und bietet eine abstrakte Schnittstelle von "Computer" ohne Rücksicht auf ein bestimmtes System.

Der Unterschied

Die Verkapselung unterscheidet sich von der Abstraktion darin, dass sie nichts damit zu tun hat, wie "real" oder "genau" etwas ist. Dabei spielt es keine entfernen Komponenten von etwas , das es einfacher oder breiter anwendbar zu machen. Vielmehr kann es bestimmte Komponenten verbergen , um einen ähnlichen Zweck zu erreichen.

Kapselung : Versteckt unerwünschte / unerwartete / ordnungsgemäße Implementierungsdetails vor den tatsächlichen Benutzern des Objekts. z.B

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

Abstraktion : Ist eine Möglichkeit zur Verallgemeinerung und damit eine übliche Methode zur Arbeit mit Objekten mit großer Vielfalt. z.B

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

Unterschied zwischen Abstraktion und Verkapselung.

Abstraktion: Die Idee, etwas auf eine vereinfachte / andere Art und Weise darzustellen, die entweder leichter zu verstehen und zu verwenden ist oder für die Situation relevanter ist.

Stellen Sie sich eine Klasse vor, die eine E-Mail sendet ... Sie verwendet die Abstraktion, um sich Ihnen als eine Art Botenjunge zu zeigen, sodass Sie emailSender.send (E-Mail, Empfänger) aufrufen können. Was es tatsächlich tut - wählt POP3 / SMTP, ruft Server an, MIME-Übersetzung usw. wird weg abstrahiert. Sie sehen nur Ihren Botenjungen.

Kapselung: Die Idee, Daten und Methoden zu sichern und auszublenden, die für ein Objekt privat sind. Es geht mehr darum, etwas unabhängig und kinderleicht zu machen.

Nimm mich zum Beispiel. Ich kapsle meine Herzfrequenz vom Rest der Welt. Weil ich nicht möchte, dass jemand anderes diese Variable ändert, und ich brauche niemanden, der sie einstellt, damit ich funktionieren kann. Es ist lebenswichtig für mich, aber Sie müssen nicht wissen, was es ist, und es ist Ihnen wahrscheinlich sowieso egal.

Wenn Sie sich umschauen, werden Sie feststellen, dass fast alles, was Sie berühren, ein Beispiel für Abstraktion und Kapselung ist. Ihr Telefon bietet Ihnen beispielsweise die Abstraktion, das, was Sie sagen, zu nehmen und es jemand anderem zu sagen - es deckt GSM, Prozessorarchitektur, Funkfrequenzen und eine Million anderer Dinge ab, die Sie nicht verstehen oder die Sie nicht interessieren. Es kapselt auch bestimmte Daten von Ihnen, wie Seriennummern, ID-Nummern, Frequenzen usw.

Das alles macht die Welt zu einem schöneren Ort zum Leben: D.

Abstraktion: Es werden nur die erforderlichen Informationen angezeigt. Konzentrieren wir uns auf das Beispiel des Einschaltens eines Computers. Der Benutzer muss nicht wissen, was passiert, während das System noch geladen wird (diese Informationen sind dem Benutzer verborgen).

Nehmen wir ein anderes Beispiel, das des Geldautomaten. Der Kunde muss nicht wissen, wie das Gerät die PIN liest und die Transaktion verarbeitet. Er muss lediglich die PIN eingeben, das Geld nehmen und gehen.

Kapselung: Behandelt das Verstecken der sensiblen Daten einer Klasse, wodurch ein Teil davon privatisiert wird. Es ist eine Möglichkeit, einige Informationen für seine Kunden privat zu halten, indem kein Zugriff von außen darauf gewährt wird.

Ein anderes Beispiel:

Angenommen, ich habe eine unveränderliche Rechteckklasse wie diese erstellt:

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

Jetzt ist es offensichtlich, dass ich Breite und Höhe eingekapselt habe (der Zugriff ist irgendwie eingeschränkt), aber ich habe nichts abstrahiert (okay, vielleicht habe ich ignoriert, wo sich das Rechteck im Koordinatenraum befindet, aber dies ist ein Fehler der Beispiel).

Eine gute Abstraktion setzt normalerweise eine gute Kapselung voraus.

Ein Beispiel für eine gute Abstraktion ist eine generische Datenbankverbindungsklasse. Die öffentliche Schnittstelle ist datenbankunabhängig und sehr einfach, ermöglicht mir jedoch, mit der Verbindung das zu tun, was ich will. Und siehst du? Dort gibt es auch eine Kapselung, da die Klasse alle Handles und Aufrufe auf niedriger Ebene enthalten muss.

Abstractionund Encapsulationunter Verwendung eines einzelnen verallgemeinerten Beispiels

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

Wir alle verwenden den Taschenrechner zur Berechnung komplexer Probleme!

Ein Mechanismus, der verhindert, dass die Daten eines bestimmten Objekts vor absichtlichem oder versehentlichem Missbrauch durch externe Funktionen geschützt sind, wird als " Datenkapselung" bezeichnet.

Das Darstellen wesentlicher Merkmale ohne Berücksichtigung der Hintergrunddetails oder Erklärungen wird als Abstraktion bezeichnet

Abstraktion: Abstraktion bedeutet, einen WhatTeil der Funktionalität zu zeigen .

Kapselung: Kapselung bedeutet, den HowTeil der Funktionalität auszublenden .

Nehmen wir ein sehr einfaches Beispiel

/// <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
    }
}

Programmklasse der Konsolenanwendung

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

Nehmen wir das Beispiel eines Stapels. Es könnte unter Verwendung eines Arrays oder einer verknüpften Liste implementiert werden. Aber die Operationen, die es unterstützt, sind Push und Pop.

Jetzt macht die Abstraktion nur die Schnittstellen Push und Pop verfügbar. Die zugrunde liegende Darstellung ist ausgeblendet (ist es ein Array oder eine verknüpfte Liste?) Und es wird eine genau definierte Schnittstelle bereitgestellt. Wie stellen Sie nun sicher, dass kein versehentlicher Zugriff auf die abstrahierten Daten erfolgt? Hier kommt die Kapselung ins Spiel. Beispielsweise verwenden Klassen in C ++ die Zugriffsspezifizierer, die sicherstellen, dass versehentlicher Zugriff und Änderungen verhindert werden. Durch die Veröffentlichung der oben genannten Schnittstellen wird außerdem sichergestellt, dass der Stapel nur über die genau definierte Schnittstelle bearbeitet werden kann. Dabei hat es die Daten und den Code gekoppelt, der sie manipulieren kann (lassen Sie uns hier nicht die Friend-Funktionen einbeziehen). Das heißt, der Code und die Daten werden miteinander verbunden oder gebunden oder gekapselt.

Die Kapselung fasst die Komplexität in einer Kapsel zusammen, die Klasse und damit Kapselung ist. Während Abstraktion die Eigenschaften eines Objekts sind, die sich von anderen Objekten unterscheiden.

Die Abstraktion kann erreicht werden, indem die Klasse abstrakt gemacht wird, wobei eine oder mehrere Methoden abstrakt sind. Welches ist nichts anderes als das Merkmal, das von der Klasse implementiert werden sollte, die es erweitert. Wenn Sie beispielsweise ein Auto erfinden / entwerfen, definieren Sie eine Eigenschaft, bei der das Auto 4 Türen, Bremsen, Lenkrad usw. haben sollte. Daher sollte jeder, der diese Konstruktion verwendet, diese Eigenschaften enthalten. Die Implementierung ist nicht der Kopf jeder Abstraktion. Es werden nur Merkmale definiert, die einbezogen werden sollen.

Die Kapselung wird erreicht, indem Daten und das Verhalten in einer Kapsel der Klasse & gespeichert werden, indem Zugriffsmodifikatoren wie öffentlich, privat, geschützt zusammen mit Vererbung, Aggregation oder Zusammensetzung verwendet werden. Sie zeigen also nur die erforderlichen Dinge, auch das nur in dem Umfang, den Sie zeigen möchten. dh öffentliche, geschützte, freundliche und private ka funda …… zB GM beschließt, das abstrahierte Design des oben genannten Autos zu verwenden. Aber sie haben verschiedene Produkte mit den gleichen Eigenschaften und fast der gleichen Funktionalität. Also schreiben sie eine Klasse, die die obige abstrakte Klasse erweitert. Es heißt, wie das Getriebe funktionieren soll, wie die Bremse funktionieren soll, wie das Lenkrad funktionieren soll. Dann verwenden alle Produkte nur diese gemeinsame Funktionalität. Sie müssen nicht wissen, wie das Getriebe funktioniert oder wie das Bremsen funktioniert oder wie das Quaddeln funktioniert.

Beide sind mächtig; Die Verwendung von Abstraktion erfordert jedoch mehr Fähigkeiten als die Kapselung, und größere Anwendungen / Produkte können ohne Abstraktion nicht überleben.

Abstraktion --- Ausblenden der Implementierung - beim Entwurf --- Verwenden von Interface / Abstract Calsses

Kapselung - Ausblenden von Daten - Bei der Entwicklung --- Verwenden von Zugriffsmodifikatoren (öffentlich / privat)

aus diesem

Unterschied zwischen Verkapselung und Abstraktion in OOPS

Abstraktion und Kapselung sind zwei wichtige Konzepte der objektorientierten Programmierung (OOPS). Kapselung und Abstraktion sind miteinander verbundene Begriffe.

Realer Unterschied zwischen Verkapselung und Abstraktion

Kapselung bedeutet sich zu verstecken. Die Einkapselung wird auch als Verstecken von Daten bezeichnet. Sie können sich die Einkapselung wie eine Kapsel (Medizin-Tablette) vorstellen, die die Medizin darin verbirgt. Die Kapselung wird umbrochen, nur Eigenschaften und Methoden werden ausgeblendet. Die Kapselung wird verwendet, um den Code und die Daten in einer einzigen Einheit zu verbergen, um die Daten vor der Außenwelt zu schützen. Klasse ist das beste Beispiel für Kapselung.

Abstraktion bezieht sich darauf, dem beabsichtigten Benutzer nur die erforderlichen Details anzuzeigen. Wie der Name schon sagt, ist Abstraktion die "abstrakte Form von allem". Wir verwenden Abstraktion in Programmiersprachen, um abstrakte Klassen zu erstellen. Die abstrakte Klasse repräsentiert eine abstrakte Ansicht der Methoden und Eigenschaften der Klasse.

Implementierungsunterschied zwischen Kapselung und Abstraktion

1. Die Abstraktion wird mithilfe der Schnittstelle und der abstrakten Klasse implementiert, während die Kapselung mithilfe des privaten und geschützten Zugriffsmodifikators implementiert wird.

2. OOPS verwendet die Kapselung, um die Integrität eines Typs zu erzwingen (dh um sicherzustellen, dass die Daten in geeigneter Weise verwendet werden), indem verhindert wird, dass Programmierer auf nicht beabsichtigte Weise auf Daten zugreifen. Durch die Kapselung kann nur eine vorbestimmte Gruppe von Funktionen auf die Daten zugreifen. Der Sammelbegriff für Datentypen und Operationen (Methoden), die zusammen mit Zugriffsbeschränkungen (öffentlich / privat usw.) gebündelt sind, ist eine Klasse.

Ich werde versuchen, die Kapselung auf einfache Weise zu demonstrieren. Mal sehen.

• Das Zusammenfassen von Daten und Funktionen in einer einzigen Einheit (Klasse genannt) wird als Kapselung bezeichnet. Kapselung, die Informationen zu einem Objekt enthält und verbirgt, z. B. interne Datenstrukturen und Code.

Verkapselung ist -

• Komplexität verbergen,
• Daten und Funktion zusammenbinden,
• Komplizierte Methoden privat machen,
• Instanzvariable privat machen,
• Unnötige Daten und Funktionen vor dem Endbenutzer ausblenden.

Kapselung implementiert Abstraktion.

Und Abstraktion ist -

• Zeigen, was notwendig ist,
• Daten müssen vom Endbenutzer abstrahiert werden.

Sehen wir uns ein Beispiel an.

Das folgende Bild zeigt eine grafische Benutzeroberfläche mit "Kundendetails, die einer Datenbank hinzugefügt werden sollen".

Wenn wir uns das Bild ansehen, können wir sagen, dass wir eine Kundenklasse brauchen.

Schritt 1: Was braucht meine Kundenklasse?

dh

• 2 Variablen zum Speichern des Kundencodes und des Kundennamens.

• 1 Funktion zum Hinzufügen des Kundencodes und des Kundennamens zur Datenbank.

  Namespace CustomerContent {public class Customer {public string CustomerCode = ""; public string CustomerName = ""; public void ADD () {// mein DB-Code wird hier abgelegt}

Jetzt funktioniert nur die ADD-Methode hier nicht mehr alleine.

Schritt -2: Wie funktioniert die Validierung, ADD-Funktion?

Wir benötigen Datenbankverbindungscode und Validierungscode (zusätzliche Methoden).

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

Jetzt müssen dem Endbenutzer die zusätzlichen Methoden (Validate (); CreateDBObject () [Komplizierte und zusätzliche Methode]) nicht mehr angezeigt werden. Der Endbenutzer muss nur noch den Kundencode, den Kundennamen und die Schaltfläche HINZUFÜGEN sehen, die hinzugefügt werden Der Datensatz. Dem Endbenutzer ist es egal, wie er die Daten zur Datenbank hinzufügt.

Schritt -3: Private die zusätzlichen und komplizierten Methoden, die keine Interaktion des Endbenutzers beinhalten.

Machen Sie diese komplizierten und zusätzlichen Methoden also als privat statt öffentlich (dh verstecken Sie diese Methoden) und löschen Sie das obj.Validate (); obj.CreateDBObject (); Vom Hauptprogramm in der Klasse erreichen wir die Kapselung.

Mit anderen Worten: Die Vereinfachung der Schnittstelle zum Endbenutzer ist die Kapselung.

Der Code sieht nun wie folgt aus:

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

Zusammenfassung :

Schritt -1: Was braucht meine Kundenklasse? ist Abstraktion.

Schritt -3: Schritt -3: Private die zusätzlichen und komplizierten Methoden, die keine Interaktion des Endbenutzers beinhalten, sind Kapselung.

PS - Der obige Code ist hart und schnell.

Der folgende Absatz hat mir geholfen zu verstehen, wie sie sich voneinander unterscheiden:

Die Datenkapselung ist ein Mechanismus zum Bündeln der Daten, und die Funktionen, die sie verwenden, und die Datenabstraktion sind ein Mechanismus zum Offenlegen nur der Schnittstellen und zum Ausblenden der Implementierungsdetails vor dem Benutzer.

Sie können mehr lesen hier .

Das Ausblenden von Informationen ist für die Abstraktion oder Kapselung nicht unbedingt erforderlich. Informationen werden möglicherweise ignoriert, müssen jedoch nicht ausgeblendet werden.

Kapselung ist die Fähigkeit, etwas als eine einzige Sache zu behandeln, obwohl es aus vielen komplexen Teilen oder Ideen bestehen kann. Zum Beispiel kann ich sagen, dass ich auf einem "Stuhl" sitze, anstatt mich auf die vielen verschiedenen Teile dieses Stuhls zu beziehen, die jeweils ein bestimmtes Design und eine bestimmte Funktion haben und alle genau zusammenpassen, um meinen Hintern bequem ein paar Fuß zu halten vom Boden weg.

Die Abstraktion wird durch Einkapselung aktiviert. Da wir Objekte einkapseln, können wir sie als Dinge betrachten, die in irgendeiner Weise miteinander in Beziehung stehen, anstatt sich in den subtilen Details der internen Objektstruktur festzumachen. Abstraktion ist die Fähigkeit, das Gesamtbild zu betrachten, ohne sich um kleine Details zu kümmern. Die Wurzel des Wortes ist abstrakt wie in der Zusammenfassung, die oben in einer wissenschaftlichen Arbeit erscheint, nicht abstrakt wie in einer Klasse, die nur als abgeleitete Unterklasse instanziiert werden kann.

Ich kann ehrlich sagen, dass ich, wenn ich meinen Hintern in meinen Stuhl plumpse, nie darüber nachdenke, wie die Struktur dieses Stuhls mein Gewicht fängt und hält. Es ist ein Stuhl, der anständig genug ist, dass ich mir um diese Details keine Sorgen machen muss. So kann ich meine Aufmerksamkeit auf meinen Computer richten. Und wieder denke ich nicht an die Komponenten meines Computers. Ich betrachte nur einen Teil einer Webseite, der einen Textbereich darstellt, den ich eingeben kann, und kommuniziere in Worten. Ich denke kaum daran, wie meine Finger immer so schnell die richtigen Buchstaben auf der Tastatur finden und wie Die Verbindung wird letztendlich zwischen dem Tippen auf diese Schlüssel und dem Posten in diesem Forum hergestellt. Dies ist die große Kraft der Abstraktion. Da man sich darauf verlassen kann, dass die unteren Ebenen des Systems konsistent und präzise arbeiten, müssen wir auf größere Arbeiten achten.

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

Die Abstraktion verbirgt nicht nützliche Daten vor Benutzern und die Kapselung bindet Daten zu einer Kapsel (einer Klasse) zusammen. Ich denke, Kapselung ist der Weg, auf dem wir Abstraktion erreichen.

Der Prozess der Abstraktion und Kapselung erzeugt beide Schnittstellen.

Eine über die Kapselung generierte Schnittstelle verbirgt Implementierungsdetails.

Eine über die Abstraktion generierte Schnittstelle kann auf mehr Datentypen angewendet werden als vor der Abstraktion.

Abstractionist ein Vertrag für die Implementierung, die wir machen werden. Die Implementierung kann sich im Laufe der Zeit ändern. Die verschiedenen Implementierungen selbst können ausgeblendet sein oder nicht, sind jedoch hinter der Abstraktion maskiert .

Angenommen, wir definieren die gesamte APIsKlasse in einer Klasse interfaceund bitten die Benutzer unseres Codes, von der Definition APIsder Klasse abhängig zu sein interface. Es steht uns frei, die Implementierung zu verbessern oder zu modifizieren, nur wir müssen den festgelegten Vertrag befolgen. Die Benutzer sind nicht an unsere Implementierung gekoppelt .

Wir legen alle notwendigen Regeln (Methoden) in der Abstraktion offen , die Implementierung der Regeln bleibt den Implementiererentitäten überlassen, auch die Implementierung ist nicht Teil der Abstraktion. Es ist nur die Unterschrift und Erklärung, die die Abstraktion ausmacht.

Encapsulationeinfach ist HIDING die inneren Details von der acess der Zustände und Verhaltensweisen zu reduzieren. Eine gekapselte Klasse kann gut definiert sein oder nicht Abstraction.

java.util.Listist eine Abstraktion für java.util.ArrayList. Der interne Zustand, in java.util.ArrayListdem mit non publicZugriffsmodifikatoren markiert wird, ist die Kapselung.

Bearbeiten Angenommen , eine Klasse Container.nava implements IContainer, IContainerkann erklären , Methoden wie addElement, removeElements, containsusw. Hier IContainerdie Abstraktion für die implementierende Klasse darstellt. Abstraktion deklariert die APIs der Klasse oder eines Moduls oder eines Systems gegenüber der Außenwelt. Diese APIs werden zum contract. Dieses System kann noch entwickelt sein oder nicht. Die Benutzer des Systems können sich jetzt auf die deklarierten APIs verlassen und sind sich sicher, dass jedes System, das einen solchen Vertrag implementiert, immer die deklarierten APIs einhält. Sie stellen immer die Implementierung für diese APIs bereit. Sobald wir eine konkrete Entität schreiben, ist die Entscheidung, unsere internen Zustände zu verbergen, die Kapselung

Ich denke, Kapselung ist ein Weg, um Abstraktion zu implementieren. Schauen Sie sich den folgenden Link an.

Abstraktion und Verkapselung

Zusamenfassend

Verwendung von Abstraktionen -> Verwendung von Kapselung und Kapselung -> Ausblenden von Daten

ODER

Das Ausblenden von Daten ist eine Teilmenge der Kapselung und die Kapselung ist eine Teilmenge der Abstraktion

Referenz: http://www.tonymarston.co.uk/php-mysql/abstraction.txt