Jaka jest dokładna różnica między enkapsulacją a abstrakcją?

Większość odpowiedzi tutaj koncentruje się na OOP, ale enkapsulacja rozpoczyna się znacznie wcześniej:

• Każda funkcja jest enkapsulacją ; w pseudokodzie:

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

  Tutaj distancepodsumowuje obliczenia (euklidesowej) odległości między dwoma punktami na płaszczyźnie: ukrywa szczegóły implementacji. To jest enkapsulacja, czysta i prosta.

• Abstrakcja jest procesem uogólnienia : podjęcia konkretnej implementacji i dostosowania jej do różnych, choć w pewnym stopniu powiązanych, rodzajów danych. Klasycznym przykładem abstrakcji jestqsortfunkcjaCdo sortowania danych:

  Chodzi o qsortto, że nie dba o sortowane dane - w rzeczywistości nie wie, jakie dane sortuje. Jego typem wejściowym jest raczej wskaźnik bez typu ( void*), który jest po prostu sposobem C na powiedzenie „Nie dbam o typ danych” (jest to również nazywane skasowaniem typu). Ważne jest to, że implementacja qsortzawsze pozostaje taka sama, niezależnie od typu danych. Jedyne, co należy zmienić, to funkcja porównania, która różni się w zależności od typu danych. qsortdlatego oczekuje, że użytkownik zapewni wspomnianą funkcję porównania jako argument funkcji.

Hermetyzacja i abstrakcja idą w parze tak bardzo, że można stwierdzić, że są naprawdę nierozłączni. Dla celów praktycznych jest to prawdopodobnie prawda; powiedziawszy, oto enkapsulacja, która nie jest zbyt abstrakcyjna:

class point {
    numeric x
    numeric y
}

Hermetyzujemy współrzędną punktu, ale nie usuwamy ich materialnie, poza logicznym zgrupowaniem.

A oto przykład abstrakcji, która nie jest enkapsulacją:

T pi<T> = 3.1415926535

Jest to zmienna ogólna pi o podanej wartości (π), a deklaracja nie dba o dokładny typ zmiennej. Przyznaję, że trudno byłoby znaleźć coś takiego w prawdziwym kodzie: abstrakcja praktycznie zawsze używa enkapsulacji. Jednakże, powyższe ma faktycznie istnieje w C ++ (14), za pomocą zmiennych szablonów (= ogólnych wzorów dla zmiennych); z nieco bardziej złożoną składnią, np .:

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

Hermetyzacja ukrywa szczegóły implementacji, które mogą, ale nie muszą, dotyczyć ogólnych lub specjalistycznych zachowań.

Abstrakcja zapewnia uogólnienie (powiedzmy, nad zestawem zachowań).

Oto dobra lektura: Abstrakcja, enkapsulacja i ukrywanie informacji przez Edwarda V. Berarda z Object Agency.

Wiele odpowiedzi i ich przykładów wprowadza w błąd.

Hermetyzacja to pakowanie danych i funkcji działających na tych danych w pojedynczy komponent i ograniczeniu dostępu do niektórych komponentów obiektu.
Hermetyzacja oznacza, że ​​wewnętrzna reprezentacja obiektu jest na ogół ukryta przed widokiem poza definicją obiektu.

Abstrakcja jest mechanizmem, który reprezentuje podstawowe funkcje bez uwzględnienia szczegółów implementacji.

Hermetyzacja: - Ukrywanie informacji .
Abstrakcja: - Ukrywanie implementacji .

Przykład:

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

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

Wewnętrzna reprezentacja dowolnego obiektu fooklasy jest ukryta poza klasą. -> Hermetyzacja.
Dowolny dostępny element członkowski (dane / funkcja) obiektu foojest ograniczony i może być dostępny tylko przez ten obiekt.

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

Implementacja metody addjest ukryta. -> Abstrakcja.

enkapsulacja umieszcza niektóre rzeczy w pudełku i daje wizjer; dzięki temu nie musisz się martwić biegami.

abstrakcja całkowicie ignoruje szczegóły, które nie mają znaczenia, takie jak to, czy rzeczy mają koła zębate, zapadkowe, koła zamachowe lub rdzenie jądrowe; oni po prostu „idą”

przykłady enkapsulacji:

• slipy
• Przybornik
• portfel
• torebka
• kapsuła
• zamrożony karbon
• pudełko z przyciskiem lub bez niego
• burrito (technicznie rzecz biorąc, tortilla wokół burrito)

