incapsulamento e astrazione differenze con l'aiuto di un esempio in Java

Question

So che la mia domanda sarà nominato per essere chiuso immediatamente dopo la pubblicazione, ma lasciate che vi dica che avevo cercato il sito per una chiara differenza di taglio in termini di un esempio , in Java. Per favore, non aver fretta di chiudere la domanda.

ho scritto quanto segue:

public class Bank { 
public String name="XXX Bank"; 
private int noOfCust; 

public int getNoOfCust() { 
return getNoOfCusts() + 2; 
} 
public void setNoOfCust(int noOfCust) { 
if(noOfCust > 0) 
{ 
this.noOfCust = noOfCust; 
} 
} 

private int getNoOfCusts() 
{ 
noOfCust = 100; 
return noOfCust; 
} 
} 

Qui, 'noOfCust è i dati che vengono nascosti'. Non sto esponendo la parte dell'implementazione introducendo private getNoOfCusts(). Quindi credo che questo sia l'incapsulamento, perché ho raggruppato tutti i dettagli di una classe e ho nascosto anche i dati.

Domanda 1: Se questo incapsulamento forte? In caso contrario, come potrei migliorarlo per essere fortemente incapsulato?

Domanda 2: Astrazione significa nascondere completamente l'implementazione. Quindi quello che ho fatto sopra è l'astrazione?

ho postato questa domanda a causa della frustrazione perché avevo dato la spiegazione di cui sopra ad un intervistatore, che mi ha detto, questo non è il significato corretto.

P.S: Si prega di rispondere in termini di esempio precedente. Non voglio esempi o ipotesi in tempo reale.

Answer 1

Scelta proprietà necessarie e nascondere i dettagli indesiderati è Abstraction. Ad es. Considera persona La persona ha gli occhi, le proprietà eyeColor, skinColor. Ma se va in banca, Bank fa la sua astrazione e non considera le proprietà di queste persone ma seleziona nome, indirizzo, numero di telefono. Questa è Astrazione. Hai frainteso.

L'incapsulamento indica semplicemente lo stato dell'oggetto di associazione (proprietà) e il comportamento (metodi) insieme. Se stai creando una classe, stai incapsulando.

Da : Nei linguaggi di programmazione orientati agli oggetti come C++, Object Pascal o Java, il concetto di astrazione è diventato esso stesso una dichiarazione dichiarativa - utilizzando le parole chiave virtual (in C++) o abstract (in Java). Dopo tale dichiarazione, è responsabilità del programmatore implementare una classe per creare un'istanza dell'oggetto della dichiarazione.

Answer 2

credo che potrebbe essere malinteso incapsulamento e astrazione.

incapsulamento è più chiaramente spiegato in termini di una scatola nera. Gli interni possono cambiare quando necessario, ma l'interfaccia pubblica rimane la stessa. Detto questo, il tuo codice è parzialmente incapsulato, in quanto hai un privato int con un getter pubblico e setter (e un getter privato, che non vedo scopo, ma dipende da te). Tuttavia, String name è pubblico e non ha getter o setter; sembra che tu intenda che sia una costante, nel qual caso dovrebbe essere dichiarata come pubblica, statica e definitiva.

L'astrazione è il concetto di semplificazione di un'idea per un'idea generale più generale. In Java, una classe può essere fatto astratto, fornendo un'implementazione che fornisce un'idea generale, ma manca di specificità, e non può essere istanziato. Ciò è ottenuto attraverso il modificatore abstract, che quando si modifica una classe, denota che la classe astratta non può essere istanziata; quando si modifica un metodo (che deve essere in una classe astratta), il modificatore denota che il metodo astratto deve essere definito in qualsiasi implementazione di sottoclasse.

Esempio di astrazione in Java, dove l'astrazione impone che il baseball è una palla:

public abstract class Ball { 
    // this class cannot be instantiated 
    public abstract double getRadius(); 

    public double getVolume() { 
     return (4.0/3) * Math.PI * Math.pow(getRadius(), 3); 
    } 
} 

