Unterschied zwischen Abstraktion und Einkapselung?

Die meisten Antworten konzentrieren sich hier 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 kapselt distance die Berechnung des (euklidischen) Abstands zwischen zwei Punkten in einer Ebene: Es werden Implementierungsdetails ausgeblendet. Das ist Kapselung, schlicht und einfach.

• Abstraktion ist der Prozess von Verallgemeinerung: eine konkrete Implementierung nehmen und auf verschiedene anwendbar machen, wenn auch etwas verwandt, Arten von Daten. Das klassische Beispiel für Abstraktion ist die Funktion qsort von C zum Sortieren von Daten:

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

Verkapselung und Abstraktion gehen so sehr Hand in Hand, dass man den Punkt treffen kann, dass sie wirklich unzertrennlich sind. Für praktische Zwecke ist dies wahrscheinlich richtig; Trotzdem ist hier eine Kapselung, die keine Abstraktion darstellt:

class point {
    numeric x
    numeric y
}

Wir kapseln die Punktkoordinate, abstrahieren sie jedoch nicht materiell, sondern gruppieren sie logisch.

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

T pi<T> = 3.1415926535

Dies ist eine generische Variablepi mit einem gegebenen 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: Bei der Abstraktion wird praktisch immer die Kapselung verwendet. Die obigen does existieren jedoch tatsächlich in C++ (14) über variable templates (= generische Templates für Variablen); mit einer etwas komplexeren Syntax, z.B.

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

Encapsulation verbirgt die Implementierungsdetails, die sich auf generisches oder spezialisiertes Verhalten beziehen können oder nicht.

Abstraction bietet eine Verallgemeinerung (zum Beispiel über eine Reihe von Verhaltensweisen). 

Hier ist eine gute Lektüre: Abstraktion, Encapsulation und Informationsverstecken von Edward V. Berard von der Objektagentur.

einkapselung bringt einige Dinge in eine Schachtel und gibt Ihnen ein Guckloch; Dies verhindert, dass Sie sich mit den Gängen mucken.

die Abstraktion ignoriert die Details, 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 Carbonit
• 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)
• "Behälter" 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. Ein Korb ist beispielsweise ein Behälter, der seinen Inhalt nicht einkapselt.

Viele Antworten und ihre Beispiele sind irreführend. 

Encapsulation ist das Packen von Daten und Funktionen, die mit diesen Daten arbeiten in eine einzige Komponente, die den Zugriff auf einige Komponenten des Objekts beschränkt.
Encapsulation bedeutet, dass die interne Darstellung eines Objekts im Allgemeinen außerhalb der Definition des Objekts für die Ansicht ausgeblendet wird.

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

Encapsulation:-- Informationen, die verbergen.
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 Objekts der foo-Klasse wird außerhalb der Klasse ausgeblendet. -> Kapselung.
Jeder zugreifbare Member (Daten/Funktion) eines Objekts von foo ist eingeschränkt und kann nur von diesem Objekt aus aufgerufen werden. 

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

Die Implementierung der Methode add ist ausgeblendet. -> Abstraktion. 

Encapsulation bedeutet das Ausblenden von Daten wie das Verwenden von Getter und Setter usw.

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

Abstraktion ist allgemeiner Begriff. die Einkapselung ist eine Teilmenge der Abstraktion.

Höflichkeit

• Mit der Abstraktion können Sie sich auf das konzentrieren, was das Objekt macht, und nicht darauf, wie es funktioniert
• Einkapselung bedeutet, die inneren Details oder Mechanismen zu verbergen, wie ein Objekt etwas tut.

Wie beim Autofahren wissen Sie, was das Gaspedal tut, aber Sie kennen möglicherweise nicht den Vorgang dahinter, weil es gekapselt ist.

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

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

sie können eine Methode wie Number.ToString () verwenden, die Ihre Zeichendarstellung der Zahl 5 zurückgibt und in einem String-Objekt speichert. Die Methode sagt Ihnen, was es tut, anstatt wie es geht.

Oben gibt es viele gute Antworten, aber ich werde hier meinen (Java-) Standpunkt vorstellen.

Data Encapsulation bedeutet einfach den Zugriff auf logisch gruppierte Daten in einer Klasse umschließen und steuern. Es ist in der Regel mit einem anderen Schlüsselwort verbunden - Data Hiding. Dies wird in Java mit access modifiers erreicht.