przykłady abstrakcji:

• „grupy rzeczy” to abstrakcja (którą nazywamy agregacją)
• „rzeczy, które zawierają inne rzeczy” to abstrakcja (którą nazywamy kompozycją)
• „pojemnik” to inny rodzaj abstrakcji „rzeczy, które zawierają inne rzeczy”; należy zauważyć, że wszystkie przykłady kapsułkowania są rodzajami pojemników, ale nie wszystkie pojemniki wykazują / zapewniają kapsułkowanie. Na przykład kosz to pojemnik, który nie zamyka zawartości.

Hermetyzacja oznacza ukrywanie danych, takich jak używanie gettera i settera itp.

Abstrakcja oznacza ukrywanie implementacji za pomocą klasy abstrakcyjnej i interfejsów itp.

Abstrakcja jest uogólnionym terminem. tj. kapsułkowanie jest podzbiorem abstrakcji.

• Przykład 2: architekt rozwiązanie jest osoba, która tworzy wysoki poziom abstrakcyjny projekt techniczny całego rozwiązania, a ten projekt jest następnie przekazany do zespołu projektowego do realizacji
  .

  Tutaj architekt rozwiązań działa jako abstrakcja, a zespół programistów działa jak enkapsulacja.

• Przykład 3: Hermetyzacja (sieć) danych użytkownika

Kurtuazja

Abstrakcja (lub modułowość) - typy pozwalają programistom myśleć na wyższym poziomie niż bit lub bajt, nie zawracając sobie głowy implementacją niskiego poziomu. Na przykład programiści mogą zacząć traktować ciąg znaków jako zbiór wartości znaków zamiast zwykłej tablicy bajtów. Co więcej, typy pozwalają programistom myśleć i wyrażać interfejsy między dwoma dowolnymi podsystemami. Umożliwia to więcej poziomów lokalizacji, dzięki czemu definicje wymagane dla interoperacyjności podsystemów pozostają spójne, gdy te dwa podsystemy się komunikują. Źródło

Powyżej podano wiele dobrych odpowiedzi, ale tutaj przedstawię swój punkt widzenia (Java).

Enkapsulacja danych oznacza po prostu pakowanie i kontrolowanie dostępu do logicznie pogrupowanych danych w klasie. Jest to ogólnie powiązane z innym słowem kluczowym - Ukrywanie danych . Osiąga się to w Javie za pomocą modyfikatorów dostępu .

Prostym przykładem byłoby zdefiniowanie zmiennej prywatnej i udzielenie do niej dostępu za pomocą metod pobierających i ustawiających lub uczynienie metody prywatną, ponieważ jej jedynym zastosowaniem jest klasa. Użytkownik nie musi wiedzieć o tych metodach i zmiennych.

Uwaga : nie należy źle rozumieć, że enkapsulacja polega wyłącznie na ukrywaniu danych. Kiedy mówimy o enkapsulacji, należy położyć nacisk na grupowanie lub pakowanie lub łączenie powiązanych danych i zachowań.

Z drugiej strony, abstrakcja danych to koncepcja uogólnienia, aby złożona logika nie była narażona na działanie użytkownika. W Javie można to osiągnąć za pomocą interfejsów i abstrakcji klas .

Przykład -

Powiedzmy, że mamy interfejs Animal i ma funkcję makeSound () . Istnieją dwie konkretne klasy Dog i Cat, które implementują ten interfejs. Te konkretne klasy mają osobne implementacje funkcji makeSound (). Powiedzmy teraz, że mamy zwierzę (otrzymujemy to z jakiegoś modułu zewnętrznego). Wszystko, co użytkownik wie, to to, że obiekt, który odbiera, to jakieś zwierzę, a użytkownik jest odpowiedzialny za wydrukowanie zwierzęcego dźwięku. Jednym ze sposobów brutalnej siły jest sprawdzenie otrzymanego obiektu w celu zidentyfikowania jego typu, następnie przeniesienie go do tego typu zwierząt i wywołanie na nim metody makeSound (). Ale ładniejszym sposobem jest odniesienie polimorficzne wyodrębnienie rzeczy . Użyj Animal jakoi wywołaj na nim makeSound (). W czasie wykonywania zależności od tego, jaki prawdziwy typ obiektu jest właściwy, zostanie wywołana funkcja.

