Qual è la differenza precisa tra incapsulamento e astrazione?

La maggior parte delle risposte qui si concentra su OOP ma l'incapsulamento inizia molto prima:

• Ogni funzione è un incapsulamento ; nello pseudocodice:

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

  Qui, distanceincapsula il calcolo della distanza (euclidea) tra due punti in un piano: nasconde i dettagli di implementazione. Questo è incapsulamento, puro e semplice.

• L'astrazione è il processo di generalizzazione : prendere un'implementazione concreta e renderla applicabile a diversi tipi di dati, sebbene in qualche modo correlati. L'esempio classico di astrazione è laqsortfunzionedi Cper ordinare i dati:

  Il fatto qsortè che non gli importa dei dati che ordina - in realtà, non sa quali dati ordina. Piuttosto, il suo tipo di input è un puntatore senza tipo ( void*) che è solo il modo di C di dire "Non mi interessa il tipo di dati" (questo è anche chiamato cancellazione del tipo). Il punto importante è che l'implementazione qsortrimane sempre la stessa, indipendentemente dal tipo di dati. L'unica cosa che deve cambiare è la funzione di confronto, che differisce da un tipo di dati all'altro. qsortpertanto si aspetta che l'utente fornisca detta funzione di confronto come argomento di funzione.

L'incapsulamento e l'astrazione vanno di pari passo così tanto da poter far notare che sono veramente inseparabili. Ai fini pratici, questo è probabilmente vero; detto questo, ecco un incapsulamento che non è molto un'astrazione:

class point {
    numeric x
    numeric y
}

Incapsuliamo le coordinate del punto, ma non le astrattiamo materialmente, oltre a raggrupparle logicamente.

Ed ecco un esempio di astrazione che non è l'incapsulamento:

T pi<T> = 3.1415926535

Questa è una variabile generica pi con un dato valore (π) e alla dichiarazione non interessa il tipo esatto della variabile. Devo ammettere che troverei difficile trovare qualcosa del genere nel vero codice: l'astrazione praticamente utilizza sempre l'incapsulamento. Tuttavia, quanto sopra esiste effettivamente in C ++ (14), tramite modelli di variabili (= modelli generici per variabili); con una sintassi leggermente più complessa, ad esempio:

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

L'incapsulamento nasconde i dettagli di implementazione che possono o meno essere per comportamenti generici o specializzati.

L'astrazione sta fornendo una generalizzazione (diciamo, su una serie di comportamenti).

Ecco una buona lettura: astrazione, incapsulamento e occultamento delle informazioni di Edward V. Berard dell'Agenzia degli oggetti.

Molte risposte e i loro esempi sono fuorvianti.

L'incapsulamento è l'imballaggio di dati e funzioni che operano su tali dati in un singolo componente e limitano l'accesso ad alcuni dei componenti dell'oggetto.
Incapsulamento significa che la rappresentazione interna di un oggetto è generalmente nascosta alla vista al di fuori della definizione dell'oggetto.

L'astrazione è un meccanismo che rappresenta le caratteristiche essenziali senza includere dettagli di implementazione.

Incapsulamento: - Nascondere le informazioni .
Astrazione: - Implementazione nascosta .

Esempio:

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

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

La rappresentazione interna di qualsiasi oggetto di fooclasse è nascosta al di fuori della classe. -> Incapsulamento.
Qualsiasi membro accessibile (dati / funzione) di un oggetto di fooè limitato e può accedere solo a quell'oggetto.

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

L'implementazione del metodo addè nascosta. -> Astrazione.

l'incapsulamento mette alcune cose in una scatola e ti dà uno spioncino; questo ti impedisce di confondere con gli ingranaggi.

l'astrazione completa ignora i dettagli che non contano, come se le cose abbiano ingranaggi, cricchetti, volani o nuclei nucleari; semplicemente "vanno"

esempi di incapsulamento:

• mutande
• cassetta degli attrezzi
• portafoglio
• borsetta
• capsula
• carbonite congelata
• una scatola, con o senza un pulsante su di essa
• un burrito (tecnicamente, la tortilla attorno al burrito)

