Em Java, a forma prática de implementar o Encapsulamento é utilizando os Modificadores de Acesso e os métodos Getters e Setters. Encapsulamento em Java: Exemplo Prático Vamos usar um exemplo de uma classe Produto onde queremos garantir que o preço nunca seja negativo.

1. Restringir Acesso aos Atributos (private) Tornamos os atributos privados para que eles não possam ser acessados ou modificados diretamente de fora da classe. public class Produto { // 1. Atributos Privados: Oculta os detalhes internos. private String nome; private double preco;

   public Produto(String nome, double preco) { this.nome = nome; // O construtor geralmente usa o setter para garantir a validação inicial. this.setPreco(preco); }

   // ... (Métodos Getter e Setter abaixo) }

2. Fornecer uma Interface Controlada (public Getters e Setters) Criamos métodos públicos (a interface controlada) que permitem a leitura e escrita dos atributos, mas aplicamos a lógica de validação dentro dos Setters. // Continuação da classe Produto

   // 2. Getter (Interface para LEITURA): // Permite que o mundo exterior "leia" o valor do atributo. public double getPreco() { return this.preco; }

   // 3. Setter (Interface para ESCRITA com CONTROLE): // Permite que o mundo exterior "escreva" o valor do atributo, // mas SOMENTE se a lógica de validação for atendida. public void setPreco(double novoPreco) { if (novoPreco > 0) { // Lógica de validação: O PREÇO DEVE SER POSITIVO this.preco = novoPreco; System.out.println("Preço definido com sucesso para: R$" + this.preco); } else { System.err.println("ERRO: O preço deve ser um valor positivo. Preço não alterado."); } }

   // Getter para o nome (simples, sem validação) public String getNome() { return nome; } }

Demonstração (Classe Main) Veja como o encapsulamento protege o atributo preco: public class Main { public static void main(String[] args) { Produto livro = new Produto("Java Básico", 50.0);

    // 1. Tentativa de ACESSO DIRETO (BLOQUEADA pelo 'private')
    // livro.preco = -10.0; // Isso resultaria em ERRO de compilação!

    // 2. Acesso CONTROLADO (via Setter)
    livro.setPreco(65.99); // Sucesso: Preço alterado

    // 3. Tentativa de alterar para um valor INVÁLIDO (Bloqueada pelo controle do Setter)
    livro.setPreco(-5.0); // ERRO: O preço deve ser um valor positivo. Preço não alterado.

    // 4. Leitura CONTROLADA (via Getter)
    System.out.println("Preço atual do " + livro.getNome() + ": R$" + livro.getPreco());
    // Saída: Preço atual do Java Básico: R$65.99
}

}

Vantagens do Encapsulamento

• Consistência e Integridade: Garante que os dados internos do objeto (como o preço) permaneçam em um estado válido.
• Segurança: Impede que outras partes do código modifiquem o estado interno de forma arbitrária.
• Manutenção: Se a regra de validação do preço mudar (ex: "preço deve ser múltiplo de 5"), você só precisa alterar a lógica no método setPreco(), sem afetar o código que o utiliza.
• Flexibilidade (Ocultação de Informação): Você pode alterar a estrutura interna da classe (ex: mudar o atributo preco de double para BigDecimal) sem que o código que chama getPreco() precise ser modificado.