Ein einfaches Beispiel wäre, eine private Variable zu definieren und mit Getter- und Setter-Methoden darauf zuzugreifen oder eine Methode als privat zu definieren, da sie nur innerhalb 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 Kapselung sagen, sollte das Hauptaugenmerk darauf liegen, verwandte Daten und Verhalten zusammenzufassen oder zu verpacken oder zu bündeln.

Data Abstraction dagegen ist das Konzept der Verallgemeinerung, so dass die darunterliegende komplexe Logik dem Benutzer nicht ausgesetzt wird. In Java wird dies durch Verwendung der Klassen interface und abstract erreicht.

Beispiel - 

Nehmen wir an, wir haben ein Interface Animal und es hat eine Funktion makeSound (). Es gibt zwei konkrete Klassen Dog und Cat, die diese Schnittstelle implementieren. Diese konkreten Klassen verfügen über separate Implementierungen der Funktion makeSound (). Nehmen wir an, wir haben ein Tier (wir bekommen das von einem externen Modul). Der Benutzer weiß nur, dass es sich bei dem Objekt, das er empfängt, um ein Tier handelt, und es liegt in der Verantwortung des Benutzers, den Tierton zu drucken. Eine brutale Methode besteht darin, das empfangene Objekt auf Identify seines Typs zu überprüfen, dann Typecast auf diesen Animal-Typ und dann call makeSound () darauf zu setzen. Aber ein aufgeräumterer Weg ist abstrahiert das Ding. Verwenden Sie Animal als polymorphe Referenz und rufen Sie dazu makeSound () auf. Um Laufzeit wird die Funktion aufgerufen, je nachdem, welcher Objekttyp richtig ist. 

Weitere Details hier .

Eine komplexe Logik befindet sich in der Leiterplatte, die in ein Touchpad gekapselt ist, und eine Nice-Schnittstelle (Schaltflächen) ist vorhanden, um sie dem Benutzer vorzugreifen. 

PS: Die obigen Links sind zu meinem persönlichen Blog.

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

Kurze Antwort

Encapsulation - 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 hauptsächliche Ähnlichkeit besteht darin, dass diese Technikendarauf abzielen, das Verständnis und den Nutzen zu verbessern.

Der Hauptunterschied besteht darin, dassAbstraktion ein Mittel ist, um Dinge einfacher darzustellen (häufig, um die Repräsentation breiter anwendbar zu machen), wohingegen Kapselung eine Methode von ist die Art und Weise zu ändern, wie andere Dinge mit etwas interagieren.

Lange Antwort

Verkapselung

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

Hier haben wir ein Arduino Uno und ein Arduino Uno in einem Gehäuse. Ein Enclosure 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 handelt es sich hierbei um Informationen, die obwohl Zugriffsmodifikatoren verbergen. , die das Ausmaß ändern, in dem bestimmte Variablen und/oder Eigenschaften gelesen und geschrieben werden können.

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

Bei der Programmierung werden verschiedene Komponenten zu einem trennbaren Konstrukt zusammengefasst, z. B. function, class oder 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 verbesserte Wartbarkeit und Testbarkeit des Codes.

Abstraktion

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

So denke ich gerne über Abstraktion nach:

Würden Sie sagen, das Bild dort ist ein Baum? Wahrscheinlich würdest du. Aber ist eswirklichein 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. Es wächst nicht, verbraucht kein Wasser und produziert keinen Sauerstoff. Wie könnte es Es ist nur ein Bündel von Farben auf einem Bildschirm, dargestellt durch Bytes in Ihrem Computerspeicher.

Und hier ist das Wesen der Abstraktion. Es 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 von einem Baum ist nicht mehr ein tatsächlicher Baum als dieses JPEG.

Bei der Programmierung können wir dies zu unserem Vorteil nutzen, indem wir eine Tree -Klasse mit Methoden für simuliertes Wachstum, Wasserverbrauch und Sauerstoffproduktion erstellen. Unsere Kreation würde etwas sein, 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 Abstraktion, um unsere Erfahrung von etwas mit Bytes und Mathematik darzustellen.

Abstrakte Klassen