Więcej informacji tutaj .

Złożona logika znajduje się na płytce drukowanej, która jest zamknięta w tabliczce dotykowej, a przyjemny interfejs (przyciski) jest udostępniany użytkownikowi.

PS: Powyższe linki prowadzą do mojego osobistego bloga.

• Abstrakcja pozwala skupić się na tym, co robi obiekt, a nie na tym, jak to robi
• Hermetyzacja oznacza ukrywanie wewnętrznych szczegółów lub mechaniki tego, jak obiekt coś robi.

Podobnie jak podczas prowadzenia samochodu, wiesz, co robi pedał gazu, ale możesz nie znać procesu za nim, ponieważ jest on zamknięty.

Podam przykład w języku C #. Załóżmy, że masz liczbę całkowitą:

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

możesz użyć metody takiej jak Number.ToString (), która zwraca ci reprezentację znaków liczby 5 i przechowuje ją w obiekcie łańcuchowym. Ta metoda mówi ci, co robi, a nie jak.

Są to niejasne pojęcia, które nie są unikalne dla informatyki i programowania. Chciałbym przedstawić kilka dodatkowych przemyśleń, które mogą pomóc innym zrozumieć te ważne pojęcia.

Krótka odpowiedź

Kapsułkowanie - Ukrywanie i / lub ograniczanie dostępu do niektórych części systemu, jednocześnie ujawniając niezbędne interfejsy.

Abstrakcja - rozważenie czegoś z usuniętymi pewnymi cechami, oprócz konkretnych rzeczywistości, konkretnych obiektów lub rzeczywistych instancji, zmniejszając w ten sposób złożoność.

Głównym podobieństwem jest to, że techniki te mają na celu poprawę zrozumienia i użyteczności.

Główną różnicą jest to, że abstrakcja jest sposobem prostszego przedstawiania rzeczy (często w celu szerszego zastosowania reprezentacji), podczas gdy enkapsulacja jest metodą zmiany sposobu, w jaki inne rzeczy oddziałują z czymś.

Długa odpowiedź

Kapsułkowanie

Oto przykład enkapsulacji, która, mam nadzieję, wyjaśnia wszystko:

Tutaj mamy Arduino Uno i Arduino Uno w obudowie. Obudowa jest doskonałym odzwierciedleniem tego, na czym polega enkapsulacja.

Enkapsulacja ma na celu ochronę niektórych komponentów przed wpływami zewnętrznymi i wiedzą, a także ujawnienie komponentów, z którymi inne rzeczy powinny się łączyć. W kategoriach programowych obejmuje to ukrywanie informacji przez modyfikatory dostępu , które zmieniają zakres, w jakim niektóre zmienne i / lub właściwości mogą być odczytywane i zapisywane.

Ale poza tym enkapsulacja ma również na celu zapewnienie tych zewnętrznych interfejsów o wiele bardziej skutecznie. W naszym przykładzie Arduino może to obejmować ładne przyciski i ekran, co znacznie ułatwia interakcję użytkownika z urządzeniem. Zapewniają użytkownikowi proste sposoby wpływania na zachowanie urządzenia i uzyskiwania użytecznych informacji o jego działaniu, które w innym przypadku byłyby znacznie trudniejsze.

Programowania wymaga to zgrupowanie różnych składników do rozdzielnego konstrukcji, takich jak function, classlub object. Obejmuje również zapewnienie środków interakcji z tymi konstruktami, a także metod uzyskiwania przydatnych informacji na ich temat.

Hermetyzacja pomaga programistom na wiele dodatkowych sposobów, między innymi poprawiając utrzymanie kodu i testowalność.

Abstrakcja

Chociaż wiele innych odpowiedzi tutaj definiuje abstrakcję jako uogólnienie, osobiście uważam, że definicja ta jest błędna. Powiedziałbym, że uogólnienie jest w rzeczywistości specyficznym rodzajem abstrakcji, a nie odwrotnie. Innymi słowy, wszystkie uogólnienia są abstrakcje, ale wszystkie abstrakcje to nie koniecznie uogólnienia.

Oto jak lubię myśleć o abstrakcji:

Czy powiedziałbyś, że obraz przedstawia drzewo? Są szanse, że byś. Ale czy to naprawdę drzewo? Oczywiście, że nie! To wiązka pikseli, które wyglądają jak coś, co możemy nazwać drzewem. Można powiedzieć, że reprezentuje abstrakcję prawdziwego drzewa. Zauważ, że pominięto kilka wizualnych szczegółów drzewa. Ponadto nie rośnie, nie zużywa wody ani nie produkuje tlenu. Jak to możliwe? to tylko kilka kolorów na ekranie, reprezentowanych przez bajty w pamięci komputera.

A oto istota abstrakcji. Jest to sposób na uproszczenie, aby były łatwiejsze do zrozumienia. Każdy pomysł przechodzący przez twoją głowę jest abstrakcją rzeczywistości. Twój mentalny obraz drzewa nie jest bardziej prawdziwym drzewem niż ten plik JPEG.

W programowaniu możemy wykorzystać to na naszą korzyść, tworząc Treeklasę z metodami symulowanego wzrostu, zużycia wody i produkcji tlenu. Nasze stworzenie byłoby czymś, co reprezentuje nasze doświadczenie z rzeczywistymi drzewami i obejmuje tylko te elementy, na których naprawdę zależy nam w naszej konkretnej symulacji. Używamy abstrakcji jako sposobu reprezentowania naszego doświadczenia czegoś z bajtami i matematyką.

Klasy abstrakcyjne

Abstrakcja w programowaniu pozwala nam również rozpatrywać podobieństwa między kilkoma „konkretnymi” typami obiektów (typy, które faktycznie istnieją) i definiować te podobieństwa w obrębie unikalnej jednostki. Na przykład nasza Treeklasa może odziedziczyć po abstract class Plant, który ma kilka właściwości i metod, które mają zastosowanie do wszystkich naszych klas podobnych do roślin, ale usuwa te, które są specyficzne dla każdego rodzaju rośliny. Może to znacznie ograniczyć powielanie kodu i poprawić konserwowalność.

Praktyczna różnica abstract classi zwykły classjest koncepcyjnie nie ma „prawdziwe” wystąpień abstract class. Nie ma sensu konstruować Plantobiektu, ponieważ nie jest on wystarczająco konkretny. Każdy „prawdziwy” Plantjest również bardziej specyficznym rodzajem Plant.

Ponadto, jeśli chcemy, aby nasz program był bardziej realistyczny, możemy rozważyć fakt, że nasza Treeklasa może być zbyt abstrakcyjna. W rzeczywistości, każdy Treejest bardziej specyficzny typ Tree, więc mogliśmy tworzenia klas dla tych typów, takich jak Birch, Mapleitp, które dziedziczą z naszej, być może teraz abstract, Treeklasy.

JVM

Innym dobrym przykładem abstrakcji jest Java Virtual Machine (JVM) , która zapewnia wirtualny lub abstrakcyjny komputer do uruchamiania kodu Java. Zasadniczo usuwa wszystkie elementy systemu specyficzne dla platformy i zapewnia abstrakcyjny interfejs „komputera” bez względu na konkretny system.

Różnica

Hermetyzacja różni się od abstrakcji tym, że nie ma nic wspólnego z tym, jak „prawdziwe” lub „dokładne” jest coś. Nie usuwa składników czegoś, co upraszcza lub ma szersze zastosowanie. Raczej może ukrywać niektóre elementy, aby osiągnąć podobny cel.

Hermetyzacja : ukrywa niechciane / nieoczekiwane / właściwe właściwości implementacji przed rzeczywistymi użytkownikami obiektu. na przykład

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

Abstrakcja : Jest to sposób na uogólnienie, a zatem powszechny sposób pracy z obiektami o dużej różnorodności. na przykład

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

Różnica między abstrakcją a enkapsulacją.

Abstrakcja: Pomysł przedstawienia czegoś w uproszczony / inny sposób, który jest albo łatwiejszy do zrozumienia i użycia, albo bardziej odpowiedni do sytuacji.

Zastanów się nad klasą, która wysyła wiadomość e-mail ... używa abstrakcji, aby pokazać się jako jakiś posłaniec, więc możesz zadzwonić na emailSender.send (poczta, odbiorca). To, co faktycznie robi - wybiera POP3 / SMTP, serwery wywołujące, tłumaczenie MIME itp. Jest abstrakcyjne. Widzisz tylko swojego posłańca.

Hermetyzacja: idea zabezpieczania i ukrywania danych i metod, które są prywatne dla obiektu. Chodzi raczej o to, aby stworzyć coś niezależnego i niezawodnego.