public class Baseball extends Ball { 
    // this class can be instantiated 
    @Override 
    public double getRadius() { 
     return 3.0; 
    } 
} 

Answer 3

L'incapsulamento in java avviene automaticamente tramite oggetti e metodi. Non devi prenderti cura di questo. Tuttavia, se lo desideri, puoi utilizzare diversi mezzi di occultamento per aumentare la tua complessità. Quindi, altri non saranno in grado di decifrare il tuo codice. È possibile utilizzare funzioni ricorsive e metodi complicati e aggiungere codici non necessari. Incapsulamento forte !!

Answer 4

• L'idea alla base encapsulation è quello di nascondere la rappresentazione interna di un object dal punto di vista al di fuori della definizione della classe. Questo è generalmente fatto per proteggere gli interni di una classe e fornire un modo sistematico per accedervi.

• Inoltre, l'idea alla base della combinazione getter/setter consiste nel fornire un modo controllato per accedere alle proprietà di tale classe. Pertanto, per ogni proprietà private di una classe, si avrebbe il metodo publicsetter() e getter().

Tenendo conto di questi due aspetti, si può ben capire perché c'è un problema con il codice in termini di incapsulamento. Una classe skeleton avere questo concetto implementato potrebbe essere il seguente:

public class Bank{ 
    private int noOfCustomers; 
    private String name; 


    public String getName(){ 
     return this.name; 
    } 

    public void setName(String name){ 
     this.name = name; 
    } 

    public int getNoOfCustomers(){ 
     return this.noOfCustomers; 
    } 

    public void setNoOfCustomers(int noOfCustomers){ 
     this.noOfCustomers = noOfCustomers; 
    } 

    /** 
    * This method is to illustrate that it is perfectly valid to have 
    * multiple types of setter methods 
    */ 
    public void setNoOfCustomers(String noOfCustomers){ 
     try{ 
      this.noOfCustomers = Integer.parseInt(noOfCustomers); 
     }catch(Exception exe){ 
      //Handle exceptions 
     } 
    } 
} 

Per quanto riguarda abstraction: Si può pensare ad esso come un'idea di presentare qualcosa in modo semplificato, che è sia di facile comprensione in termini di utilizzo o più pertinente alla situazione Prendendo il tuo esempio, puoi pensare a Bank come a abstraction che può rappresentare sia una banca federale o una banca membro di stato o qualcosa del genere. Fonderesti essenzialmente classi specifiche per ciascuna di queste rappresentazioni, prendendo Bank come genitore.

Penso che si possa ottenere un'immagine migliore di abstraction se si studia cosa rappresenta File in Java. Il file in sé è una rappresentazione astratta di nomi di file e directory. Tuttavia, se si studiano i codici sorgente, si troverà che contiene diverse proprietà che sono private alla sua progettazione.

L'incapsulamento, in quanto tale, può essere considerato il modo in cui si proteggono le proprietà da uso improprio e astrazione, in quanto tale può essere pensato a quanta semplificazione si sta fornendo all'utente esterno.

Answer 5

Incapsulamento: Ok, forse. Hai un'implementazione molto strana e il chiamante non riesce a vederlo.

Astrazione: c'è bisogno di sapere che cosa stai effettivamente cercando di fare. L'interfaccia attuale sembra getter/setter di un valore intero. Non è molto astratto (e l'implementazione non funziona così, fa qualcos'altro). Per un'astrazione l'operazione eseguita (o l'oggetto coinvolto) deve catturare qualcosa che non è solo separato dall'implementazione concreta, ma anche applicabile a una gamma più ampia di cose (che sono diverse, ma comunque simili in quanto possono essere fatte per appartengono alla stessa "astrazione"). Il tuo esempio è probabilmente troppo piccolo per questo.

Per provare a costruire sull'esempio, forse si dispone di un codice che classifica le aziende in base alla loro dimensione. Ci sarebbe l'astrazione del "business" con proprietà come numero di clienti, numero di dipendenti, ecc. Il codice che utilizza questa astrazione funzionerebbe ugualmente bene con banche, farmacie e negozi di alimentari.