¿Qué es la encapsulación?
La encapsulación en Java consiste en mantener ocultos los detalles de cómo funciona algo y al mismo tiempo permitir que otros lo utilicen. Agrupa sus datos (como variables) y métodos (como funciones) en una unidad, llamada clase. En lugar de permitir que todos accedan directamente a sus datos, usted proporciona métodos (captadores y configuradores) para controlar cómo se accede a ellos o cómo se modifican. De esta manera, proteges tus datos y mantienes tu código limpio y organizado, sin permitir que nadie se meta con el funcionamiento interno a menos que tú lo desees.

Cómo usarlo
Para usar la encapsulación en Java, crea una clase con campos privados y proporciona métodos públicos (como captadores y definidores) para acceder y modificar esos campos. Esto garantiza que los datos sólo puedan modificarse de forma controlada. Por ejemplo, si desea crear una clase Persona donde el nombre y la edad sean privados, usaría captadores para recuperar los valores y definidores para actualizarlos. Así es como puedes hacerlo:

public class Person {
    // Private fields
    private String name;
    private int age;

    // Constructor
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // Getter for name
    public String getName() {
        return name;
    }

    // Setter for name
    public void setName(String name) {
        this.name = name;
    }

    // Getter for age
    public int getAge() {
        return age;
    }

    // Setter for age
    public void setAge(int age) {
        if(age > 0) { // Simple validation
            this.age = age;
        } else {
            System.out.println("Age must be positive.");
        }
    }
}

// Using the Person class
public class Main {
    public static void main(String[] args) {
        Person person = new Person("John", 25);

        // Accessing fields using getters
        System.out.println(person.getName()); // Output: John
        System.out.println(person.getAge());  // Output: 25

        // Modifying fields using setters
        person.setName("Jane");
        person.setAge(30);

        System.out.println(person.getName()); // Output: Jane
        System.out.println(person.getAge());  // Output: 30
    }
}

Vamos a desglosarlo
Analicemos el código y expliquemos cada sección paso a paso:

1. Definición de clase con campos privados

public class Person {
    // Private fields
    private String name;
    private int age;
}

Explicación:

Esta es la clase Persona donde definimos dos campos privados: nombre (un String) y edad (un int). Al hacer que estos campos sean privados, nos aseguramos de que ninguna otra clase pueda acceder a ellos o modificarlos directamente. Esta es la idea central de la encapsulación: ocultar el estado interno de un objeto.

2. Constructor

    // Constructor
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

Explicación:

El constructor inicializa el objeto Persona cuando se crea. Toma dos parámetros, nombre y edad, y asigna estos valores a los campos privados. Esto garantiza que cuando se crea un nuevo objeto Persona, comience con datos válidos.

3. Getter y Setter para

    // Getter for name
    public String getName() {
        return name;
    }

    // Setter for name
    public void setName(String name) {
        this.name = name;
    }

Explicación:

El constructor inicializa el objeto Persona cuando se crea. Toma dos parámetros, nombre y edad, y asigna estos valores a los campos privados. Esto garantiza que cuando se crea un nuevo objeto Persona, comience con datos válidos.

4. Getter y Setter por edad (con validación)

    // Getter for age
    public int getAge() {
        return age;
    }

    // Setter for age
    public void setAge(int age) {
        if (age > 0) { // Simple validation
            this.age = age;
        } else {
            System.out.println("Age must be positive.");
        }
    }

Explicación:

El getter getAge() funciona de la misma manera que el de nombre, permitiendo el acceso al campo de edad.
El configurador setAge() no solo permite la modificación del campo de edad sino que también agrega una verificación de validación. La condición if garantiza que la edad solo se establezca si es un número positivo. Si se proporciona una edad no válida (como un número negativo), el configurador impide la actualización e imprime un mensaje en su lugar. Este es un ejemplo de cómo la encapsulación le permite controlar qué tipo de datos se pueden configurar.

5. Usando la clase de persona

// Using the Person class
public class Main {
    public static void main(String[] args) {
        Person person = new Person("John", 25);

        // Accessing fields using getters
        System.out.println(person.getName()); // Output: John
        System.out.println(person.getAge());  // Output: 25

        // Modifying fields using setters
        person.setName("Jane");
        person.setAge(30);

        System.out.println(person.getName()); // Output: Jane
        System.out.println(person.getAge());  // Output: 30
    }
}

Explicación:

En esta sección, creamos un objeto Persona (persona) usando el constructor. El constructor establece el nombre inicial como "John" y la edad como 25.

Luego, usamos los captadores (getName() y getAge()) para imprimir los valores de nombre y edad. Después de eso, usamos los configuradores (setName() y setAge()) para actualizar los valores. Finalmente, los valores actualizados se imprimen usando los captadores nuevamente.

Puntos clave de la encapsulación en acción:

• Protección de datos:

  No se puede acceder ni modificar directamente los campos privados desde fuera de la clase.

• Acceso controlado:

  Los captadores y definidores proporcionan una forma controlada de acceder y modificar los campos privados.

• Validación:

  El definidor de edad demuestra cómo se pueden aplicar reglas (por ejemplo, la edad debe ser positiva) para proteger los datos contra entradas no válidas.