Weź mnie na przykład. Podsumowuję tętno z reszty świata. Ponieważ nie chcę, aby ktokolwiek inny zmieniał tę zmienną i nie potrzebuję, aby ktoś inny ją ustawiał, aby działał. Jest to dla mnie niezwykle ważne, ale nie musisz wiedzieć, co to jest, i prawdopodobnie i tak cię to nie obchodzi.

Rozejrzyj się, a zobaczysz, że prawie wszystko, czego dotykasz, jest przykładem zarówno abstrakcji, jak i enkapsulacji. Na przykład Twój telefon przedstawia abstrakcję polegającą na tym, że możesz zabrać to, co mówisz i powiedzieć to komuś innemu - obejmując GSM, architekturę procesora, częstotliwości radiowe i milion innych rzeczy, których nie rozumiesz lub których nie obchodzi. Zawiera również pewne dane od ciebie, takie jak numery seryjne, numery identyfikacyjne, częstotliwości itp.

Wszystko to sprawia, że ​​świat jest przyjemniejszym miejscem do życia: D

Abstrakcja: Wyświetlane są tylko niezbędne informacje. Skupmy się na przykładzie włączania komputera. Użytkownik nie musi wiedzieć, co się dzieje, gdy system wciąż się ładuje (ta informacja jest ukryta przed użytkownikiem).

Weźmy inny przykład bankomatu. Klient nie musi wiedzieć, w jaki sposób urządzenie odczytuje PIN i przetwarza transakcję, wystarczy wpisać PIN, wziąć gotówkę i wyjść.

Enkapsulacja: zajmuje się ukrywaniem poufnych danych klasy, a tym samym prywatyzacją jej części. Jest to sposób na zachowanie poufności niektórych informacji dla klientów poprzez uniemożliwienie dostępu do nich z zewnątrz.

Inny przykład:

Załóżmy, że stworzyłem niezmienną klasę Rectangle w następujący sposób:

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

Teraz jest oczywiste, że zakapsułkowałem szerokość i wysokość (dostęp jest jakoś ograniczony), ale niczego nie wyodrębniłem (dobra, może zignorowałem położenie prostokąta w przestrzeni współrzędnych, ale jest to wada przykład).

Dobra abstrakcja zwykle oznacza dobre kapsułkowanie.

Przykładem dobrej abstrakcji jest ogólna klasa połączenia z bazą danych. Jego interfejs publiczny jest niezależny od bazy danych i jest bardzo prosty, ale pozwala mi robić to, co chcę z połączeniem. A ty widzisz Istnieje również enkapsulacja, ponieważ klasa musi mieć w środku wszystkie uchwyty i wywołania niskiego poziomu.

Abstractioni Encapsulationza pomocą jednego uogólnionego przykładu

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

Wszyscy używamy kalkulatora do obliczania złożonych problemów!

Mechanizm, który chroni dane poszczególnych obiektów przed celowym lub przypadkowym niewłaściwym użyciem przez funkcje zewnętrzne, nazywa się „ enkapsulacją danych”

Akt reprezentowania istotnych cech bez uwzględnienia szczegółów tła lub wyjaśnień jest znany jako abstrakcja

Abstrakcja: Abstrakcja oznacza pokazanie Whatczęści funkcjonalności.

Encapsulation: Encapsulation oznacza ukrywanie Howczęści funkcjonalności.

Weźmy bardzo prosty przykład

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

Klasa programu aplikacji konsolowej

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

Weźmy przykład stosu. Może być zaimplementowany przy użyciu tablicy lub listy połączonej. Ale obsługiwane przez nią operacje to push i pop.

Teraz abstrakcja ujawnia tylko interfejsy push i pop. Podstawowa reprezentacja jest ukryta (czy jest to tablica czy lista połączona?) I zapewniony jest dobrze zdefiniowany interfejs. Jak teraz zapewnić, że nie będzie przypadkowego dostępu do abstrakcyjnych danych? W tym momencie dochodzi do enkapsulacji . Na przykład klasy w C ++ używają specyfikatorów dostępu, które zapewniają zapobieganie przypadkowemu dostępowi i modyfikacji. Ponadto, czyniąc wyżej wymienione interfejsy publicznymi, zapewnia, że ​​jedynym sposobem manipulowania stosem jest dobrze zdefiniowany interfejs. W tym czasie połączył dane i kod, który może nimi manipulować (nie angażujmy tutaj funkcji znajomych). Oznacza to, że kod i dane są ze sobą połączone, powiązane lub enkapsulowane.