Abstraktion in der Programmierung ermöglicht es uns auch, Gemeinsamkeiten zwischen mehreren "konkreten" Objekttypen (Typen, die tatsächlich existieren) zu berücksichtigen und diese Gemeinsamkeiten innerhalb einer eindeutigen Entität zu definieren. Zum Beispiel kann unsere Tree -Klasse von einem abstract class Plant Erben, der verschiedene Eigenschaften und Methoden hat, die für alle unsere anlagenähnlichen Klassen gelten, aberEntferntdiejenigen, die für jeden Pflanzentyp spezifisch sind. Dies kann die Vervielfältigung von Code erheblich reduzieren und die Wartbarkeit verbessern.

Der praktische Unterschied von abstract class Und einfachem class besteht darin, dass es konzeptionell keine "echten" Instanzen des abstract class Gibt. Es wäre nicht sinnvoll, ein Plant -Objekt zu erstellen, da dies nicht spezifisch genug ist. Jedes "echte" Plant ist auch eine spezifischere Art von Plant.

Wenn wir möchten, dass unser Programm realistischer ist, möchten wir möglicherweise die Tatsache berücksichtigen, dass unsere Klasse Tree selbst möglicherweise zu abstrakt ist. In Wirklichkeit ist jeder Tree ein spezifischerer Typ von Tree, so dass wir Klassen für solche Typen wie Birch, Maple usw. erstellen können, die erben von unserer, vielleicht jetzt abstract, Tree Klasse.

JVM

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

Der Unterschied

Die Verkapselung unterscheidet sich von der Abstraktion darin, dass sie nichts damit zu tun hat, wie "echt" oder "genau" etwas ist. Es ist nichtremoveKomponenten von etwas, um es einfacher oder allgemeiner anwendbar zu machen. Vielmehr kann es sein, dasshidebestimmte Komponenten, um einen ähnlichen Zweck zu erreichen.

Verkapselung : Verbirgt unerwünschte/nicht erwartete/Implementierungsdetails vor den tatsächlichen Benutzern des Objekts .

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 daher eine übliche Art, mit Objekten von großer Vielfalt zu arbeiten. 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 zu präsentieren, die entweder einfacher zu verstehen und zu verwenden ist oder sich auf die Situation bezieht.

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

Encapsulation: Die Idee, Daten und Methoden, die für ein Objekt privat sind, zu schützen und auszublenden. Es geht eher darum, etwas unabhängig und narrensicher zu machen.

Nimm mich zum Beispiel. Ich fasse meine Herzfrequenz vom Rest der Welt ein. Weil ich nicht will, dass jemand anderes diese Variable ändert, und ich brauche niemanden, der sie einstellt, damit ich funktionieren kann. Es ist für mich von entscheidender Bedeutung, aber Sie müssen nicht wissen, was es ist, und Sie interessieren sich wahrscheinlich sowieso nicht dafür.

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

All dies macht die Welt zu einem schöneren Ort zum Leben: D

Abstraktion: Nur notwendige Informationen werden angezeigt. Konzentrieren wir uns auf das Beispiel des Einschaltens eines Computers. Der Benutzer muss nicht wissen, was los ist, während das System noch lädt (diese Informationen sind für den Benutzer nicht sichtbar).

Nehmen wir ein anderes Beispiel, das des Geldautomaten. Der Kunde muss nicht wissen, wie der Computer die PIN liest und die Transaktion verarbeitet. Er muss nur die PIN eingeben, das Geld nehmen und gehen.

Encapsulation: befasst sich mit dem Verstecken der sensiblen Daten einer Klasse, wodurch ein Teil davon privatisiert wird. Es ist eine Möglichkeit, einige Informationen für seine Kunden geheim zu halten, indem sie keinen Zugriff von außen zulassen.

AbstractionundEncapsulationanhand eines einzigen verallgemeinerten Beispiels

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

Wir verwenden alle einen Rechner zur Berechnung komplexer Probleme!

Ein anderes Beispiel:

Angenommen, ich habe eine unveränderliche Rechteckklasse 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_;
}

Nun ist es offensichtlich, dass ich gekapselt Breite und Höhe (Zugriff ist irgendwie eingeschränkt) hat, aber ich habe nicht abstrahiert irgendetwas (okay, vielleicht habe ich ignoriert, wo das Rechteck im Koordinatenraum liegt , aber das ist ein Fehler des Beispiels).

Eine gute Abstraktion impliziert normalerweise eine gute Einkapselung.

