Um pouco sobre encapsulamento: Entendendo modificadores de Acesso em Java

No desenvolvimento de sistemas robustos, a visibilidade de cada componente é uma decisão arquitetural crítica. Como desenvolvedores, utilizamos os Modificadores de Acesso para aplicar o princípio do encapsulamento, garantindo que o estado interno de um objeto seja protegido contra manipulações indevidas.

Em Java, temos quatro níveis de acesso: private, default (sem palavra-chave), protected e public.

Eles funcionam como camadas de segurança que definem quem pode ler ou alterar um dado.

Sem eles, o acoplamento cresce e a manutenção se torna um pesadelo.

Vamos entender essa hierarquia construindo um sistema bancário simplificado.

Modificadores na Prática

O Nível Mais Restritivo (private)

O modificador private limita o acesso apenas à própria classe. É a regra de ouro para atributos: proteja seus dados.

public class ContaBancaria {
  private double saldo; // Ninguém fora desta classe toca aqui


  private boolean validarValor(double valor) { // Método auxiliar interno
      return valor > 0;
  }


  public void depositar(double valor) {
      if (validarValor(valor)) this.saldo += valor;
  }
}

O Acesso de Pacote (default)

Quando não definimos um modificador, o Java aplica o package-private. O membro é visível apenas para classes no mesmo pacote.

public class ContaBancaria {
  protected double saldo; // Agora subclasses podem ver


  protected void aplicarTaxa() {
      this.saldo -= 5.0;
  }
}

Acesso via Herança (protected)

O protected permite que o membro seja visto no mesmo pacote e também por subclasses, mesmo que estejam em pacotes diferentes.

public class ContaBancaria {
  protected double saldo; // Agora subclasses podem ver


  protected void aplicarTaxa() {
      this.saldo -= 5.0;
  }
}

Criando uma Especialização

Aqui, a ContaPoupanca (em outro pacote) acessa o saldo e o método aplicarTaxa graças ao modificador protected.

public class ContaPoupanca extends ContaBancaria {
  public void atualizarRendimento(double taxa) {
      this.saldo += this.saldo * taxa; // Acesso direto permitido via herança
      this.aplicarTaxa();
  }
}

A Interface Pública (public)

O modificador public torna o membro visível para qualquer classe em qualquer lugar do projeto. É a sua "API" de comunicação.

public class Banco {
  public static void main(String[] args) {
      ContaBancaria conta = new ContaBancaria();
      conta.depositar(500.0); // Método público acessível globalmente
      System.out.println("Operação realizada com sucesso.");
  }
}

O Erro de Compilação (Segurança)

Tentar burlar as regras de acesso impede que o código seja compilado, protegendo a integridade do sistema.

public class Auditoria {
  public void verificar(ContaBancaria c) {
      // c.saldo = 1000000; // ERRO: saldo tem acesso private ou protected
      // c.validarValor(10); // ERRO: método é private
  }
}

Encapsulamento Completo

A boa prática dita: oculte tudo, exponha o mínimo. Use métodos públicos para controlar o acesso ao private.

public class ContaFinal {
  private double saldo;
  private static int totalContas; // Static para controle da classe


  public void sacar(double valor) {
      if (valor <= saldo) saldo -= valor;
  }


  public double getSaldo() { return saldo; } // Getter público
  public static int getTotalContas() { return totalContas; }
}

Conclusão

Modificadores de acesso não são apenas sintaxe; são ferramentas de design.

Ao restringir o acesso, você reduz efeitos colaterais e torna o código testável.

Comece sempre com private e suba o nível de exposição apenas quando houver uma necessidade clara e justificada.

Mão na Massa! 🚀

Teoria sem prática é esquecimento. Para fixar esses conceitos, tente executar o projeto abaixo:

1. Projeto Biblioteca: Crie três classes: Livro, Usuario e Emprestimo.
2. Encapsule: Garanta que o Livro tenha atributos privados e que a devolução só ocorra através de um método público que valide a data.
3. Organize: Coloque as classes em pacotes diferentes (model, service) para testar o comportamento do protected e do default.
4. Evolua: Estude como os modificadores interagem com o static e tente implementar um contador global de livros.

Dica: Tente escrever um teste unitário para sua classe. Se você sentir dificuldade em acessar o que precisa para testar, seu design pode estar restritivo demais ou mal organizado.

Bons estudos!