Enkapsulacja owija złożoność w jedną kapsułę, która jest klasą, a zatem Enkapsulacja… Podczas gdy abstrakcja jest cechą obiektu, która odróżnia ją od innych obiektów ...

Abstrakcja może być osiągnięta poprzez uczynienie abstrakcji klasy abstrakcyjną za pomocą jednej lub więcej metod. Jest to cecha, która powinna zostać zaimplementowana przez klasę rozszerzającą ją. np. kiedy wymyślasz / projektujesz samochód, definiujesz takie cechy, jak samochód powinien mieć 4 drzwi, hamulec, kierownicę itp., więc każdy, kto korzysta z tego projektu, powinien uwzględnić te cechy. Wdrożenie nie jest główną abstrakcją. Określi tylko cechy, które należy uwzględnić.

Osłonięcie osiąga się, utrzymując dane i zachowanie w jednej kapsule, która jest klasowa, i wykorzystując modyfikatory dostępu, takie jak public, private, chronione wraz z dziedziczeniem, agregacją lub kompozycją. Więc pokazujesz tylko wymagane rzeczy, to też tylko w takim zakresie, w jakim chcesz to pokazać. tj. publiczny, chroniony, przyjazny i prywatny ka funda …… np. GM decyduje się na zastosowanie abstrakcyjnego projektu samochodu powyżej. Ale mają różne produkty o tych samych właściwościach i prawie takiej samej funkcjonalności. Piszą więc klasę, która rozszerza powyższą klasę abstrakcyjną. Mówi, jak powinna działać skrzynia biegów, jak powinna działać przerwa, jak powinna działać kierownica. Następnie wszystkie produkty korzystają z tej wspólnej funkcjonalności. Nie muszą wiedzieć, jak działa skrzynia biegów, czy działa przerwa, czy sterowanie pracą koła.

Oba są potężne; ale używanie abstrakcji wymaga więcej umiejętności niż enkapsulacja, a większe aplikacje / produkty nie mogą przetrwać bez abstrakcji.

Abstrakcja --- Ukrywanie implementacji - w fazie projektowania --- Korzystanie z interfejsu / Abstrakcyjne calsses

Hermetyzacja - Ukrywanie danych - Rozwój - Korzystanie z modyfikatorów dostępu (publiczny / prywatny)

Z tego

Różnica między enkapsulacją a abstrakcją w OOPS

Abstrakcja i enkapsulacja to dwie ważne koncepcje programowania obiektowego (OOPS). Zarówno enkapsulacja, jak i abstrakcja są wzajemnie powiązanymi terminami.

Rzeczywista różnica między enkapsulacją a abstrakcją

Encapsulate oznacza ukrywanie. Kapsułkowanie jest również nazywane ukrywaniem danych. Możesz myśleć o kapsułkowaniu jak kapsułce (tabletce leku), która ukrywa w sobie lek. Enkapsulacja to zawijanie, tylko ukrywanie właściwości i metod. Enkapsulacja służy do ukrywania kodu i danych w jednym urządzeniu w celu ochrony danych przed światem. Klasa jest najlepszym przykładem enkapsulacji.

Abstrakcja odnosi się do pokazywania tylko niezbędnych szczegółów zamierzonemu użytkownikowi. Jak sama nazwa wskazuje, abstrakcja jest „abstrakcyjną formą czegokolwiek”. Używamy abstrakcji w językach programowania do tworzenia klasy abstrakcyjnej. Klasa abstrakcyjna reprezentuje abstrakcyjny pogląd na metody i właściwości klasy.

Różnica w implementacji między enkapsulacją a abstrakcją

1. Abstrakcja jest implementowana przy użyciu interfejsu i klasy abstrakcyjnej, natomiast enkapsulacja jest implementowana przy użyciu prywatnego i chronionego modyfikatora dostępu.

2. OOPS wykorzystuje enkapsulację, aby wymusić integralność typu (tj. Upewnić się, że dane są wykorzystywane w odpowiedni sposób), uniemożliwiając programistom dostęp do danych w sposób niezamierzony. Poprzez enkapsulację tylko z góry określona grupa funkcji może uzyskać dostęp do danych. Zbiorowy termin dla typów danych i operacji (metod) w pakiecie wraz z ograniczeniami dostępu (publicznymi / prywatnymi itp.) To klasa.

