encapsulation java
Ulteriori informazioni sull'incapsulamento in Java con esempi, perché ne abbiamo bisogno, metodi getter e setter associati:
In questo tutorial, discuteremo un altro concetto OOP: 'Incapsulamento'. L'OOP ha quattro pilastri: astrazione, incapsulamento, polimorfismo ed ereditarietà.
Mentre l'astrazione viene utilizzata per esporre solo i dettagli rilevanti all'utente finale, l'incapsulamento si occupa principalmente della sicurezza dei dati. Nel garantire la sicurezza dei dati, l'incapsulamento protegge i membri dei dati dall'accesso indesiderato specificando i modificatori di accesso e raggruppa i dati in una singola unità.
tipo di test nello sviluppo del software
=> Dai un'occhiata alla guida di formazione Java perfetta qui.
Allora come possiamo definire l'incapsulamento in Java?
Definizione di incapsulamento
'L'incapsulamento in Java può essere definito come un meccanismo mediante il quale i dati e i metodi che lavorano su tali dati vengono inseriti in una singola unità.'
Cosa imparerai:
Che cos'è l'incapsulamento in Java
Utilizzando l'incapsulamento possiamo anche nascondere i membri dei dati di classe (variabili) dalle altre classi. È possibile accedere indirettamente a queste variabili membro dati utilizzando i metodi della classe in cui sono dichiarate. A loro volta si accede ai metodi utilizzando l'oggetto di quella classe.
Quindi ciò che concludiamo dalla definizione precedente è che abbiamo nascosto le variabili dei membri dei dati all'interno di una classe e abbiamo anche specificato i modificatori di accesso in modo che non siano accessibili alle altre classi.
Quindi l'incapsulamento è anche una sorta di 'occultamento dei dati' sebbene più avanti nel tutorial vedremo che l'incapsulamento non è la stessa cosa dell'occultamento dei dati.
La figura sopra rappresenta una classe che è un'unità di incapsulamento che raggruppa i dati ei metodi che operano su questi dati in una singola unità.
Poiché l'incapsulamento si occupa principalmente di dati, è chiamato in alternativa 'Incapsulamento dei dati'.
Possiamo visualizzare l'incapsulamento come una capsula medica. Come tutti sappiamo, il medicinale è racchiuso in una capsula medica. Allo stesso modo, dati e metodi sono racchiusi in una singola unità in incapsulamento.
Pertanto, l'incapsulamento funge da scudo protettivo attorno ai dati e impedisce ai dati l'accesso non autorizzato dal mondo esterno. In altre parole, protegge i dati sensibili della nostra applicazione.
In Java, ci sono due passaggi per implementare l'incapsulamento. Di seguito sono riportati i passaggi:
- Utilizza il modificatore di accesso 'private' per dichiarare le variabili dei membri della classe.
- Per accedere a queste variabili membro private e modificare i loro valori, dobbiamo fornire rispettivamente i metodi public getter e setter.
Implementiamo ora l'esempio dell'incapsulamento in Java.
Esempio di incapsulamento Java
//Student_Id and name bundled in a unit 'Student' => encapsulation class Student { private int Student_Id; private String name; //getters, setters for Student_Id and name fields. public int getId() { return Student_Id; } public void setId(int s_id) { this.Student_Id = s_id; } public String getname() { return name; } public void setname(String s_name) { this.name = s_name; } } class Main{ public static void main(String() args) { //create an object of Student class Student s=new Student(); //set fields values using setter methods s.setId (27); s.setname('Tom Lee'); //print values using getter methods System.out.println('Student Data:' + '
Student ID:' + s.getId() + ' Student Name:' + s.getname()); } }
Produzione:
Nel programma sopra, dichiariamo una classe che è l'unità di incapsulamento. Questa classe Student ha raggruppato i dati (Student_Id e nome) ei metodi per leggere e impostare i valori per questi membri in una singola unità.
Notare i modificatori di accesso associati ai campi membro. Entrambi i campi del membro sono privati in modo che non siano accessibili al di fuori della classe Student.
Forniamo getter (getId e getname) per leggere i valori di questi campi e metodi setter (setId e setname) per impostare i valori per questi metodi. Questo è l'unico accesso che hanno e anche quello dovrebbe essere fatto usando l'oggetto della classe Student.
b-albero vs b + albero
Metodi Getter e Setter
Per implementare l'incapsulamento in Java, rendiamo private le variabili membro dei dati della classe. Ora, queste variabili private non sono accessibili a nulla al di fuori della classe, incluso l'oggetto della classe.
Ciò significa che se abbiamo una classe ABC come segue.
classe ABC {
età int privata;
}
Creiamo un oggetto della classe ABC come segue:
ABC abc = nuovo ABC ();
abc.age = 21; // errore del compilatore
Quindi, nel codice precedente, l'accesso alla variabile privata utilizzando l'oggetto classe comporterà un errore del compilatore.
Per accedere alle variabili private e leggere i loro valori e impostare alcuni nuovi valori in esse, abbiamo bisogno di un modo per farlo. Pertanto Java fornisce un modo per accedere a variabili private utilizzando metodi getter e setter.
Getter e Setters sono metodi pubblici che possiamo utilizzare per creare, modificare, eliminare o semplicemente visualizzare i valori delle variabili private.
Il programma seguente è un esempio dei metodi Getter e Setter.
//Account class - private data members bundled with getters and setters class Account { //private data members private long acc_no; private String name,email; private float amount; //public getter and setter methods for each data member public long getAcc_no() { return acc_no; } public void setAcc_no(long acc_no) { this.acc_no = acc_no; } public String getName() { return name; } public void setName(String name) { this.name = name; } public String getEmail() { return email; } public void setEmail(String email) { this.email = email; } public float getAmount() { return amount; } public void setAmount(float amount) { this.amount = amount; } } public class Main { public static void main(String() args) { //create instance of Account class Account myAcc=new Account(); //set values for data members through setter methods myAcc.setAcc_no(775492842L); myAcc.setName('SoftwareTestingHelp.com'); myAcc.setEmail('sth_account@sth.com'); myAcc.setAmount(25000f); //read data member values through getter methods System.out.println('Account No:' + myAcc.getAcc_no()+' '+'Account Name:' + myAcc.getName()+'
'+'Account holder email:' + myAcc.getEmail()+'
' + 'Amount in Account:' + myAcc.getAmount()); } }
Produzione:
Il programma di cui sopra ha una classe Account e ha quattro variabili private relative all'account. Poiché tutti i membri dei dati sono privati, abbiamo fornito i metodi getter e setter per ciascuna di queste variabili.
come faccio ad aprire un file eps in Windows 10
Nel metodo principale, leggiamo e impostiamo i valori per queste variabili private utilizzando i metodi getter e setter pubblici a cui si accede tramite l'oggetto della classe Account.
Dati nascosti in Java
Spesso utilizziamo l'incapsulamento e l'occultamento dei dati in modo intercambiabile. Ma entrambi non sono la stessa cosa. L'incapsulamento Java si occupa del raggruppamento dei dati correlati in una singola unità per garantire una migliore gestione e sicurezza dei dati.
L'occultamento dei dati, d'altra parte, limita l'accesso ai membri dei dati nascondendo i dettagli di implementazione. Sebbene l'incapsulamento non sia esattamente il nascondiglio dei dati, ci fornisce il modo per nascondere i dati. L'occultamento dei dati si ottiene utilizzando i modificatori di accesso.
Java fornisce quattro modificatori di accesso.
- pubblico: Accessibile a tutti.
- privato: Accessibile solo all'interno della classe.
- protetto: Accessibile al pacchetto contenitore e alle sottoclassi.
- predefinito: Accessibile all'interno della confezione.
L'incapsulamento raggruppa i dati in una singola unità, quindi in un certo senso nasconde i dati. Inoltre, rende i dati privati e quindi inaccessibili al mondo esterno. Per rendere privati i dati, utilizziamo il modificatore di accesso privato, che è un concetto che nasconde i dati.
Allo stesso tempo, all'utente finale vengono forniti solo i dettagli rilevanti senza esporre i dettagli di implementazione, che è una definizione di astrazione. Quindi possiamo vedere l'incapsulamento come una combinazione di astrazione e nascondimento dei dati.
Perché abbiamo bisogno dell'incapsulamento
Esistono vari motivi per cui l'incapsulamento è essenziale in Java:
- L'incapsulamento ci consente di modificare il codice o una parte del codice senza dover modificare altre funzioni o codice.
- L'incapsulamento controlla il modo in cui accediamo ai dati.
- Possiamo modificare il codice in base ai requisiti utilizzando l'incapsulamento.
- L'incapsulamento rende le nostre applicazioni più semplici.
Domande frequenti
D # 1) Perché viene utilizzato l'incapsulamento in Java?
Risposta: L'incapsulamento in Java è principalmente utile per nascondere i dati. O in altre parole, decidere in merito all'accesso dato ai dati su chi può accedervi e chi no.
D # 2) Cos'è l'incapsulamento in OOP?
Risposta: L'incapsulamento è uno dei pilastri importanti del linguaggio di programmazione orientato agli oggetti e si occupa del raggruppamento di dati e metodi che operano su tali dati in un'unica unità. Per esempio, una classe in Java è una struttura incapsulata. L'incapsulamento si occupa anche delle decisioni relative alla fornitura dell'accesso ai dati.
D # 3) Qual è il vantaggio dell'incapsulamento in Java?
Risposta: Il principale vantaggio dell'incapsulamento in Java è l'occultamento dei dati. Utilizzando l'incapsulamento possiamo consentire al programmatore di decidere sull'accesso ai dati e sui metodi che operano su quei dati. Per esempio, se vogliamo che un particolare dato sia inaccessibile a chiunque al di fuori della classe, allora rendiamo quei dati privati.
Q # 4) Cos'è il processo di incapsulamento?
Risposta: L'incapsulamento è un processo di raccolta dei dati da un formato o protocollo (in termini di rete) e di tradurli o riformattarli in un altro formato o protocollo in modo che i dati siano accessibili attraverso le applicazioni o la rete e allo stesso tempo siano protetti.
D # 5) Qual è l'ultimo passaggio nell'incapsulamento dei dati?
Risposta: L'ultimo passaggio dell'incapsulamento consiste nel modificare le informazioni dell'utente in dati equivalenti. Quindi questi dati vengono modificati in segmenti che vengono ulteriormente trasformati in pacchetti di dati. I pacchetti di dati vengono inseriti in un frame logico che può essere trasferito avanti e indietro nell'ambiente software
Conclusione
Questo conclude il nostro tutorial sull'incapsulamento in Java. L'incapsulamento è una tecnica per raggruppare le variabili membro e i metodi che operano su questi membri di dati in una singola unità. Una classe in Java è un classico esempio di incapsulamento poiché racchiude i dati e i metodi in una singola unità.
Java ottiene l'implementazione dell'incapsulamento rendendo privati tutti i membri dei dati e quindi fornendo metodi getter e setter che sono pubblici in modo che possiamo leggere i valori delle variabili private e impostare nuovi valori per queste variabili.
=> Visita qui per l'esclusiva serie di tutorial di formazione Java.
Lettura consigliata
- Tutorial JAVA per principianti: oltre 100 tutorial video Java pratici
- TreeMap in Java - Tutorial con esempi di Java TreeMap
- Java Double - Tutorial con esempi di programmazione
- Tutorial Java Float con esempi di programmazione
- Java Reverse String: tutorial con esempi di programmazione
- Java Enum: Tutorial sull'enumerazione Java con esempi
- Java Integer e Java BigInteger Class con esempi
- Tutorial sul metodo Java String contains () con esempi