L'incapsulamento in Java è un concetto fondamentale nella programmazione orientata agli oggetti (OOP) che si riferisce al raggruppamento di dati e metodi che operano su tali dati all'interno di una singola unità, chiamata classe in Java. L'incapsulamento Java è un modo per nascondere i dettagli di implementazione di una classe all'accesso esterno ed esporre solo un'interfaccia pubblica che può essere utilizzata per interagire con la classe.
In Java, l'incapsulamento si ottiene dichiarando private le variabili di istanza di una classe, il che significa che è possibile accedervi solo all'interno della classe. Per consentire l'accesso esterno alle variabili di istanza, vengono definiti metodi pubblici chiamati getter e setter, che vengono utilizzati rispettivamente per recuperare e modificare i valori delle variabili di istanza. Utilizzando getter e setter, la classe può applicare le proprie regole di convalida dei dati e garantire che il proprio stato interno rimanga coerente.
Implementazione dell'incapsulamento Java
Di seguito è riportato l'esempio con l'incapsulamento Java:
Giava
ordinamento di fusione
// Java Program to demonstrate> // Java Encapsulation> // Person Class> class> Person {> >// Encapsulating the name and age> >// only approachable and used using> >// methods defined> >private> String name;> >private> int> age;> >public> String getName() {>return> name; }> >public> void> setName(String name) {>this>.name = name; }> >public> int> getAge() {>return> age; }> >public> void> setAge(>int> age) {>this>.age = age; }> }> // Driver Class> public> class> Main {> >// main function> >public> static> void> main(String[] args)> >{> >// person object created> >Person person =>new> Person();> >person.setName(>'John'>);> >person.setAge(>30>);> >// Using methods to get the values from the> >// variables> >System.out.println(>'Name: '> + person.getName());> >System.out.println(>'Age: '> + person.getAge());> >}> }> |
>
>Produzione
Name: John Age: 30>
Incapsulamento è definito come il raggruppamento dei dati in una singola unità. È il meccanismo che lega insieme il codice e i dati che manipola. Un altro modo di pensare all'incapsulamento è che si tratta di uno scudo protettivo che impedisce l'accesso ai dati da parte del codice esterno a questo scudo.
- Tecnicamente nell'incapsulamento, le variabili o i dati di una classe sono nascosti a qualsiasi altra classe ed è possibile accedervi solo tramite qualsiasi funzione membro della propria classe in cui è dichiarata.
- Come nell'incapsulamento, i dati in una classe vengono nascosti alle altre classi utilizzando il concetto di nascondimento dei dati che si ottiene rendendo privati i membri o i metodi di una classe e la classe viene esposta all'utente finale o al mondo senza fornire alcun dettaglio dietro l'implementazione utilizzando il concetto di astrazione, quindi è anche noto come a combinazione di occultamento dei dati e astrazione .
- L'incapsulamento può essere ottenuto dichiarando tutte le variabili nella classe come private e scrivendo metodi pubblici nella classe per impostare e ottenere i valori delle variabili.
- È più definito con il metodo setter e getter.
Vantaggi dell'incapsulamento
- Dati nascosti: è un modo per limitare l'accesso dei nostri dati membri nascondendo i dettagli di implementazione. L'incapsulamento fornisce anche un modo per nascondere i dati. L'utente non avrà idea dell'implementazione interna della classe. Non sarà visibile all'utente il modo in cui la classe memorizza i valori nelle variabili. L'utente saprà solo che stiamo passando i valori a un metodo setter e che le variabili verranno inizializzate con quel valore.
- Maggiore flessibilità: Possiamo rendere le variabili della classe di sola lettura o di sola scrittura a seconda delle nostre esigenze. Se desideriamo rendere le variabili di sola lettura allora dobbiamo omettere i metodi setter come setName(), setAge(), ecc. dal programma sopra o se desideriamo rendere le variabili di sola scrittura allora dobbiamo omettere il ottieni metodi come getName(), getAge(), ecc. dal programma sopra
- Riutilizzabilità: L'incapsulamento migliora anche la riutilizzabilità ed è facile da modificare con nuovi requisiti.
- Testare il codice è semplice: Il codice incapsulato è facile da testare per i test unitari.
- Libertà del programmatore nell'implementazione dei dettagli del sistema: Questo è uno dei principali vantaggi dell'incapsulamento poiché offre al programmatore la libertà nell'implementazione dei dettagli di un sistema. L'unico vincolo per il programmatore è mantenere l'interfaccia astratta che vedono gli estranei.
Per esempio: Il programmatore del codice del menu di modifica nella GUI di un editor di testo potrebbe inizialmente implementare le operazioni di taglia e incolla copiando le immagini dello schermo effettive dentro e fuori da un buffer esterno. Successivamente potrebbe essere insoddisfatto di questa implementazione, poiché non consente la memorizzazione compatta della selezione e non distingue testo e oggetti grafici. Se il programmatore ha progettato l'interfaccia taglia e incolla pensando all'incapsulamento, cambiare l'implementazione sottostante con una che memorizza il testo come testo e oggetti grafici in un formato compatto appropriato non dovrebbe causare problemi alle funzioni che devono interfacciarsi con questa GUI . Pertanto l'incapsulamento produce adattabilità, poiché consente ai dettagli di implementazione di parti di un programma di cambiare senza influenzare negativamente altre parti.
Svantaggi dell'incapsulamento in Java
- Può portare ad una maggiore complessità, soprattutto se non utilizzato correttamente.
- Può rendere più difficile capire come funziona il sistema.
- Può limitare la flessibilità dell'attuazione.
Esempi che mostrano l'incapsulamento dei dati in Java
Esempio 1:
Di seguito è riportata l'implementazione dell'argomento precedente:
Giava
// Java Program to demonstrate> // Java Encapsulation> // fields to calculate area> class> Area {> >int> length;> >int> breadth;> >// constructor to initialize values> >Area(>int> length,>int> breadth)> >{> >this>.length = length;> >this>.breadth = breadth;> >}> >// method to calculate area> >public> void> getArea()> >{> >int> area = length * breadth;> >System.out.println(>'Area: '> + area);> >}> }> class> Main {> >public> static> void> main(String[] args)> >{> >Area rectangle =>new> Area(>2>,>16>);> >rectangle.getArea();> >}> }> |
>
>Produzione
Area: 32>
Esempio 2:
Il programma per accedere alle variabili della classe EncapsulateDemo è mostrato di seguito:
Giava
mvc per Java
// Java program to demonstrate> // Java encapsulation> class> Encapsulate {> >// private variables declared> >// these can only be accessed by> >// public methods of class> >private> String geekName;> >private> int> geekRoll;> >private> int> geekAge;> >// get method for age to access> >// private variable geekAge> >public> int> getAge() {>return> geekAge; }> >// get method for name to access> >// private variable geekName> >public> String getName() {>return> geekName; }> >// get method for roll to access> >// private variable geekRoll> >public> int> getRoll() {>return> geekRoll; }> >// set method for age to access> >// private variable geekage> >public> void> setAge(>int> newAge) { geekAge = newAge; }> >// set method for name to access> >// private variable geekName> >public> void> setName(String newName)> >{> >geekName = newName;> >}> >// set method for roll to access> >// private variable geekRoll> >public> void> setRoll(>int> newRoll) { geekRoll = newRoll; }> }> public> class> TestEncapsulation {> >public> static> void> main(String[] args)> >{> >Encapsulate obj =>new> Encapsulate();> >// setting values of the variables> >obj.setName(>'Harsh'>);> >obj.setAge(>19>);> >obj.setRoll(>51>);> >// Displaying values of the variables> >System.out.println(>'Geek's name: '> + obj.getName());> >System.out.println(>'Geek's age: '> + obj.getAge());> >System.out.println(>'Geek's roll: '> + obj.getRoll());> >// Direct access of geekRoll is not possible> >// due to encapsulation> >// System.out.println('Geek's roll: ' +> >// obj.geekName);> >}> }> |
>
>Produzione
Geek's name: Harsh Geek's age: 19 Geek's roll: 51>
Esempio 3:
Nel programma sopra, la classe Encapsulate è incapsulata poiché le variabili sono dichiarate private. I metodi get come getAge(), getName() e getRoll() sono impostati come pubblici e vengono utilizzati per accedere a queste variabili. Anche i metodi setter come setName(), setAge(), setRoll() sono dichiarati pubblici e vengono utilizzati per impostare i valori delle variabili.
Di seguito è riportata l'implementazione dell'esempio definito:
Giava
// Java Program to demonstrate> // Java Encapsulation> class> Name {> >// Private is using to hide the data> >private> int> age;> >// getter> >public> int> getAge() {>return> age; }> >// setter> >public> void> setAge(>int> age) {>this>.age = age; }> }> // Driver Class> class> GFG {> >// main function> >public> static> void> main(String[] args)> >{> >Name n1 =>new> Name();> >n1.setAge(>19>);> >System.out.println(>'The age of the person is: '> >+ n1.getAge());> >}> }> |
>
>Produzione
The age of the person is: 19>
Esempio 4:
Di seguito è riportata l'implementazione dell'incapsulamento Java:
Giava
quale anno è stato inventato il computer
// Java Program to demonstrate> // Java Encapsulation> class> Account {> >// private data members to hide the data> >private> long> acc_no;> >private> String name, email;> >private> float> amount;> >// public getter and setter methods> >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;> >}> }> // Driver Class> public> class> GFG {> >// main function> >public> static> void> main(String[] args)> >{> >// creating instance of Account class> >Account acc =>new> Account();> >// setting values through setter methods> >acc.setAcc_no(90482098491L);> >acc.setName(>'ABC'>);> >acc.setEmail(>'[email protected]'>);> >acc.setAmount(100000f);> >// getting values through getter methods> >System.out.println(> >acc.getAcc_no() +>' '> + acc.getName() +>' '> >+ acc.getEmail() +>' '> + acc.getAmount());> >}> }> |
>
>Produzione
90482098491 ABC [email protected] 100000.0>