esempi di astrazione:

• "gruppi di cose" è un'astrazione (che chiamiamo aggregazione)
• "cose ​​che contengono altre cose" è un'astrazione (che chiamiamo composizione)
• "container" è un altro tipo di astrazione di "cose ​​che contengono altre cose"; si noti che tutti gli esempi di incapsulamento sono tipi di contenitori, ma non tutti i contenitori presentano / forniscono incapsulamento. Un cestino, ad esempio, è un contenitore che non incapsula il suo contenuto.

Incapsulamento significa nascondere i dati come usare getter, setter ecc.

Astrazione significa nascondere l'implementazione usando classe astratta e interfacce ecc.

L'astrazione è termine generalizzato. cioè l'incapsulamento è un sottoinsieme di Astrazione.

• Esempio 2:
  l' architetto della soluzione è la persona che crea il progetto tecnico astratto di alto livello dell'intera soluzione e questo progetto viene quindi consegnato al team di sviluppo per l' implementazione .

  Qui, l'architetto della soluzione funge da abstract e il team di sviluppo funge da incapsulamento.

• Esempio 3: incapsulamento (rete) dei dati utente

Cortesia

Astrazione (o modularità) - tipi consentono ai programmatori di pensare a un livello superiore rispetto al bit o al byte, senza preoccuparsi dell'implementazione di basso livello. Ad esempio, i programmatori possono iniziare a pensare a una stringa come un insieme di valori di caratteri anziché come un semplice array di byte. Ancora più in alto, i tipi consentono ai programmatori di pensare ed esprimere interfacce tra due sottosistemi di qualsiasi dimensione. Ciò consente più livelli di localizzazione in modo che le definizioni richieste per l'interoperabilità dei sottosistemi rimangano coerenti quando questi due sottosistemi comunicano. fonte

Molte buone risposte sono fornite sopra ma presenterò qui il mio punto di vista (Java).

Incapsulamento dei dati significa semplicemente impacchettare e controllare l'accesso ai dati raggruppati logicamente in una classe. È generalmente associato a un'altra parola chiave - Nascondersi dati . Ciò si ottiene in Java usando modificatori di accesso .

Un semplice esempio potrebbe essere la definizione di una variabile privata e la possibilità di accedervi utilizzando i metodi getter e setter o rendere privato un metodo in quanto il suo solo utilizzo è all'interno della classe. Non è necessario che l'utente conosca questi metodi e variabili.

Nota : non bisogna fraintendere che l'incapsulamento riguarda solo il nascondere i dati. Quando diciamo incapsulamento, l'accento dovrebbe essere posto sul raggruppamento o l'imballaggio o il raggruppamento di dati e comportamenti correlati.

L'astrazione dei dati è invece un concetto di generalizzazione in modo che la logica complessa sottostante non sia esposta all'utente. In Java questo si ottiene utilizzando interfacce e abstract classi .

Esempio -

Diciamo che abbiamo un'interfaccia Animal e ha una funzione makeSound () . Esistono due classi concrete Dog e Cat che implementano questa interfaccia. Queste classi concrete hanno implementazioni separate della funzione makeSound (). Ora supponiamo che abbiamo un animale (lo otteniamo da un modulo esterno). Tutti gli utenti sanno che l'oggetto che sta ricevendo è un animale ed è responsabilità dell'utente stampare il suono dell'animale. Un modo di forza bruta è controllare l'oggetto ricevuto per identificarne il tipo, quindi digitarlo su quel tipo di Animale e quindi chiamare makeSound () su di esso. Ma un modo più ordinato è di estrarre le cose . Usa animali come ariferimento polimorfico e chiama makeSound () su di esso. In fase di esecuzione, a seconda del tipo di oggetto reale, verrà richiamata la funzione corretta.

Maggiori dettagli qui .

La logica complessa si trova nel circuito stampato che è incapsulato in un touchpad e viene fornita una bella interfaccia (pulsanti) per estrarre l'utente.

PS: I link sopra sono al mio blog personale.

• L'astrazione ti consente di concentrarti su ciò che fa l'oggetto anziché su come lo fa
• Incapsulamento significa nascondere i dettagli interni o la meccanica di come un oggetto fa qualcosa.

