Incapsulamento vs astrazione?

Ecco le brevi definizioni di incapsulamento e astrazione.

Astrazione:

Il processo di astrazione in Java viene utilizzato per hide alcuni dettagli e mostrare solo le caratteristiche essenziali dell’object. In altre parole, si occupa della vista esterna di un object (interfaccia). L’unico buon esempio che vedo per questo attraverso diversi siti è l’interfaccia.

incapsulamento:

Si tratta fondamentalmente di hide lo stato dell’object con l’aiuto di modificatori come privati, pubblici, protetti ecc. Esponiamo lo stato attraverso metodi pubblici solo se richiesto.

Ciò che otteniamo con i modificatori come il private , il public nasconde anche dettagli superflui dal mondo esterno che non è altro che un concetto di astrazione

Quindi, dalla spiegazione sopra sembra che l’incapsulamento è una parte dell’astrazione o possiamo dire che è un sottoinsieme di astrazione. Ma perché allora il termine di incapsulamento è inventato quando possiamo gestirlo solo con l’astrazione? Sono sicuro che ci dovrebbe essere una grande differenza che li distingue ma la maggior parte del materiale in rete dice quasi la stessa cosa per entrambi.

Anche se questa domanda è stata sollevata in precedenza su questo forum, ma la sto postando di nuovo con dubbi specifici. Alcune risposte dicono anche che l’astrazione è un concetto e l’incapsulamento è l’implementazione. Ma non lo compro – Se è vero, allora posso pensare che questi due diversi concetti siano forniti per confonderci.

Aggiornamento: – Dopo 5 anni ho trovato la mia risposta che è l’essenza basata sulle risposte in questo post e sotto

  1. differenza tra astrazione e incapsulamento?
  2. esempio di incapsulamento vs astrazione del mondo reale

L’incapsulamento è una strategia usata come parte dell’astrazione. L’incapsulamento si riferisce allo stato degli oggetti: gli oggetti incapsulano il loro stato e lo nascondono dall’esterno; gli utenti esterni della class interagiscono con esso attraverso i suoi metodi, ma non possono accedere direttamente allo stato delle classi. Quindi la class astrae i dettagli di implementazione relativi al suo stato.

L’astrazione è un termine più generico, può anche essere ottenuto mediante (tra le altre) sottoclassi. Ad esempio, l’ List interfacce nella libreria standard è un’astrazione per una sequenza di elementi, indicizzati dalla loro posizione, esempi concreti di un List sono una ArrayList o una List LinkedList . Il codice che interagisce con un List riassume il dettaglio del tipo di elenco che sta utilizzando.

Spesso l’astrazione non è ansible senza hide lo stato sottostante tramite l’incapsulamento: se una class espone il suo stato interno, non può cambiare il suo funzionamento interno, e quindi non può essere astratto.

L’astrazione è il concetto di descrivere qualcosa in termini più semplici, vale a dire l’astrazione dei dettagli, al fine di concentrarsi su ciò che è importante (questo si vede anche nell’arte astratta, per esempio, dove l’artista si concentra sugli elementi costitutivi di immagini, come colore o forms). La stessa idea si traduce in OOP utilizzando una gerarchia di ereditarietà, in cui i concetti più astratti sono in cima e le idee più concrete, in fondo, si basano sulle loro astrazioni. Al suo livello più astratto non ci sono dettagli di implementazione e forse pochissimi punti in comune, che vengono aggiunti man mano che l’astrazione diminuisce.

Ad esempio, in alto potrebbe essere un’interfaccia con un singolo metodo, quindi il livello successivo, fornisce diverse classi astratte, che possono o meno compilare alcuni dei dettagli sul livello principale, ma rami aggiungendo i propri metodi astratti , quindi per ciascuna di queste classi astratte ci sono classi concrete che forniscono le implementazioni di tutti i restanti metodi.

L’incapsulamento è una tecnica . Può o non può essere di aiuto all’astrazione, ma è certamente una questione di nascondimento e / o organizzazione delle informazioni. Richiede che i dati e le funzioni siano raggruppati in qualche modo – ovviamente una buona pratica OOP richiede che siano raggruppati per astrazione. Tuttavia, vi sono altri usi che facilitano la manutenzione, ecc.

l’incapsulamento è una parte dell’astrazione o possiamo dire che è un sottoinsieme di astrazione

