O que é encapsulamento?
O encapsulamento em Java consiste em manter ocultos os detalhes de como algo funciona e, ao mesmo tempo, permitir que outros o utilizem. Você agrupa seus dados (como variáveis) e métodos (como funções) em uma unidade, chamada classe. Em vez de permitir que todos acessem diretamente seus dados, você fornece métodos (getters e setters) para controlar como eles são acessados ​​ou alterados. Dessa forma, você protege seus dados e mantém seu código limpo e organizado, sem deixar ninguém mexer no funcionamento interno, a menos que você queira.

Como usar
Para usar o encapsulamento em Java, você cria uma classe com campos privados e fornece métodos públicos (como getters e setters) para acessar e modificar esses campos. Isso garante que os dados só possam ser alterados de forma controlada. Por exemplo, se você quiser criar uma classe Person onde o nome e a idade sejam privados, você usaria getters para recuperar os valores e setters para atualizá-los. Veja como você pode fazer isso:

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 decompô-lo
Vamos decompor o código e explicar cada seção passo a passo:

1. Definição de Classe com Campos Privados

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

Explicação:

Esta é a classe Person onde definimos dois campos privados: nome (uma String) e idade (um int). Ao tornar esses campos privados, garantimos que nenhuma outra classe possa acessá-los ou modificá-los diretamente. Esta é a ideia central do encapsulamento - ocultar o estado interno de um objeto.

2. Construtor

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

Explicação:

O construtor inicializa o objeto Person quando ele é criado. São necessários dois parâmetros, nome e idade, e atribui esses valores aos campos privados. Isso garante que quando um novo objeto Person for criado, ele comece com dados válidos.

3. Getter e Setter para

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

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

Explicação:

O construtor inicializa o objeto Person quando ele é criado. São necessários dois parâmetros, nome e idade, e atribui esses valores aos campos privados. Isso garante que quando um novo objeto Person for criado, ele comece com dados válidos.

4. Getter e Setter por idade (com validação)

    // 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.");
        }
    }

Explicação:

O getter getAge() funciona da mesma forma que o do nome, permitindo acesso ao campo idade.
O setter setAge() não apenas permite a modificação do campo idade, mas também adiciona uma verificação de validação. A condição if garante que a idade só seja definida se for um número positivo. Se uma idade inválida for fornecida (como um número negativo), o setter impede a atualização e imprime uma mensagem. Este é um exemplo de como o encapsulamento permite controlar que tipo de dados podem ser definidos.

5. Usando a classe Person

// 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
    }
}

Explicação:

Nesta seção, criamos um objeto Person (pessoa) usando o construtor. O construtor define o nome inicial como "John" e a idade como 25.

Então, usamos os getters (getName() e getAge()) para imprimir os valores de nome e idade. Depois disso, usamos os setters (setName() e setAge()) para atualizar os valores. Finalmente, os valores atualizados são impressos usando os getters novamente.

Principais pontos de encapsulamento em ação:

• Proteção de dados:

  Os campos privados não podem ser acessados ​​ou modificados diretamente de fora da classe.

• Acesso controlado:

  Getters e setters fornecem uma maneira controlada de acessar e modificar os campos privados.

• Validação:

  O configurador de idade demonstra como você pode aplicar regras (por exemplo, a idade deve ser positiva) para proteger os dados contra entradas inválidas.