1. Ocultación de datos: El núcleo de la encapsulación está ocultando el estado interno (datos) de un objeto del acceso directo por código exterior. Esto se logra a través de modificadores de acceso (como `privado`, 'protegido' y` público 'en muchos idiomas).
* Privado: Los miembros declarados como 'privados' solo son accesibles desde la clase misma. Ningún código externo, incluso código dentro de la misma aplicación, puede manipular directamente a estos miembros privados. Este es el nivel más fuerte de encapsulación.
* Protegido: Los miembros declarados como 'protegidos' son accesibles desde la clase misma y de las subclases (clases heredadas). Esto permite el acceso controlado desde las clases derivadas mientras sigue protegiendo los datos de partes no relacionadas de la aplicación.
* público: Los miembros declarados como "público" son accesibles desde cualquier lugar del programa. Esto no ofrece protección y debe usarse con moderación. A menudo, los miembros públicos representan interfaces:vías para que el código externo interactúe con el objeto sin tocar directamente sus datos internos.
2. Métodos como guardianes: En lugar de acceder directamente a los datos privados, el código externo interactúa con el objeto a través de sus métodos públicos. Estos métodos actúan como guardianes, controlando cómo se accede y modifica los datos.
`` `Java
perro de clase pública {
nombre de cadena privada; // datos encapsulados
edad privada int; // datos encapsulados
Public Dog (Nombre de cadena, Int Age) {
this.name =name;
this.age =edad;
}
Public String getName () {// Método Getter
nombre de retorno;
}
Public void setAGE (int age) {// método setter
if (edad> =0) {// Validación de entrada
this.age =edad;
} demás {
System.out.println ("edad inválida");
}
}
public void bark () {// método que funciona en datos
System.out.println (nombre + "dice Woof!");
}
}
clase pública Main {
public static void main (string [] args) {
Perro mydog =nuevo perro ("amigo", 3);
System.out.println (myDog.getName ()); // Acceso a datos a través de un Getter
mydog.setage (4); // modificando datos a través de un setter
mydog.setage (-1); // Ejemplo de validación de entrada
MyDog.Bark ();
}
}
`` `` ``
En este ejemplo, `Name` y` Age` son privados, evitando la modificación directa. El código externo solo puede acceder o cambiarlos a través de los métodos `getName ()` y `setage ()`. El método `setage ()` también proporciona validación de entrada, asegurando que la edad no sea negativa.
Beneficios de la encapsulación:
* Integridad de datos: Previene la corrupción accidental o intencional de los datos.
* Mantenimiento del código: Los cambios en la implementación interna de una clase no afectan el código externo siempre que la interfaz pública siga siendo consistente.
* Reutilización: Las clases encapsuladas son más fáciles de reutilizar en diferentes partes de la aplicación o en otros proyectos.
* Seguridad: Protege los datos confidenciales del acceso no autorizado.
* Modularidad: Promueve el diseño modular, lo que hace que el código sea más organizado y más fácil de entender.
En esencia, la encapsulación protege el funcionamiento interno de un objeto, mejorando la confiabilidad del código, la mantenibilidad y la seguridad controlando el acceso a sus datos y métodos. Es una piedra angular de software bien estructurado y robusto.