L'encapsulació a Java és un concepte fonamental en la programació orientada a objectes (OOP) que es refereix a l'agrupació de dades i mètodes que operen amb aquestes dades dins d'una sola unitat, que s'anomena classe a Java. L'encapsulació de Java és una manera d'ocultar els detalls d'implementació d'una classe de l'accés extern i només exposar una interfície pública que es pot utilitzar per interactuar amb la classe.
A Java, l'encapsulació s'aconsegueix declarant les variables d'instància d'una classe com a privades, el que significa que només es pot accedir a elles dins de la classe. Per permetre l'accés extern a les variables d'instància, es defineixen mètodes públics anomenats getters i setters, que s'utilitzen per recuperar i modificar els valors de les variables d'instància, respectivament. Mitjançant l'ús de captadors i setters, la classe pot aplicar les seves pròpies regles de validació de dades i assegurar-se que el seu estat intern segueixi sent coherent.
Implementació de Java Encapsulation
A continuació es mostra l'exemple amb Java Encapsulation:
Java
// 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());> >}> }> |
>
>Sortida
Name: John Age: 30>
Encapsulació es defineix com l'embolcall de dades en una sola unitat. És el mecanisme que uneix el codi i les dades que manipula. Una altra manera de pensar en l'encapsulació és que es tracta d'un escut protector que impedeix que el codi accedeixi a les dades fora d'aquest escut.
- Tècnicament en l'encapsulació, les variables o dades d'una classe s'oculten de qualsevol altra classe i només es pot accedir a través de qualsevol funció membre de la seva pròpia classe en què es declari.
- Com en l'encapsulació, les dades d'una classe s'oculten d'altres classes utilitzant el concepte d'ocultació de dades que s'aconsegueix fent privats els membres o mètodes d'una classe, i la classe s'exposa a l'usuari final o al món sense proporcionar cap detall. darrere de la implementació utilitzant el concepte d'abstracció, per la qual cosa també es coneix com a combinació d'abstracció i ocultació de dades .
- L'encapsulació es pot aconseguir declarant totes les variables de la classe com a privades i escrivint mètodes públics a la classe per establir i obtenir els valors de les variables.
- Es defineix més amb el mètode setter i getter.
Avantatges de l'encapsulació
- Ocultació de dades: és una manera de restringir l'accés dels nostres membres de dades ocultant els detalls de la implementació. L'encapsulació també ofereix una manera d'amagar les dades. L'usuari no tindrà ni idea de la implementació interna de la classe. No serà visible per a l'usuari com la classe emmagatzema els valors a les variables. L'usuari només sabrà que estem passant els valors a un mètode setter i que les variables s'inicialitzen amb aquest valor.
- Augment de la flexibilitat: Podem fer que les variables de la classe siguin només de lectura o només d'escriptura segons els nostres requisits. Si volem que les variables siguin només de lectura, hem d'ometre els mètodes de configuració com setName(), setAge(), etc. del programa anterior o si volem que les variables siguin només d'escriptura, hem d'ometre el obtenir mètodes com getName(), getAge(), etc. del programa anterior
- Reutilitzabilitat: L'encapsulació també millora la reutilització i és fàcil de canviar amb nous requisits.
- Prova el codi és fàcil: El codi encapsulat és fàcil de provar per a les proves d'unitat.
- Llibertat per al programador en la implementació dels detalls del sistema: Aquest és un dels principals avantatges de l'encapsulació que dóna llibertat al programador per implementar els detalls d'un sistema. L'única limitació del programador és mantenir la interfície abstracta que veuen els estrangers.
Per exemple: El programador del codi del menú d'edició en una GUI d'editor de text podria, al principi, implementar les operacions de retallar i enganxar copiant imatges de pantalla reals dins i fora d'un buffer extern. Més endavant, pot estar insatisfet amb aquesta implementació, ja que no permet l'emmagatzematge compacte de la selecció, i no distingeix els objectes de text i gràfics. Si el programador ha dissenyat la interfície de retallar i enganxar tenint en compte l'encapsulació, canviar la implementació subjacent a una que emmagatzemi text com a text i objectes gràfics en un format compacte adequat no hauria de causar cap problema a les funcions que necessiten connectar-se amb aquesta GUI. . Així, l'encapsulació produeix adaptabilitat, ja que permet que els detalls d'implementació de parts d'un programa canviïn sense afectar negativament altres parts.
Desavantatges de l'encapsulació a Java
- Pot augmentar la complexitat, sobretot si no s'utilitza correctament.
- Pot fer que sigui més difícil entendre com funciona el sistema.
- Pot limitar la flexibilitat de la implementació.
Exemples que mostren l'encapulació de dades a Java
Exemple 1:
A continuació es mostra la implementació del tema anterior:
Java
// 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();> >}> }> |
rudyard kipling si explicació
>
>Sortida
Area: 32>
Exemple 2:
El programa per accedir a les variables de la classe EncapsulateDemo es mostra a continuació:
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);> >}> }> |
>
>Sortida
Geek's name: Harsh Geek's age: 19 Geek's roll: 51>
Exemple 3:
Al programa anterior, la classe Encapsulate s'encapsula ja que les variables es declaren privades. Els mètodes get com getAge(), getName() i getRoll() s'estableixen com a públics, aquests mètodes s'utilitzen per accedir a aquestes variables. Els mètodes setter com setName(), setAge(), setRoll() també es declaren públics i s'utilitzen per establir els valors de les variables.
A continuació es mostra la implementació de l'exemple definit:
Java
// 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());> >}> }> |
substituint la cadena a java
>
>Sortida
The age of the person is: 19>
Exemple 4:
A continuació es mostra la implementació de l'encapsulació de Java:
Java
// 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());> >}> }> |
>
>Sortida
90482098491 ABC [email protected] 100000.0>