Ein Beispiel für eine gute Abstraktion ist eine generische Datenbankverbindungsklasse. Die öffentliche Schnittstelle ist datenbankunabhängig und sehr einfach. Trotzdem kann ich mit der Verbindung tun, was ich will. Und siehst du? Dort gibt es auch die Kapselung, da die Klasse alle Low-Level-Handles und Aufrufe enthalten muss.

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

Encapsulation: Encapsulation bedeutet, den How-Teil 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);
    }
}

Ein Mechanismus, der verhindert, dass die Daten eines bestimmten Objekts vorsätzlich oder versehentlich durch externe Funktionen missbraucht werden, heißt "data Encapsulation"

Die Darstellung wesentlicher Merkmale ohne Einbeziehung der Hintergrunddetails oder Erklärungen wird als Abstraktion bezeichnet.

Nehmen wir das Beispiel eines Stapels. Es kann unter Verwendung eines Arrays oder einer verknüpften Liste implementiert werden. Die unterstützten Operationen sind jedoch Push und Pop.

Jetzt Abstraktion macht nur die Schnittstellen Push und Pop verfügbar. Die zugrunde liegende Darstellung ist ausgeblendet (ist es ein Array oder eine verknüpfte Liste?) Und eine gut definierte Schnittstelle wird bereitgestellt. Wie stellen Sie nun sicher, dass kein versehentlicher Zugriff auf die abstrahierten Daten erfolgt? An dieser Stelle kommt encapsulation zum Einsatz. Klassen in C++ verwenden beispielsweise die Zugriffspezifizierer, die sicherstellen, dass versehentlicher Zugriff und Änderung verhindert werden. Durch die Veröffentlichung der oben genannten Schnittstellen wird auch sichergestellt, dass der Stapel nur über die genau definierte Schnittstelle manipuliert werden kann. Es hat dabei die Daten und den Code, der sie manipulieren kann, gekoppelt (lasst uns die Freundesfunktionen hier nicht einbeziehen). Das heißt, der Code und die Daten sind miteinander verbunden oder gebunden oder gekapselt.

Abstraktion - Implementierung ausblenden - beim Design - Verwendung von Schnittstellen-/abstrakten Calsses

Kapselung - Daten verbergen - Entwicklung in der Entwicklung --- Verwenden von Zugriffsmodifizierer (öffentlich/privat) 

Encapsulation ist die Einkapselung von Komplexität in einer Kapsel, die Klasse und somit Encapsulation ist. Die Abstraktion ist das Merkmal eines Objekts, das sich von anderen Objekten unterscheidet.

Die Abstraktion kann erreicht werden, indem die Klassenzusammenfassung mit einer oder mehreren Methoden abstrakt wird. Das ist nichts anderes als die Eigenschaft, die von der Klasse implementiert werden sollte, die sie erweitert. Wenn Sie ein Auto erfinden/entwerfen, definieren Sie, dass ein Fahrzeug Eigenschaften wie 4 Türen, Bremse, Lenkrad usw. haben sollte. Daher sollte jeder Benutzer dieses Design verwenden. Die Umsetzung ist nicht der Kopf der Abstraktion. Es werden nur Merkmale definiert, die einbezogen werden sollten.

Kapselung wird erreicht, um Daten und das Verhalten in einer einzigen Kapsel der Klasse & zu halten, indem Zugriffsmodifizierer wie public, private, Vererbung, Aggregation oder Zusammensetzung verwendet werden. Sie zeigen also nur die erforderlichen Dinge an, auch nur in dem Umfang, den Sie anzeigen möchten. öffentliche, geschützte, freundliche und private ka funda …… GM beschließt, das abstrahierte Design des Autos oben zu verwenden. Sie verfügen jedoch über verschiedene Produkte, die die gleichen Eigenschaften haben und nahezu die gleiche Funktionalität haben. Also schreiben sie eine Klasse, die die obige abstrakte Klasse erweitert. Es zeigt, wie das Getriebe funktionieren soll, wie Pause funktionieren soll, wie das Lenkrad funktionieren soll. Dann verwenden alle Produkte nur diese allgemeine Funktionalität. Sie müssen nicht wissen, wie das Getriebe funktioniert oder wie sie funktionieren oder wie man lenkt. Einzelne Produkte können sicherlich mehr Funktionen wie A/C oder Auto Lock usw. haben.

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.

Ich werde versuchen, die Kapselung auf einfache Art und Weise zu demonstrieren.