Come quando guidi un'auto, sai cosa fa il pedale dell'acceleratore ma potresti non conoscere il processo dietro perché è incapsulato.

Lasciami fare un esempio in C #. Supponiamo di avere un numero intero:

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

è possibile utilizzare un metodo come Number.ToString () che restituisce la rappresentazione dei caratteri del numero 5 e lo memorizza in un oggetto stringa. Il metodo ti dice cosa fa invece di come lo fa.

Questi sono concetti un po 'sfocati che non sono unici per l'Informatica e la programmazione. Vorrei offrire alcuni pensieri aggiuntivi che potrebbero aiutare gli altri a comprendere questi concetti importanti.

Risposta breve

incapsulamento : nascondere e / o limitare l'accesso a determinate parti di un sistema, esponendo al contempo le interfacce necessarie.

Astrazione : considerare qualcosa con determinate caratteristiche rimosse, a parte realtà concrete, oggetti specifici o istanze reali, riducendo così la complessità.

La principale somiglianza è che queste tecniche mirano a migliorare la comprensione e l'utilità.

La differenza principale è che l' astrazione è un mezzo per rappresentare le cose più semplicemente (spesso per rendere la rappresentazione più ampiamente applicabile), mentre l'incapsulamento è un metodo per cambiare il modo in cui le altre cose interagiscono con qualcosa.

Risposta lunga

incapsulamento

Ecco un esempio di incapsulamento che, si spera, rende le cose più chiare:

Qui abbiamo un Arduino Uno e un Arduino Uno all'interno di un recinto. Un recinto è un'ottima rappresentazione di ciò che è l'incapsulamento.

L'incapsulamento mira a proteggere determinati componenti da influenze e conoscenze esterne, nonché a esporre componenti con cui altre cose dovrebbero interfacciarsi. In termini di programmazione, ciò implica nascondere le informazioni attraverso i modificatori di accesso , che cambiano la misura in cui determinate variabili e / o proprietà possono essere lette e scritte.

Ma oltre a ciò, l'incapsulamento mira anche a fornire quelle interfacce esterne in modo molto più efficace. Con il nostro esempio di Arduino, questo potrebbe includere i bei pulsanti e lo schermo che rendono l'interazione dell'utente con il dispositivo molto più semplice. Forniscono all'utente modi semplici per influenzare il comportamento del dispositivo e ottenere informazioni utili sul suo funzionamento che altrimenti sarebbero molto più difficili.

Nella programmazione, ciò comporta il raggruppamento di vari componenti in un costrutto separabile, come un function,class o object. Include anche fornire i mezzi per interagire con tali costrutti, nonché metodi per ottenere informazioni utili su di essi.

L'incapsulamento aiuta i programmatori in molti altri modi aggiuntivi, non ultimo il miglioramento della manutenibilità e della testabilità del codice.

Astrazione

Sebbene molte altre risposte qui definiscano l'astrazione come generalizzazione, personalmente ritengo che la definizione sia sbagliata. Direi che la generalizzazione è in realtà un tipo specifico di astrazione, non viceversa. In altre parole, tutte le generalizzazioni sono astrazioni, ma tutte le astrazioni sono non necessariamente generalizzazioni.

Ecco come mi piace pensare all'astrazione:

Diresti che c'è un albero? Probabilmente lo faresti. Ma è davvero un albero? Beh, certo che no! È un mucchio di pixel fatti per assomigliare a qualcosa che potremmo chiamare un albero. Potremmo dire che rappresenta un'astrazione di un vero albero. Si noti che diversi dettagli visivi dell'albero sono stati omessi. Inoltre, non cresce, consuma acqua o produce ossigeno. Come potrebbe? è solo un mucchio di colori su uno schermo, rappresentato da byte nella memoria del tuo computer.

Ed ecco l'essenza dell'astrazione. È un modo di semplificare le cose in modo che siano più facili da capire. Ogni idea che ti passa per la testa è un'astrazione della realtà. La tua immagine mentale di un albero non è più un vero albero di quanto non sia questo jpeg.

