La encapsulación en Java es un concepto fundamental en la programación orientada a objetos (POO) que se refiere a la agrupación de datos y métodos que operan sobre esos datos dentro de una sola unidad, que se denomina clase en Java. La encapsulación de Java es una forma de ocultar los detalles de implementación de una clase al acceso externo y solo exponer una interfaz pública que se puede usar para interactuar con la clase.
En Java, la encapsulación se logra declarando las variables de instancia de una clase como privadas, lo que significa que solo se puede acceder a ellas dentro de la clase. Para permitir el acceso externo a las variables de instancia, se definen métodos públicos llamados getters y setters, que se utilizan para recuperar y modificar los valores de las variables de instancia, respectivamente. Al utilizar captadores y definidores, la clase puede imponer sus propias reglas de validación de datos y garantizar que su estado interno siga siendo coherente.
Implementación de la encapsulación de Java
A continuación se muestra el ejemplo con encapsulación de Java:
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());> >}> }> |
>
>Producción
Name: John Age: 30>
Encapsulación Se define como la agrupación de datos en una sola unidad. Es el mecanismo que une el código y los datos que manipula. Otra forma de pensar en la encapsulación es que es un escudo protector que evita que el código fuera de este escudo acceda a los datos.
- Técnicamente en encapsulación, las variables o datos de una clase están ocultos de cualquier otra clase y solo se puede acceder a ellos a través de cualquier función miembro de su propia clase en la que están declaradas.
- Al igual que en la encapsulación, los datos de una clase se ocultan de otras clases utilizando el concepto de ocultación de datos que se logra haciendo que los miembros o métodos de una clase sean privados, y la clase se expone al usuario final o al mundo sin proporcionar ningún detalle. detrás de la implementación utilizando el concepto de abstracción, por lo que también se conoce como combinación de ocultación de datos y abstracción .
- La encapsulación se puede lograr declarando todas las variables de la clase como privadas y escribiendo métodos públicos en la clase para establecer y obtener los valores de las variables.
- Está más definido con el método setter y getter.
Ventajas de la encapsulación
- Ocultación de datos: es una forma de restringir el acceso de nuestros miembros a los datos ocultando los detalles de implementación. La encapsulación también proporciona una forma de ocultar datos. El usuario no tendrá idea acerca de la implementación interna de la clase. El usuario no podrá ver cómo la clase almacena valores en las variables. El usuario solo sabrá que estamos pasando los valores a un método de establecimiento y que las variables se inicializan con ese valor.
- Mayor flexibilidad: Podemos hacer que las variables de la clase sean de solo lectura o de solo escritura según nuestros requisitos. Si deseamos que las variables sean de solo lectura, entonces tenemos que omitir los métodos de configuración como setName(), setAge(), etc. del programa anterior o si deseamos que las variables sean de solo escritura, entonces tenemos que omitir el obtener métodos como getName(), getAge(), etc. del programa anterior
- Reutilizabilidad: La encapsulación también mejora la reutilización y es fácil de cambiar según nuevos requisitos.
- Probar el código es fácil: El código encapsulado es fácil de probar para pruebas unitarias.
- Libertad para el programador en la implementación de los detalles del sistema: Esta es una de las principales ventajas de la encapsulación: le da al programador libertad para implementar los detalles de un sistema. La única limitación para el programador es mantener la interfaz abstracta que ven los externos.
Por ejemplo: El programador del código del menú de edición en una GUI de editor de texto podría, al principio, implementar las operaciones de cortar y pegar copiando imágenes de pantalla reales dentro y fuera de un búfer externo. Posteriormente, puede que no esté satisfecho con esta implementación, ya que no permite el almacenamiento compacto de la selección y no distingue entre objetos textuales y gráficos. Si el programador ha diseñado la interfaz de cortar y pegar teniendo en cuenta la encapsulación, cambiar la implementación subyacente a una que almacene texto como texto y objetos gráficos en un formato compacto apropiado no debería causar ningún problema a las funciones que necesitan interactuar con esta GUI. . Por tanto, la encapsulación produce adaptabilidad, ya que permite que los detalles de implementación de partes de un programa cambien sin afectar negativamente a otras partes.
Desventajas de la encapsulación en Java
- Puede conducir a una mayor complejidad, especialmente si no se utiliza correctamente.
- Puede hacer que sea más difícil entender cómo funciona el sistema.
- Puede limitar la flexibilidad de la implementación.
Ejemplos que muestran la encapsulación de datos en Java
Ejemplo 1:
A continuación se muestra la implementación 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();> >}> }> |
>
>Producción
Area: 32>
Ejemplo 2:
El programa para acceder a variables de la clase EncapsulateDemo se muestra a continuación:
Java
palíndromo en 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);> >}> }> |
>
>Producción
Geek's name: Harsh Geek's age: 19 Geek's roll: 51>
Ejemplo 3:
En el programa anterior, la clase Encapsulate se encapsula ya que las variables se declaran privadas. Los métodos get como getAge(), getName() y getRoll() se configuran como públicos y estos métodos se utilizan para acceder a estas variables. Los métodos de establecimiento como setName(), setAge(), setRoll() también se declaran como públicos y se utilizan para establecer los valores de las variables.
A continuación se muestra la implementación del ejemplo definido:
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());> >}> }> |
>
>Producción
The age of the person is: 19>
Ejemplo 4:
A continuación se muestra la implementación de la encapsulación de Java:
burak ozcivit
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());> >}> }> |
>
>Producción
90482098491 ABC [email protected] 100000.0>