Introduzione all'incapsulamento in Java
L'incapsulamento è uno dei quattro concetti di programmazione orientata agli oggetti di base in Java. L'idea principale alla base di questo è il nascondere i dettagli di implementazione dagli utenti. In altre parole, l'incapsulamento è il confezionamento di dati in una singola unità al fine di impedire l'accesso ad esso dal mondo esterno. Poiché i dati sono nascosti dalle altre classi, questo processo è anche noto come Nascondersi dati. Consideriamo il funzionamento di una lampadina come esempio. Non conosciamo l'effettivo funzionamento dietro la lampadina anche se la stiamo usando. Ma nel caso di Java Encapsulation, è possibile accedere ai dati utilizzando modificatori. Vediamolo nella prossima sezione.
Come funziona l'incapsulamento in Java?
L'incapsulamento funziona in Java da
- Dichiarare gli attributi o le variabili in classe come privati
Ad esempio, stiamo creando un dipendente di classe. Le variabili devono essere impostate come private come mostrato di seguito.
private String EmpName;
private int EmpID;
private int EmpSal;
- Creazione di metodi pubblici in classe per ottenere e impostare gli attributi o le variabili.
Di seguito è riportato il metodo get e il metodo set per le diverse variabili private nella classe Employee.
Codice:
public int getEmpSal()
(
return EmpSal;
)public String getEmpName()
(
return EmpName;
)
public int getEmpID()
(
return EmpID;
)
public void setEmpSal( int EmpSal)
(
this.EmpSal = EmpSal;
)
public void setEmpName(String EmpName)
(
this.EmpName = EmpName;
)
public void setEmpID( int EmpID)
(
this.EmpID = EmpID;
)
Usando questi metodi, è possibile rendere la classe di sola lettura o sola lettura, cioè possiamo saltare questi metodi se è necessario.
Di seguito sono riportati alcuni dei vantaggi dell'incapsulamento.
- Semplicità nell'applicazione
- Possibilità di riutilizzare o modificare il codice in base ai requisiti
- Limita l'accessibilità dei dati
- Facilità nel testing di unità poiché il codice è incapsulato
Java Bean Class è uno degli esempi per la classe completamente incapsulata poiché tutti i membri dei dati nella classe sono privati.
Esempi di incapsulamento Java
Vediamo un esempio di incapsulamento con i metodi getter e setter. Per questo crea 2 classi: una con il metodo principale e l'altra con i metodi get e set.
Esempio 1
- Employee.java
Codice:
//Java program for Encapsulation with both read and write
public class Employee (
//private variables which can be accessed by public methods of the class
private String EmpName;
private int EmpID;
private int EmpSal;
// get method to access the private integer variable EmpSal
public int getEmpSal()
(
return EmpSal;
)
// get method to access the private string variable EmpName
public String getEmpName()
(
return EmpName;
)
// get method to access the private integer variable EmpID
public int getEmpID()
(
return EmpID;
)
// set method to access the private integer variable EmpSal
public void setEmpSal( int EmpSal)
(
this.EmpSal = EmpSal;
)
// set method to access the private string variable EmpName
public void setEmpName(String EmpName)
(
this.EmpName = EmpName;
)
// set method to access the private integer variable EmpID
public void setEmpID( int EmpID)
(
this.EmpID = EmpID;
)
)
- EmployeeEncaps.java
Codice:public class EmployeeEncaps (
public static void main(String() args) (
Employee EmpObj= new Employee(); //object of the class Employee
//passing the values to the methods using object
EmpObj.setEmpName("Anna");
EmpObj.setEmpSal(30000);
EmpObj.setEmpID(670311);
// Printing values of the variables
System.out.println("Employee's Name: " + EmpObj.getEmpName());
System.out.println("Employee's ID: " + EmpObj.getEmpID());
System.out.println("Employee's Salary: " + EmpObj.getEmpSal());
)
)
Produzione:
Nel programma sopra, la classe Employee è incapsulata poiché le variabili sono private. È possibile leggere e scrivere l'implementazione poiché ha ottenuto e impostato metodi. Le variabili private come EmpName, EmpSal, EmpID sono accessibili usando questi metodi e visualizzate chiamando i metodi usando l'oggetto.
Ora, vediamo come funziona l'incapsulamento con la classe di sola lettura.
Esempio 2
- Employee.java
Codice:
//Java program for Encapsulation with read permission
public class Employee (
//private variables which can be accessed by public methods of the class
private String EmpName = "Adam";
private int EmpID = 670388;
private int EmpSal = 35000;
// get method to access the private integer variable EmpSal
public int getEmpSal()
(return EmpSal;
)// get method to access the private string variable EmpName
public String getEmpName()
(
return EmpName;
)
// get method to access the private integer variable EmpID
public int getEmpID()
(
return EmpID;
)
)
- EmployeeEncaps.java
Codice:
public class EmployeeEncaps (
public static void main(String() args) (
Employee EmpObj= new Employee(); //object of the class Employee
// Printing values of the variables
System.out.println("Employee's Name: " + EmpObj.getEmpName());
System.out.println("Employee's ID: " + EmpObj.getEmpID());
System.out.println("Employee's Salary: " + EmpObj.getEmpSal());
)
)
Produzione:
Simile al primo esempio, anche qui stiamo usando variabili private. La differenza è che non stiamo usando il metodo set per impostare valori per le variabili private nella classe. Invece, assegniamo direttamente il valore alle variabili.
Ora possiamo passare a scrivere solo lezioni.
Esempio 3
- Employee.java
Codice:
//Java program for Encapsulation with write permission
public class Employee (
//private variables which can be accessed by public methods of the class
private String EmpName;
private int EmpID;
private int EmpSal;
// set method to access the private integer variable EmpSal
public void setEmpSal( int EmpSal)
(
this.EmpSal = EmpSal;
//for sample output
System.out.println("Employee's Salary: " + EmpSal);
)
// set method to access the private string variable EmpName
public void setEmpName(String EmpName)
(
this.EmpName = EmpName;
//for sample output
System.out.println("Employee's Name: " + EmpName);
)// set method to access the private integer variable EmpID
public void setEmpID( int EmpID)
(
this.EmpID = EmpID;
//for sample output
System.out.println("Employee's ID: " + EmpID);
)
)
- EmployeeEncaps.java
Codice:
public class EmployeeEncaps (
public static void main(String() args) (
Employee EmpObj = new Employee(); //object of the class Employee
//passing the values to the methods using object
EmpObj.setEmpName("Iza");
EmpObj.setEmpID(670472);
EmpObj.setEmpSal(48000);
)
)
Produzione:
Nell'esempio sopra, non stiamo usando il metodo get per ottenere la classe di sola scrittura. cioè le variabili non possono essere modificate o recuperate qui. Dal momento che non è possibile ottenere i valori, stiamo usando print all'interno del metodo set per l'output di esempio.
Conclusione
L'incapsulamento è un concetto OOP in cui i dati verranno spostati nascondendo tutti i dettagli di implementazione. Può essere ottenuto utilizzando variabili private e metodi come ottenere, impostare per accedere alle variabili. I principali vantaggi dell'incapsulamento includono flessibilità, nascondimento dei dati, facilità nei test e riusabilità .
Articoli consigliati
Questa è stata una guida all'incapsulamento in Java. Qui discutiamo di come funziona l'incapsulamento, esempi di incapsulamento Java con codici e output. Puoi anche consultare i nostri articoli per saperne di più-
- Distruttore in Java
- Layout in Java
- I migliori compilatori Java
- Guida all'incapsulamento in C ++
- Perché abbiamo bisogno dell'incapsulamento in C?
- Panoramica dell'incapsulamento in JavaScript