No meu sistema de cadastro de livros eu preciso do nome e do preço:
public class Livro {
private final String nome;
private final double preco;
public Livro(String nome, double preco) {
this.nome = nome;
this.preco = preco;
}
//métodos
}
Para cadastrar um livro eu preciso passar as informações e enviar para o banco de dados:
Livro livro = new Livro("Java", 27.83);
Conexao conexao = pegaConexaoComOBancoDeDados();
conexao.cadastraLivro(livro);
conexao.fechaConexao();
Todas as vezes que eu quiser cadastrar um livro eu terei que instanciá-lo, pegar uma conexão, salvar o livro e fechar a conexão. Vamos supor que agora nós precisamos verificar se o livro já existe no banco e, caso exista, precisamos atualizar em vez de salvar:
Livro livro = new Livro("Java", 27.83);
Conexao conexao = pegaConexaoComOBancoDeDados();
if(!conexao.existeLivro(livro)){
conexao.cadastraLivro(livro);
} else{
conexao.atualizaLivro(livro);
}
conexao.fechaConexao();
Quanto mais procedimentos para poder salvar o livro eu precisar, maior ficará a minha rotina de salvar livros. Imagine todas as classes que precisarem salvar um livro, terão que ser atualizadas todas as vezes que houver uma mudança! É uma péssima solução... Que tal mudarmos esse procedimento de salvar o livro para um único método? Então, ficaria:
Livro livro = new Livro("Java", 27.83);
salvaLivro(livro);
public void salvaLivro(Livro livro){
Conexao conexao = pegaConexaoComOBancoDeDados();
if(!conexao.existeLivro(livro)){
conexao.cadastraLivro(livro);
} else{
conexao.atualizaLivro(livro);
}
conexao.fechaConexao();
}
Agora não precisamos saber sobre conexão ou qualquer procedimento para salvar um livro, apenas chamamos o método salvaLivro(), enviamos o livro, e ele faz tudo por nós! Quando transformamos um procedimento que apresenta muitas regras de negócio ou rotinas complexas em um método, chamamos isso de encapsulamento. E se tivermos que fazer um backup dos livros cada vez que salvar ou atualizar? Bastaria adicionar esse trecho em um único lugar, ou seja, no método salvaLivro():
//continuo usando o salvaLivro() do mesmo jeito salvaLivro(livro);
public void salvaLivro(Livro livro){
//rotina para salvar livro
conexao.fazBackupDoLivro();
conexao.fechaConexao(); }
O código mudou e continuamos utilizando o método sem nenhuma preocupação se ele mudou ou não! Além disso, o código foi modificado em apenas um lugar, ou seja, não precisamos nos preocupar se vai quebrar o nosso sistema em todos os outros lugares que usam esse método! Além de ser mais elegante, torna o nosso sistema manutenível.
É sempre importante verificar em todos os pontos do código aonde é possível aplicar o encapsulamento, pois ganhamos muitos benefícios:
- Melhor manutenção de código.
- Divisão de responsabilidades.
- Reutilização de código.
E aí, gostou do encapsulamento? Está pronto para analisar o seu código e verificar aonde ele pode ser aplicado? O encapsulamento faz parte de uma das boas práticas de refatoração de código onde é apresentado detalhadamente no curso de Refatorando na prática com Java, que demonstra como fazer manutenção em um sistema com um código de qualidade utilizando as boas práticas de refatoração.