Spróbuję wykazać enkapsulację w prosty sposób .. Zobaczmy ...

• Opakowanie danych i funkcji w jedną jednostkę (zwaną klasą) jest znane jako enkapsulacja. Hermetyzacja zawierająca i ukrywająca informacje o obiekcie, takie jak wewnętrzne struktury danych i kod.

Kapsułkowanie to -

• Ukrywanie złożoności,
• Powiązanie danych i funkcji razem,
• Czynienie skomplikowanej metody prywatnym,
• Czyniąc zmienną instancji prywatną,
• Ukrywanie niepotrzebnych danych i funkcji przed użytkownikiem końcowym.

Enkapsulacja implementuje Abstrakcję.

A abstrakcja to -

• Pokazuje, co jest konieczne,
• Dane muszą być pobierane od użytkownika końcowego,

Zobaczmy przykład

Poniższy obraz pokazuje graficzny interfejs użytkownika „Dane klienta, które należy dodać do bazy danych”.

Patrząc na obraz, możemy powiedzieć, że potrzebujemy klasy klienta.

Krok - 1: Czego potrzebuje moja klasa klienta?

to znaczy

• 2 zmienne do przechowywania kodu klienta i nazwy klienta.

• 1 Funkcja dodawania kodu klienta i nazwy klienta do bazy danych.

  przestrzeń nazw CustomerContent {public class Customer {public string CustomerCode = ""; ciąg publiczny CustomerName = ""; public void ADD () {// mój kod DB przejdzie tutaj}

Teraz tylko metoda ADD nie będzie działać tutaj sama.

Krok -2: Jak będzie działać walidacja, funkcja ADD?

Będziemy potrzebować kodu połączenia z bazą danych i kodu sprawdzania poprawności (dodatkowe metody).

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

Teraz nie ma potrzeby pokazywania dodatkowych metod (Validate (); CreateDBObject () [metoda skomplikowana i dodatkowa]) użytkownikowi końcowemu. Użytkownik końcowy musi tylko zobaczyć i wiedzieć o kodzie klienta, nazwie klienta i przycisku DODAJ, który doda rekord .. Użytkownik końcowy nie dba o to, JAK DODAĆ dane do bazy danych ?.

Krok -3: Prywatne dodatkowe i skomplikowane metody, które nie wymagają interakcji użytkownika końcowego.

Więc uczynienie tych skomplikowanych i dodatkowych metod prywatnymi zamiast publicznych (tzn. Ukrywanie tych metod) i usuwanie obj.Validate (); obj.CreateDBObject (); z głównego programu w klasie osiągamy enkapsulację.

Innymi słowy Uproszczeniem interfejsu dla użytkownika końcowego jest enkapsulacja.

Więc teraz kod wygląda jak poniżej -

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

Podsumowanie :

Krok -1: Czego potrzebuje moja klasa klienta? jest abstrakcja.

Krok -3: Krok -3: Prywatne dodatkowe i skomplikowane metody, które nie wymagają interakcji użytkownika końcowego to enkapsulacja.

PS - Powyższy kod jest trudny i szybki.

Poniższy akapit pomógł mi zrozumieć, czym się różnią:

Hermetyzacja danych to mechanizm łączenia danych, a funkcje, które ich używają, i abstrakcja danych to mechanizm ujawniania tylko interfejsów i ukrywania szczegółów implementacji przed użytkownikiem.

Możesz przeczytać więcej tutaj .

Ukrywanie informacji nie jest bezwzględnie wymagane w celu uzyskania abstrakcji lub enkapsulacji. Informacje mogą być ignorowane, ale nie muszą być ukryte.

Kapsułkowanie to zdolność do traktowania czegoś jako jednej rzeczy, nawet jeśli może składać się z wielu złożonych części lub pomysłów. Mogę na przykład powiedzieć, że siedzę na „krześle”, a nie odnoszę się do wielu różnych części tego krzesła, z których każda ma określony wygląd i funkcję, wszystkie pasują do siebie w celu wygodnego trzymania mojego tyłka na kilka stóp z dala od podłogi.

Abstrakcja jest włączana przez enkapsulację. Ponieważ obudowujemy obiekty, możemy myśleć o nich jako o rzeczach, które w jakiś sposób się ze sobą wiążą, zamiast zagłębiać się w subtelne szczegóły wewnętrznej struktury obiektu. Abstrakcja to umiejętność rozważenia większego obrazu, usuniętego z troski o drobne szczegóły. Rdzeń tego słowa jest abstrakcyjny, jak w streszczeniu, które pojawia się na górze artykułu naukowego, a nie abstrakcyjny, jak w klasie, która może być utworzona tylko jako pochodna podklasa.

Mogę szczerze powiedzieć, że kiedy opadam tyłek na krzesło, nigdy nie myślę o tym, jak struktura tego krzesła złapie i utrzyma moją wagę. To wystarczająco przyzwoite krzesło, że nie muszę się martwić o te szczegóły. Mogę więc zwrócić uwagę na komputer. I znowu nie myślę o częściach składowych mojego komputera. Patrzę tylko na część strony internetowej, która reprezentuje obszar tekstowy, który mogę wpisać, i komunikuję się słowami, ledwo nawet myśląc o tym, jak moje palce tak szybko znajdują odpowiednie litery na klawiaturze i jak ostatecznie nawiązano połączenie między stuknięciem tych kluczy a opublikowaniem na tym forum. To jest wielka siła abstrakcji. Ponieważ na niższych poziomach systemu można polegać na spójności i precyzji, musimy poświęcić więcej uwagi na większą pracę.

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

abstrakcja ukrywa nieprzydatne dane przed użytkownikami, a enkapsulacja wiąże dane w kapsułce (klasie). Myślę, że enkapsulacja jest sposobem na osiągnięcie abstrakcji.

Zarówno proces abstrakcji, jak i enkapsulacji generują interfejsy.

Interfejs wygenerowany przez enkapsulację ukrywa szczegóły implementacji.

Interfejs wygenerowany za pomocą abstrakcji ma zastosowanie do większej liczby typów danych w porównaniu do abstrakcji przed nią.

Abstractionto umowa na wdrożenie, które zamierzamy wykonać. Wdrożenie może ulec zmianie w miarę upływu czasu. Różne implementacje mogą, ale nie muszą być ukryte, ale są maskowane za abstrakcję.

Załóżmy, że zdefiniujemy całą APIsklasę, a interfacenastępnie poprosimy użytkowników naszego kodu, aby polegali na zdefiniowanej APIsklasie interface. Jesteśmy w stanie ulepszyć lub zmodyfikować wdrożenie, tylko musimy postępować zgodnie z ustaloną umową. Użytkownicy nie są powiązani z naszą implementacją.

NARAŻAMY wszystkie KONIECZNE Reguły (metody) w abstrakcji , implementacja reguł pozostawia się podmiotom implementującym, również implementacja nie jest częścią abstrakcji. To tylko podpis i deklaracja tworzą abstrakcję.

Encapsulationto po prostu UKRYWANIE wewnętrznych szczegółów poprzez ograniczenie dostępu do stanów i zachowań. Hermetyzowana klasa może mieć, ale nie musi, dobrze zdefiniowaną Abstraction.

java.util.Listjest abstrakcją dla java.util.ArrayList. Wewnętrzne stany java.util.ArrayListoznaczenia non publicmodyfikatorami dostępu to hermetyzacja.

Edycja Załóżmy klasę Container.nava implements IContainer, IContainermoże zadeklarować metody podoba addElement, removeElements, contains, itd. Tutaj IContainerreprezentuje abstrakcji dla swojej klasie wykonawczego. Abstrakcja deklaruje interfejsy API klasy, modułu lub systemu światu zewnętrznemu. Te interfejsy API stają się contract. Ten system może być jeszcze rozwinięty. Użytkownicy systemu mogą teraz polegać na zadeklarowanych interfejsach API i są pewni, że każdy system wdrażający taką umowę zawsze będzie stosować się do zadeklarowanych interfejsów API i zawsze zapewni implementację tych interfejsów API. Kiedy piszemy jakiś konkretny byt, decyzja o ukryciu naszych stanów wewnętrznych jest hermetyzacją

Myślę, że enkapsulacja jest sposobem na wdrożenie abstrakcji. Spójrz na poniższy link.

Abstrakcja i enkapsulacja

W skrócie

Użycie abstrakcji -> Użycie enkapsulacji i enkapsulacji -> ukrywanie danych

LUB

ukrywanie danych to podzbiór enkapsulacji, a enkapsulacja to podzbiór abstrakcji

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