Nella programmazione, potremmo utilizzarlo a nostro vantaggio creando una Treeclasse con metodi per la simulazione di crescita, consumo di acqua e produzione di ossigeno. La nostra creazione sarebbe qualcosa che rappresenta la nostra esperienza di alberi reali, e include solo quegli elementi a cui teniamo veramente per la nostra simulazione particolare. Usiamo l'astrazione come un modo di rappresentare la nostra esperienza di qualcosa con byte e matematica.

Classi astratte

L'astrazione nella programmazione ci consente anche di considerare i punti in comune tra diversi tipi di oggetti "concreti" (tipi effettivamente esistenti) e di definire tali punti in comune all'interno di un'entità unica. Ad esempio, la nostra Treeclasse può ereditare da an abstract class Plant, che ha diverse proprietà e metodi applicabili a tutte le nostre classi simili a piante, ma rimuove quelle che sono specifiche per ogni tipo di pianta. Ciò può ridurre significativamente la duplicazione del codice e migliorare la manutenibilità.

La differenza pratica tra an abstract classe plain classè che concettualmente non esistono istanze "reali" di abstract class. Non avrebbe senso costruire un Plantoggetto perché non è abbastanza specifico. Ogni "reale" Plantè anche un tipo più specifico di Plant.

Inoltre, se vogliamo che il nostro programma sia più realistico, potremmo voler considerare il fatto che la nostra Treeclasse potrebbe essere troppo astratta in se stessa. In realtà, ogni Treeè un tipo più specifico di Tree, così abbiamo potuto creare classi per quei tipi come Birch, Mapleecc che ereditano dalla nostra, forse ora abstract, Treedi classe.

JVM

Un altro buon esempio di astrazione è la Java Virtual Machine (JVM) , che fornisce un computer virtuale o astratto per l'esecuzione del codice Java. In sostanza toglie tutti i componenti specifici della piattaforma di un sistema e fornisce un'interfaccia astratta di "computer" senza riguardo ad alcun sistema in particolare.

La differenza

L'incapsulamento differisce dall'astrazione in quanto non ha nulla a che fare con quanto "reale" o "accurato" sia qualcosa. Non rimuove i componenti di qualcosa per renderlo più semplice o ampiamente applicabile. Piuttosto potrebbe nascondere alcuni componenti per raggiungere uno scopo simile.

Incapsulamento : nasconde i dettagli dell'implementazione indesiderata / non attesa / proprietà agli utenti effettivi dell'oggetto. per esempio

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

Astrazione : è un modo di fornire generalizzazione e quindi un modo comune di lavorare con oggetti di grande diversità. per esempio

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

Differenza tra astrazione e incapsulamento.

Astrazione: l'idea di presentare qualcosa in un modo semplificato / diverso, che è più facile da capire e usare o più pertinente alla situazione.

Considera una classe che invia un'email ... usa l'astrazione per mostrarti come una sorta di messenger boy, così puoi chiamare emailSender.send (mail, destinatario). Ciò che effettivamente fa: sceglie POP3 / SMTP, i server di chiamata, la traduzione MIME, ecc. Viene sottratto. Vedi solo il tuo ragazzo messaggero.

Incapsulamento: l'idea di proteggere e nascondere dati e metodi privati ​​di un oggetto. Si occupa più di rendere qualcosa di indipendente e infallibile.

Prendimi, per esempio. Incapsulo la frequenza cardiaca dal resto del mondo. Perché non voglio che nessun altro cambi quella variabile, e non ho bisogno che nessun altro la imposti affinché funzioni. È di vitale importanza per me, ma non è necessario sapere di cosa si tratta e probabilmente non ti interessa comunque.

Guardati intorno e scoprirai che quasi tutto ciò che tocchi è un esempio di astrazione e incapsulamento. Il tuo telefono, ad esempio, ti presenta l'astrazione di essere in grado di prendere quello che dici e dirlo a qualcun altro - coprendo GSM, architettura del processore, frequenze radio e un milione di altre cose che non capisci o ti interessano. Incapsula anche alcuni dati da te, come numeri di serie, numeri ID, frequenze, ecc.