• Das Einschließen von Daten und Funktionen in eine einzige Einheit ( Klasse) wird als Kapselung bezeichnet. Kapselung, die __.-Informationen zu einem Objekt enthält und verbirgt, z. B. interne Datenstrukturen und __.-Code.

Einkapselung ist -

• Komplexität verstecken,
• Daten und Funktion miteinander verbinden, 
• Komplizierte Methode privat machen,
• Instanzvariable als privat definieren,
• Unnötige Daten und Funktionen vor dem Endbenutzer ausblenden.

Encapsulation implementiert Abstraktion.

Und Abstraktion ist - 

• Zeigen, was nötig ist,
• Daten müssen vom Endbenutzer abstrahieren,

Lass uns ein Beispiel sehen

Das Bild unten zeigt eine GUI von "Kundendaten, die in eine Datenbank aufgenommen werden sollen".

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

Schritt - 1: Was braucht meine Kundenklasse?

d.h.

• 2 Variablen zum Speichern von Kundencode und Kundenname.

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

  namespace CustomerContent { public Klasse Customer { public Zeichenfolge CustomerCode = ""; public Zeichenfolge CustomerName = ""; public void ADD () { .//my DB-Code wird hier angezeigt }

Jetzt funktioniert nur die ADD-Methode hier nicht 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 die Extra-Methoden (Validate (); CreateDBObject () [Complicated und Extra-Methode]) dem Endbenutzer nicht angezeigt werden. Der Endbenutzer muss lediglich den Kundencode, den Kundennamen und die Schaltfläche ADD sehen und kennen, die ADD hinzufügen der Datensatz .. Der Endbenutzer kümmert sich nicht darum, WIE er die Daten zur Datenbank hinzufügt.

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

Machen Sie diese komplizierten und extra-Methoden als private statt öffentlich (d. H. Diese Methoden ausblenden) und löschen Sie obj.Validate (). obj.CreateDBObject (); Vom Hauptprogramm in der Klasse erreichen wir die Einkapselung.

Mit anderen Worten: Die Vereinfachung der Benutzeroberfläche für den Endbenutzer ist die Kapselung.

So jetzt sieht der Code 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: Verwenden Sie die zusätzlichen und komplizierten Methoden, bei denen die Interaktion des Endbenutzers nicht eingeschlossen ist, die Kapselung.

P.S. - Der obige Code ist hart und schnell. 

Von das

Unterschied zwischen Verkapselung und Abstraktion in OOPS

Abstraktion und Einkapselung sind zwei wichtige Konzepte der objektorientierten Programmierung (OOPS). Einkapselung und Abstraktion sind beide Begriffe. 

Real Life Difference zwischen Einkapselung und Abstraktion

Einkapseln heißt verstecken. Einkapselung wird auch als Verstecken von Daten bezeichnet. Sie können die Einkapselung wie eine Kapsel (Medizintablette) denken, die Medizin in sich verbirgt. Einkapselung ist Umhüllung, nur das Ausblenden von Eigenschaften und Methoden. Die Kapselung wird verwendet, um den Code und die Daten in einer einzigen Einheit auszublenden, um die Daten vor der Welt zu schützen. Klasse ist das beste Beispiel für die Einkapselung. 

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 Einkapselung und Abstraktion

1. Die Abstraktion wird mithilfe der Schnittstelle und der abstrakten Klasse implementiert, während die Encapsulation mithilfe eines privaten und geschützten Zugriffsmodifizierers implementiert wird.

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

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

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

Sie können mehr hier lesen.

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

Encapsulation ist die Fähigkeit, etwas als eine einzige Sache zu behandeln, obwohl es aus vielen komplexen Teilen oder Ideen bestehen kann. Ich kann zum Beispiel sagen, dass ich auf einem "Stuhl" sitze, anstatt auf die vielen verschiedenen Teile dieses Stuhls zu verweisen, die jeweils ein bestimmtes Design und eine bestimmte Funktion haben und genau zusammenpassen, um meinen Hintern bequem zu halten wenige Meter vom Boden entfernt.

Abstraktion wird durch die Kapselung aktiviert. Da wir Objekte kapseln, können wir sie als Dinge betrachten, die in irgendeiner Weise miteinander in Beziehung stehen, anstatt sich in den subtilen Details der inneren Objektstruktur festzusetzen. Abstraktion ist die Fähigkeit, das größere Bild zu betrachten, ohne sich um kleine Details Sorgen zu machen. 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 fallen lasse, nie darüber nachdenke, wie die Struktur dieses Stuhls mein Gewicht einfängt und hält. Es ist ein anständiger Stuhl, den ich mir um diese Details nicht kümmern muss. So kann ich meine Aufmerksamkeit auf meinen Computer richten. Und wieder denke ich nicht an die Bestandteile meines Computers. Ich betrachte nur einen Teil einer Webseite, der einen Textbereich darstellt, den ich eingeben kann, und kommuniziere in Worten. Ich denke kaum darüber nach, wie meine Finger auf der Tastatur immer so schnell die richtigen Buchstaben finden und wie Die Verbindung wird letztendlich hergestellt zwischen dem Antippen dieser Schlüssel und dem Posten in diesem Forum. Dies ist die große Kraft der Abstraktion. Da den unteren Ebenen des Systems vertraut werden kann, dass sie mit Konsistenz und Präzision arbeiten, müssen wir uns um größere Arbeit kümmern.

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

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

Der Prozess der Abstraktion und der Encapsulation erzeugt Schnittstellen.

Eine durch Kapselung erzeugte Schnittstelle verbirgt Implementierungsdetails.

Eine durch Abstraktion erzeugte Schnittstelle kann im Vergleich zu vor der Abstraktion für mehrere Datentypen verwendet werden.

Abstraction ist ein Vertrag für die Implementierung, die wir durchführen werden. Die Implementierung kann sich im Laufe der Zeit ändern. Die verschiedenen Implementierungen selbst können versteckt sein oder nicht, sind jedoch Maskiert hinter der Abstraktion. 

Angenommen, wir definieren alle APIs einer Klasse in einer interface und bitten die Benutzer unseres Codes, von der definierten APIs der interface abhängig zu sein. Es steht uns frei, die Implementierung zu verbessern oder zu modifizieren, nur müssen wir den festgelegten Vertrag einhalten. Die Benutzer sind mit unserer Implementierung nicht gekoppelt.

Wir setzen alle NECESSARY Rules (Methoden) in Abstraktion aus , die Implementierung der Regeln bleibt den Implementiererentitäten überlassen, auch die Implementierung ist nicht Teil der Abstraktion. Es ist nur die Signatur und Deklaration, was die Abstraktion ausmacht.

Encapsulation ist einfach VERSTECKT die internen Details, indem der Zugriff der Zustände und Verhaltensweisen reduziert wird. Eine gekapselte Klasse kann Abstraction definiert haben oder nicht. 

Java.util.List ist eine Abstraktion für Java.util.ArrayList. Die internen Zustände von Java.util.ArrayList, die mit non public-Zugriffsmodifizierern markiert sind, sind die Kapselung. 

Edit Angenommen, eine Klasse Container.nava implements IContainer, IContainer kann Methoden wie addElement, removeElements, contains usw. deklarieren. Hier steht IContainer für die Abstraktion der implementierenden Klasse. Abstraktion deklariert die APIs der Klasse oder eines Moduls oder eines Systems zur Außenwelt. Diese APIs werden zur contract. Dieses System ist möglicherweise noch nicht entwickelt. 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 angegebenen APIs einhalten wird, und sie stellt immer eine Tge-Implementierung für diese APIs bereit. Sobald wir etwas Konkretes schreiben, ist die Einkapselung die Entscheidung, unsere internen Zustände zu verbergen

Ich versuche hier eine Grenze zwischen Abstraktion und Einkapselung zu ziehen. Abstraktion ist meiner Meinung nach eher eine konzeptionelle Sache, bei der Einkapselung eine der Abstraktionsimplementierungen ist. Da kann man Daten ohne Kapselung verbergen, zum Beispiel mit privaten Konstanten oder Variablen; So können wir Einkapselung mit Datenverstecken haben, aber Datenverstecken ist nicht immer Einkapselung . Im folgenden Teil des Codes versuche ich, die einfachste Form dieser Konzepte darzustellen. 

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

In Aktion,

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.

Zusamenfassend

Abstraktion verwenden -> Encapsulation & Encapsulation verwenden -> Daten ausblenden

OR

data hiding ist eine Teilmenge von Encapsulation und Encapsulation ist eine Teilmenge von Abstraction

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

Ich denke, Encapsulation ist eine Möglichkeit, Abstraktion zu implementieren. Schauen Sie sich den folgenden Link an.

Abstraktion und Verkapselung

Abstraktion und Encapsulation sind beide für das Verstecken von Daten bekannt. Es gibt jedoch einen großen Unterschied.

Verkapselung

Encapsulation ist ein Vorgang des Bindens oder Umschließens der Daten und der Codes, die die Daten verarbeiten, in eine einzige Einheit, die als Klasse bezeichnet wird. 

Encapsulation löst das Problem auf der Implementierungsebene.

In der Klasse können Sie Daten ausblenden, indem Sie private oder geschützte Zugriffsmodifizierer verwenden.

Abstraktion

Abstraktion ist das Konzept, irrelevante Details zu verbergen. Mit anderen Worten: Machen Sie komplexe Systeme einfach, indem Sie das unnötige Detail vor dem Benutzer verbergen. 

Abstraktion löst das Problem auf Designebene.

Sie können eine Abstraktion erzielen, indem Sie in Java eine Schnittstelle und eine abstrakte Klasse erstellen. 

In Ruby können Sie durch die Erstellung von Modulen eine Abstraktion erzielen. 

Bsp .: Wir verwenden (Sammeln, Zuordnen, Reduzieren, Sortieren ...) Methoden des Enumerable-Moduls mit Array und Hash in Ruby.

Lassen Sie mich dies mit einem einfachen Codebeispiel versuchen

Abstraktion = Daten ausblenden + Verkapselung

 // Abstraction
    interface IOperation
    {
        int GetSumOfNumbers();
    }
    internal class OperationEven : IOperation
    {
        // data hiding
        private IEnumerable<int> numbers;

        public OperationEven(IEnumerable<int> numbers)
        {
            this.numbers = numbers;
        }
        // Encapsulation
        public int GetSumOfNumbers()
        {
            return this.numbers.Where(i => i % 2 == 0).Sum();
        }
    }

Zusamenfassend:

Abstraktion ist eine Technik, mit der wir erkennen können, welche spezifischen Informationen wesentlich sind und welche Informationen verborgen werden sollen.

Encapsulation ist die Technik zum Einschließen der Informationen, um Details und Implementierungsdetails eines Objekts zu verbergen. 

Abstraktion

Abstraktion ist der Prozess, bei dem die gemeinsamen Eigenschaften und Felder aller vorhandenen und vorgesehenen Implementierungen herausgeholt werden.

Zum Beispiel: Car ist eine Abstraktion für Sedan, Hatchback, SUV, Coupe, Convertible .Car hätte alle Eigenschaften und Felder, die für alle Fahrzeugtypen gelten.

Verkapselung

Bei der Kapselung werden unerwünschte Details vor dem Benutzer ausgeblendet. Dieser Begriff stammt von der Kapsel. Genauso wie Medizin vor dem Benutzer in der Kapsel verborgen ist. Einzelheiten zu verschiedenen Maschinen und Ausrüstungen und Geräten, von Mischern, Fahrrädern, Waschmaschinen, Radio, Fernsehen bis hin zu Flugzeugen. Sie möchten nicht, dass alle Details der Maschine für den Benutzer sichtbar sind. 

In der Programmiersprache: Betrachten wir eine Klasse Car . Im folgenden Beispiel muss der Benutzer nur wissen, dass er den Schlüssel dreht (turnKey () -Methode), er kennt die internen Funktionen nicht. Der Benutzer muss keine der internen Funktionen oder die internen Komponenten kennen.

In diesem Fall sind alle privaten Methoden interne Funktionen und private Felder wie 'Piston p1' sind interne Daten, die der Benutzer nicht zu kennen braucht. 

public class Car{

    private void startMotor(){ //do something }
    private void generateVoltage(){ //do something }
    private void sparkPlugIgnition(){ //do something }
    private void fuelFlowFromTankToInjector(){ //do something }
    private void pushPistonsDown() { 
               p1.doAction();
               p2.doAction();
               //do something    }
    private void moveCrankShaft(){ //do something }

    private Piston p1;
    private Piston p2;

    public void turnKey(){
        startMotor();
        generateVoltage();
        sparkPlugIgnition();
        fuelFlowFromTankToInjector();
        pushPistonsDown();
        moveCrankShat();
        ...
    }
}