Sono concetti diversi.

  • L’astrazione è il processo di perfezionamento di tutti gli attributi non necessari / non importanti di un object e mantiene solo le caratteristiche più adatte al tuo dominio.

    Ad esempio per una persona: decidi di mantenere il nome e cognome e SSN. L’età, l’altezza, il peso ecc. Vengono ignorati come irrilevanti.

    L’astrazione è dove inizia il tuo progetto.

  • L’incapsulamento è il passo successivo in cui riconosce le operazioni adatte agli attributi che hai accettato di mantenere durante il processo di astrazione. È l’associazione dei dati con l’operazione che agisce su di loro.
    I dati e i metodi sono raggruppati insieme.

L’incapsulamento sta nascondendo i dati non necessari in una capsula o unità

L’astrazione sta mostrando la caratteristica essenziale di un object

L’incapsulamento è usato per hide il suo membro dalla class e dall’interfaccia esterna. Usando i modificatori di accesso forniti in c # .come esempio pubblico, privato, protetto ecc.

 Class Learn { private int a; // by making it private we are hiding it from other private void show() //class to access it { console.writeline(a); } } 

Qui abbiamo avvolto i dati in una unità o capsula, ad es. Class.

L’astrazione è esattamente l’opposto di Encapsulation.

L’astrazione viene utilizzata per mostrare all’utente importanti e rilevanti. il miglior esempio del mondo reale In un telefono cellulare, si vedono i loro diversi tipi di funzionalità come fotocamera, lettore mp3, funzione di chiamata, funzione di registrazione, multimedia ecc. È un’astrazione, perché si vedono solo le informazioni rilevanti al posto della loro ingegneria interna.

  abstract class MobilePhone { public void Calling(); //put necessary or essential data public void SendSMS(); //calling n sms are main in mobile } public class BlackBerry : MobilePhone // inherited main feature { public void FMRadio(); //added new public void MP3(); public void Camera(); public void Recording(); } 

L’astrazione è un termine molto generico e l’astrazione nel software non è limitata ai linguaggi orientati agli oggetti. Una definizione di dizionario: “l’atto di considerare qualcosa come una qualità o caratteristica generale, a prescindere da realtà concrete, oggetti specifici o istanze reali”.

Il linguaggio assembly può essere pensato come un’astrazione del codice macchina – l’assembly esprime i dettagli essenziali e la struttura del codice macchina, ma ti libera dal dover pensare agli opcode utilizzati, il layout del codice in memoria, facendo andare i salti a l’indirizzo giusto, ecc.

L’API del tuo sistema operativo è un’astrazione del computer sottostante. Il compilatore fornisce uno strato di astrazione che ti protegge dai dettagli del linguaggio assembly. Lo stack TCP / IP integrato nel sistema operativo astrae i dettagli della trasmissione di bit su una rete. Se vai giù fino al silicio grezzo, le persone che hanno progettato la tua CPU lo hanno fatto usando diagrammi circuitali scritti in termini di “diodi” e “transistor”, che sono astrazioni di come gli elettroni viaggiano attraverso i cristalli semiconduttori.

Nel software, tutto è un’astrazione. Costruiamo programmi che simulano o modellano alcuni aspetti della realtà, ma per necessità i nostri modelli allontanano sempre alcuni dettagli della “cosa reale”. Costruiamo layer su layer su layer di astrazioni, perché è l’unico modo in cui otteniamo qualcosa. (Immagina che stavi cercando di creare, ad esempio, un risolutore di sudoku, e dovevi progettarlo usando solo i cristalli di semiconduttori. “OK, ho bisogno di un pezzo di silicio di tipo N qui …”)

In confronto, “incapsulamento” è un termine molto specifico e limitato. Alcune delle altre risposte a questa domanda hanno già fornito buone definizioni per questo.

Rispondendo alla mia domanda dopo 5 anni, sentendo che ha ancora bisogno di ulteriori dettagli

Astrazione:

Definizione tecnica: – L’ astrazione è un concetto per hide dettagli non necessari (complessi o semplici) e mostrare solo le caratteristiche essenziali dell’object. Non c’è implementazione qui è solo un concetto

Cosa significa in pratica: – Quando dico che la mia azienda ha bisogno di un mezzo / dispositivo in modo che i dipendenti possano connettersi al cliente. Questa è la forma più pura di astinenza (come l’interfaccia in java) in quanto quel dispositivo / mezzo può essere un telefono o internet o skype o di persona o e-mail, ecc. Non sto andando a finire in un dispositivo / media

Anche quando dico che la mia azienda ha bisogno di un mezzo / dispositivo in modo che i dipendenti possano connettersi al cliente tramite chiamata vocale. Poi parlo anche astratto ma a un livello leggermente inferiore come dispositivo / mezzo può essere telefono o skype o qualcos’altro ecc

Ora quando dico che la mia azienda ha bisogno di un telefono in modo che i dipendenti possano connettersi al cliente tramite una chiamata vocale. Poi parlo anche astratto ma a un livello leggermente inferiore come il telefono può essere di qualsiasi azienda come iPhone o Samsung o Nokia ecc

Incapsulamento: – Si tratta fondamentalmente di hide lo stato (informazioni) dell’object con l’aiuto di modificatori come privati, pubblici, protetti ecc. Esponiamo lo stato attraverso metodi pubblici solo se richiesto.

Che cosa significa praticamente: – Ora quando dico che la mia azienda ha bisogno di un iphone in modo che i dipendenti possano connettersi al cliente attraverso la chiamata vocale. Ora sto parlando di un object concreto (come l’iphone). Anche se non ho intenzione di mettere in chiaro il nocciolo dell’iphone anche qui, ma l’iphone ha qualche informazione / implementazione concreta / associata associata con il dispositivo / medium che non ha. Quando dico object concreto, in realtà significa qualsiasi object che abbia qualche implementazione / informazione (non completa come la class astratta java) ad essa associata.

Quindi l’iphone ha effettivamente usato qui l’incapsulamento come strategia per hide il suo stato / informazione ed esporre solo quelli che pensa dovrebbero essere esposti. Quindi sia l’astrazione che l’incapsulamento nascondono alcuni dettagli non necessari, ma l’astrazione a livello di concetto e l’incapsulamento in realtà a livello di implementazione

Questo è il succo basato sulle risposte in questo post e sotto

  1. differenza tra astrazione e incapsulamento?
  2. esempio di incapsulamento vs astrazione del mondo reale

Incapsulamento : il processo di occultamento dei componenti della class per impedire l’accesso diretto dall’esterno. Si ottiene utilizzando il modificatore “privato” per impedire l’accesso diretto ad alcuni membri della class (campo dati o metodo) da altre classi o oggetti, fornendo al contempo l’accesso a questi membri privati ​​da membri pubblici (Interfaccia). Ciò rende i membri della class protetti come organi umani nascosti / incapsulati sotto la pelle o uno scudo.

Astrazione – Un principio deve essere seguito nella scrittura del programma OOP che dice “devi includere nella class solo componenti che sono interessanti nel compito del programma”. Ad esempio: lo studente object ha molti caratteri umani: nome, età, peso, colore dei capelli, colore degli occhi, ecc. Ma quando crei una lezione in OOP per lavorare con gli studenti dovresti includere solo quei personaggi che davvero materia per il database degli studenti: nome, età, specialità, livello, marchi … ecc. in C ++ puoi creare classi astratte usando il modificatore “virtuale” con qualsiasi metodo della class e ciò lo renderà inutilizzabile in diretta ma puoi derivare altre classi da esso e creare l’implementazione per i suoi membri con l’aggiunta di membri richiesti in base all’attività.

Ecco come l’ho capito:

Nella programmazione orientata agli oggetti, abbiamo qualcosa chiamato classi . A cosa servono? Devono immagazzinare alcuni stati e memorizzare alcuni metodi per cambiare quello stato, cioè, incapsulano lo stato e i suoi metodi.

A (class) non interessa la visibilità del proprio o dei suoi contenuti. Se scegliamo di hide lo stato o alcuni metodi, si nasconderà l’informazione .

Ora, prendi lo scenario di un’eredità . Abbiamo una class base e un paio di classi derivate (ereditate). Quindi, che cosa fa la class base qui? Sta estraendo alcune cose dalle classi derivate.

Tutti loro sono diversi, giusto? Ma li mescoliamo per scrivere buoni programmi orientati agli oggetti. Spero che sia d’aiuto 🙂

L’astrazione delinea una rappresentazione semplificata specifica del contesto di qualcosa; ignora i dettagli contestualmente non pertinenti e include dettagli contestualmente importanti.

L’incapsulamento limita l’ accesso esterno alle parti di qualcosa e raggruppa lo stato della cosa con le procedure che utilizzano lo stato.


Prendi le persone, per esempio. Nel contesto della chirurgia, un’astrazione utile ignora le credenze religiose di una persona e include il corpo della persona. Inoltre, le persone incapsulano i loro ricordi con i processi mentali che usano quei ricordi. Un’astrazione non ha bisogno di incapsulare; per esempio, un dipinto di una persona non nasconde le sue parti né impacchetta le procedure con il suo stato. E l’incapsulamento non ha bisogno di un’astrazione associata; per esempio, le persone reali (non quelle astratte) incapsulano i loro organi con il loro metabolismo.

NOTA: sto condividendo questo. Non significa che qui non sia una buona risposta, ma perché ho capito facilmente.

Risposta:

Quando una class è concettualizzata, quali sono le proprietà che possiamo avere in esso dato il contesto. Se stiamo progettando un animale di class nel contesto di uno zoo, è importante avere un attributo come animalType per descrivere domestico o selvaggio. Questo attributo potrebbe non avere senso quando progettiamo la class in un contesto diverso.

Allo stesso modo, quali sono i comportamenti che avremo nella class? L’astrazione è anche applicata qui. Cosa è necessario avere qui e quale sarà una overdose? Quindi abbiamo tagliato alcune informazioni dalla class. Questo processo sta applicando l’astrazione.

Quando chiediamo la differenza tra incapsulamento e astrazione, direi che l’ incapsulamento usa l’astrazione come concetto. Quindi, è solo incapsulamento. No, l’astrazione è anche un concetto applicato come parte dell’ereditarietà e del polimorfismo.

Vai qui per ulteriori spiegazioni su questo argomento.

Cerchiamo di capire in un modo diverso.

Cosa può accadere se l’astrazione non è presente e cosa può accadere se l’incapsulamento non è presente.

Se l’astrazione non c’è, allora puoi dire che l’object è usato di meno. Non è ansible identificare l’object né è ansible accedere a qualsiasi funzionalità di esso. Fai un esempio di un TV, se non hai un’opzione per accendere, cambiare canale, aumentare o diminuire il volume ecc., Allora a cosa serve la TV e come la usi?

Se l’incapsulamento non è presente o non viene implementato correttamente, si può abusare dell’object. Lì da dati / componenti possono essere abusati. Prendi lo stesso esempio di TV, se non è stato eseguito l’incapsulamento sul volume della TV, il regolatore del volume potrebbe essere utilizzato in modo errato facendolo scendere o superare il limite (0-40 / 50).

L’incapsulamento protegge per comprimere il comportamento interno di object / istanza dall’ quadro esterna. Quindi, dovrebbe essere fornito un controllo per confermare che i dati che vengono forniti non danneggeranno il sistema interno di istanza / object per sopravvivere alla sua esistenza.

Buon esempio, Divider è una class che ha due variabili di istanza dividendo e divisore e un metodo getDividedValue.

Potete per favore pensare, se il divisore è impostato su 0, il sistema / comportamento interno (getDivided) si interromperà.

Pertanto, il comportamento interno dell’object potrebbe essere protetto generando un’eccezione tramite un metodo.

Incapsulamento (dati e codice vincolanti)

  • L’incapsulamento è il meccanismo che lega insieme il codice e i dati che manipola e tiene al sicuro sia dall’interferenza che dall’uso improprio.

  • In un linguaggio orientato agli oggetti, codice e dati possono essere combinati in modo tale da creare una “scatola nera” autonoma. Quando codice e dati sono collegati insieme in questo modo, viene creato un object. In altre parole, un object è il dispositivo che supporta l’incapsulamento.

  • L’incapsulamento porta al concetto di occultamento dei dati, ma il concetto di incapsulamento non deve essere limitato all’occultamento delle informazioni.

  • L’incapsulamento rappresenta chiaramente la capacità di raggruppare dati e funzionalità correlate all’interno di una singola quadro autonoma chiamata class.

Astrazione (hide come i dati sono archiviati e hide come la funzione è implementata)

  • L’astrazione dei dati è un processo di rappresentazione delle funzionalità essenziali senza includere dettagli di implementazione.

  • L’astrazione è una delle funzionalità più potenti e vitali fornite dalla programmazione orientata agli oggetti.

  • L’idea principale alla base dell’astrazione dei dati è quella di fornire una chiara separazione tra le proprietà del tipo di dati e i dettagli di implementazione associati. Questa separazione viene raggiunta affinché le proprietà del tipo di dati astratto siano visibili all’interfaccia utente e i dettagli dell’implementazione siano nascosti.

  • L’astrazione sta separando le proprietà logiche dai dettagli di implementazione. Ad esempio, guidare la macchina è una proprietà logica e il design del motore è il dettaglio di implementazione.