Tutto rende il mondo un posto migliore in cui vivere: D

Astrazione: vengono visualizzate solo le informazioni necessarie. Concentriamoci sull'esempio dell'accensione di un computer. L'utente non deve sapere cosa succede mentre il sistema sta ancora caricando (le informazioni sono nascoste all'utente).

Facciamo un altro esempio, quello del bancomat. Il cliente non ha bisogno di sapere come la macchina legge il PIN ed elabora la transazione, tutto ciò che deve fare è inserire il PIN, prelevare i contanti e partire.

Incapsulamento: si occupa di nascondere i dati sensibili di un clas privatizzandone quindi una parte. È un modo per mantenere alcune informazioni private ai propri clienti, non consentendo l'accesso ad esse dall'esterno.

Un altro esempio:

Supponiamo di aver creato una classe Rutilizzabile immutabile come questa:

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

Ora è ovvio che ho incapsulato larghezza e altezza (l'accesso è in qualche modo limitato), ma non ho sottratto nulla (ok, forse ho ignorato dove si trova il rettangolo nello spazio delle coordinate, ma questo è un difetto del esempio).

Una buona astrazione di solito implica un buon incapsulamento.

Un esempio di buona astrazione è una classe di connessione al database generica. La sua interfaccia pubblica è indipendente dal database ed è molto semplice, ma mi consente di fare ciò che voglio con la connessione. E vedi? C'è anche l'incapsulamento lì, perché la classe deve contenere tutti gli handle e le chiamate di basso livello.

Abstractione Encapsulationusando un singolo esempio generalizzato

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

Usiamo tutti la calcolatrice per il calcolo di problemi complessi!

Un meccanismo che impedisce ai dati di un determinato oggetto di essere protetto da un uso improprio intenzionale o accidentale da parte di funzioni esterne è chiamato " incapsulamento dei dati"

L'atto di rappresentare le caratteristiche essenziali senza includere i dettagli o le spiegazioni di sfondo è noto come astrazione

Astrazione: astrazione significa mostrare Whatparte della funzionalità.

Incapsulamento: incapsulamento significa nascondere la Howparte della funzionalità.

Facciamo un esempio molto semplice

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

Classe di programma dell'applicazione console

class Program
{
    static void Main(string[] args)
    {
        Employee obj = new Employee();
        obj.EmplpyeeName = "001";
        obj.EmployeeCode = "Raj";

        // We have exposed only what part of the functionality
        obj.AddEmployee(obj);
    }
}

Facciamo l'esempio di uno stack. Potrebbe essere implementato utilizzando un array o un elenco collegato. Ma le operazioni che supporta sono push and pop.

Ora l' astrazione sta esponendo solo le interfacce push and pop. La rappresentazione sottostante è nascosta (è un array o un elenco collegato?) E viene fornita un'interfaccia ben definita. Ora, come si fa a garantire che non venga effettuato alcun accesso accidentale ai dati estratti? È qui che entra in gioco l' incapsulamento . Ad esempio, le classi in C ++ usano gli identificatori di accesso che assicurano che l'accesso accidentale e le modifiche siano prevenute. Inoltre, rendendo pubbliche le interfacce sopra menzionate, garantisce che l'unico modo per manipolare lo stack sia attraverso l'interfaccia ben definita. Nel processo, ha accoppiato i dati e il codice che possono manipolarli (non coinvolgiamo le funzioni degli amici qui). Cioè, il codice e i dati sono uniti o legati o incapsulati.

L'incapsulamento sta avvolgendo la complessità in una capsula che è classe e quindi Incapsulamento ... Mentre l'astrazione è le caratteristiche di un oggetto che si differenzia da un altro oggetto ...

L'astrazione può essere ottenuta rendendo astratto di classe avente uno o più metodi astratti. Che non è altro che la caratteristica che dovrebbe essere implementata dalla classe che la estende. ad es. quando inventi / progetti un'auto definisci caratteristiche come l'auto dovrebbe avere 4 porte, freno, volante ecc ... quindi chiunque usi questo disegno dovrebbe includere queste caratteristiche. L'implementazione non è la testa dell'astrazione. Definirà solo le caratteristiche che dovrebbero essere incluse.

L'incapsulamento si ottiene mantenendo i dati e il comportamento in una capsula che è di classe e facendo uso di modificatori di accesso come pubblici, privati, protetti insieme a eredità, aggregazione o composizione. Quindi mostri solo le cose richieste, anche solo nella misura in cui vuoi mostrare. vale a dire pubblica, protetta, amichevole e privata ka funda …… ad es. GM decide di utilizzare il disegno astratto dell'automobile sopra. Ma hanno vari prodotti con le stesse caratteristiche e quasi la stessa funzionalità. Quindi scrivono una classe che estende la classe astratta sopra. Dice come dovrebbe funzionare la scatola del cambio, come dovrebbe funzionare la rottura, come dovrebbe funzionare il volante. Quindi tutti i prodotti usano solo questa funzionalità comune. Non hanno bisogno di sapere come funziona la scatola del cambio o la rottura o lo sterzo.

Entrambi sono potenti; ma usare l'astrazione richiede più abilità dell'incapsulamento e applicazioni / prodotti più grandi non possono sopravvivere senza astrazione.

Astrazione --- Implementazione nascosta - in fase di progettazione --- Uso dell'interfaccia / Estratti calsses

Incapsulamento - Nascondere i dati - Allo sviluppo --- Uso dei modificatori di accesso (pubblico / privato)

Da questo

Differenza tra incapsulamento e astrazione in OOPS

Astrazione ed incapsulamento sono due importanti concetti di programmazione orientata agli oggetti (OOPS). Incapsulamento e astrazione sono entrambi termini correlati.

Differenza di vita reale tra incapsulamento e astrazione

Incapsulare significa nascondere. L'incapsulamento è anche chiamato nascondimento dei dati. Puoi pensare all'incapsulamento come una capsula (compressa medicinale) che nasconde la medicina al suo interno. L'incapsulamento sta avvolgendo, nascondendo solo proprietà e metodi. L'incapsulamento viene utilizzato per nascondere il codice e i dati in una singola unità per proteggere i dati dall'esterno. La classe è il miglior esempio di incapsulamento.

Per astrazione si intende mostrare solo i dettagli necessari all'utente previsto. Come suggerisce il nome, l'astrazione è la "forma astratta di qualsiasi cosa". Usiamo l'astrazione nei linguaggi di programmazione per fare lezione astratta. La classe astratta rappresenta la vista astratta dei metodi e delle proprietà della classe.

Differenza di implementazione tra incapsulamento e astrazione

1. L'astrazione viene implementata utilizzando l'interfaccia e la classe astratta mentre l'incapsulamento viene implementata utilizzando il modificatore di accesso privato e protetto.

2. OOPS utilizza l'incapsulamento per imporre l'integrità di un tipo (ovvero per garantire che i dati vengano utilizzati in modo appropriato) impedendo ai programmatori di accedere ai dati in modo non previsto. Attraverso l'incapsulamento, solo un gruppo predeterminato di funzioni può accedere ai dati. Il termine collettivo per tipi di dati e operazioni (metodi) in bundle con restrizioni di accesso (pubblico / privato, ecc.) È una classe.

Proverò a dimostrare l'incapsulamento in modo semplice .. Vediamo ..

• Il wrapping di dati e funzioni in una singola unità (chiamata classe) è noto come incapsulamento. Incapsulamento contenente e nascondendo informazioni su un oggetto, come strutture dati interne e codice.

L'incapsulamento è -

• Complessità nascosta,
• Dati e funzione vincolanti insieme,
• Rendere privato il metodo complicato,
• Rendere privato la variabile di istanza,
• Nascondere dati e funzioni non necessari all'utente finale.

L'incapsulamento implementa l'astrazione.

E l'astrazione è -

• Mostrando ciò che è necessario,
• I dati devono essere estratti dall'utente finale,

Vediamo un esempio-

L'immagine seguente mostra una GUI di "Dettagli cliente da aggiungere a un database".

Guardando l'immagine possiamo dire che abbiamo bisogno di una classe di clienti.

Step - 1: Di cosa ha bisogno la mia classe di clienti?

vale a dire

• 2 variabili per memorizzare il codice cliente e il nome cliente.

• 1 Funzione per aggiungere il codice cliente e il nome cliente nel database.

  namespace CustomerContent {public class Customer {public string CustomerCode = ""; stringa pubblica CustomerName = ""; public void ADD () {// il mio codice DB andrà qui}

Ora solo il metodo ADD non funzionerà qui da solo.

Step -2: Come funzionerà la validazione, ADD Function?

Avremo bisogno del codice di connessione al database e del codice di convalida (metodi extra).

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

Ora non è necessario mostrare i metodi aggiuntivi (Convalida (); CreateDBObject () [Metodo complicato ed extra]) per l'utente finale. L'utente deve solo vedere e conoscere il codice cliente, il nome cliente e il pulsante AGGIUNGI che aggiungerà il record .. L'utente finale non si preoccupa di come aggiungerà i dati al database ?.

Step -3: Private i metodi extra e complicati che non comportano l'interazione dell'utente finale.

Quindi rendendo tali metodi Complicati ed Extra come Privati ​​anziché Pubblici (ovvero nascondendo quei metodi) ed eliminando obj.Validate (); obj.CreateDBObject (); dal programma principale in classe otteniamo l'incapsulamento.

In altre parole, semplificare l'interfaccia per l'utente finale è l'incapsulamento.

Quindi ora il codice è simile al seguente:

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

Sommario :

Step -1: di cosa ha bisogno la mia classe di clienti? è l'astrazione.

Passaggio -3: Passaggio -3: Privare i metodi extra e complicati che non comportano l'interazione dell'utente finale è l'incapsulamento.

PS: il codice sopra è duro e veloce.

Il paragrafo seguente mi ha aiutato a capire come differiscono l'uno dall'altro:

L'incapsulamento dei dati è un meccanismo di raggruppamento dei dati e le funzioni che li utilizzano e l'astrazione dei dati è un meccanismo che espone solo le interfacce e nasconde all'utente i dettagli dell'implementazione.

Puoi leggere di più qui .

Non è strettamente necessario nascondere le informazioni per l'astrazione o l'incapsulamento. Le informazioni potrebbero essere ignorate, ma non devono essere nascoste.

L'incapsulamento è la capacità di trattare qualcosa come una cosa sola, anche se può essere composto da molte parti o idee complesse. Ad esempio, posso dire che sono seduto su una "sedia" piuttosto che riferirmi alle molte varie parti di quella sedia ognuna con un design e una funzione specifici, tutte perfettamente adattate allo scopo di tenere comodamente il mio sedere di qualche piede lontano dal pavimento.

L'astrazione è abilitata dall'incapsulamento. Poiché incapsuliamo gli oggetti, possiamo pensarli come cose che si relazionano tra loro in qualche modo piuttosto che impantanarsi nei sottili dettagli della struttura interna degli oggetti. L'astrazione è la capacità di considerare il quadro più ampio, rimosso dalla preoccupazione per i piccoli dettagli.La radice della parola è astratta come nel sommario che appare nella parte superiore di un documento accademico, non astratta come in una classe che può essere istanziata solo come sottoclasse derivata.

Posso onestamente dire che quando faccio cadere il sedere sulla sedia, non penso mai a come la struttura di quella sedia prenderà e manterrà il mio peso. È una sedia abbastanza decente che non devo preoccuparmi di quei dettagli. Quindi posso rivolgere la mia attenzione al mio computer. E ancora, non penso alle parti componenti del mio computer. Sto solo guardando una parte di una pagina Web che rappresenta un'area di testo che posso digitare e sto comunicando a parole, a malapena pensando persino a come le mie dita trovano sempre le lettere giuste così rapidamente sulla tastiera e come alla fine viene stabilita la connessione tra il tocco di questi tasti e la pubblicazione su questo forum. Questo è il grande potere dell'astrazione. Poiché i livelli inferiori del sistema possono essere considerati affidabili per lavorare con coerenza e precisione, abbiamo attenzione a risparmiare per un lavoro maggiore.

class Aeroplane : IFlyable, IFuelable, IMachine
{ // Aeroplane's Design says:
  // Aeroplane is a flying object
  // Aeroplane can be fueled
  // Aeroplane is a Machine
}
// But the code related to Pilot, or Driver of Aeroplane is not bothered 
// about Machine or Fuel. Hence,
// pilot code:
IFlyable flyingObj = new Aeroplane();
flyingObj.Fly();
// fighter Pilot related code
IFlyable flyingObj2 = new FighterAeroplane();
flyingObj2.Fly();
// UFO related code 
IFlyable ufoObj = new UFO();
ufoObj.Fly();
// **All the 3 Above codes are genaralized using IFlyable,
// Interface Abstraction**
// Fly related code knows how to fly, irrespective of the type of 
// flying object they are.

// Similarly, Fuel related code:
// Fueling an Aeroplane
IFuelable fuelableObj = new Aeroplane();
fuelableObj.FillFuel();
// Fueling a Car
IFuelable fuelableObj2 = new Car(); // class Car : IFuelable { }
fuelableObj2.FillFuel();

// ** Fueling code does not need know what kind of vehicle it is, so far 
// as it can Fill Fuel**

l'astrazione nasconde i dati non utili dagli utenti e l'incapsulamento unisce i dati in una capsula (una classe). Penso che l'incapsulamento sia un modo per raggiungere l'astrazione.

Il processo di astrazione e incapsulamento generano entrambe interfacce.

Un'interfaccia generata tramite incapsulamento nasconde i dettagli di implementazione.

Un'interfaccia generata tramite l'astrazione diventa applicabile a più tipi di dati, rispetto a prima dell'astrazione.

Abstractionè un contratto per l'implementazione che stiamo per fare. L'implementazione potrebbe subire modifiche nel corso del tempo. Le varie implementazioni stesse possono essere nascoste o meno ma sono mascherate dietro l'Astrazione.

Supponiamo di definire tutta APIsuna classe in un interfacequindi chiedere agli utenti del nostro codice di dipendere dal definito APIsdi interface. Siamo liberi di migliorare o modificare l'implementazione solo dobbiamo seguire il contratto stabilito. Gli utenti non sono associati alla nostra implementazione.

ESPIAMO tutte le Regole (metodi) NECESSARIE in astrazione , l'implementazione delle regole è lasciata alle entità implementatrici, anche l'implementazione non fa parte dell'astrazione. È solo la firma e la dichiarazione ciò che rende l'astrazione.

Encapsulationè semplicemente NASCONDERE i dettagli interni riducendo l'accesso degli stati e dei comportamenti. Una classe incapsulata può o non può essere stata ben definita Abstraction.

java.util.Listè un'astrazione per java.util.ArrayList. Gli stati interni di java.util.ArrayListessere contrassegnati con non publicmodificatori di accesso è l'incapsulamento.

Modifica Supponiamo che una classe Container.nava implements IContainer, IContainerpuò dichiarare metodi come addElement, removeElements, contains, ecc Ecco IContainerrappresenta l'astrazione per la sua classe di attuazione. L'astrazione sta dichiarando le API della classe o un modulo o un sistema al mondo esterno. Queste API diventano il contract. Tale sistema potrebbe essere o non essere ancora sviluppato. Gli utenti del sistema ora possono dipendere dalle API dichiarate e sono sicuri che qualsiasi sistema che implementa tale contratto aderirà sempre alle API dichiarate, forniranno sempre un'implementazione tge per tali API. Una volta che scriviamo un'entità concreta, decidere di nascondere i nostri stati interni è l'incapsulamento

Penso che l'incapsulamento sia un modo per attuare l'astrazione. Dai un'occhiata al seguente link.

Astrazione ed incapsulamento

In breve

Uso dell'astrazione -> Uso dell'incapsulamento e dell'incapsulamento -> nascondere i dati

O

nascondere i dati è un sottoinsieme di incapsulamento e l' incapsulamento è un sottoinsieme di astrazione

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