Técnicas de Refactoring

Técnicas de Refactoring
Rodrigo Branas – @rodrigobranas - http://www.agilecode.com.br

“Transformar equipes de desenvolvimento de software”
http://www.agilecode.com.br

Rodrigo Branas
rodrigo.branas@agilecode.com.br
http://www.agilecode.com.br
• Desenvolvendo Software na Gennera
• Criando treinamentos na Agile Code
• Escrevendo na Java Magazine e PacktPub
• Palestrando sobre desenvolvimento de
software em eventos, universidades e
empresas

Certificações
Formação Acadêmica
Ciências da Computação – UFSC
Gerenciamento de Projetos - FGV
SCJA, SCJP, SCJD, SCWCD, SCBCD, PMP, MCP e CSM
Experiência
Há mais de 12 anos desenvolvendo software na
plataforma Java com as empresas: EDS, HP, NET,
Citibank, GM, Dígitro, Softplan, OnCast, Senai,
VALE, RBS, Unimed, Globalcode, V.Office, Suntech,
WPlex e Gennera.

• Há mais de 5 anos liderando pessoas.
• Mais de 2000 horas em sala de aula.
• Mais de 100 apresentações em eventos.
• 6 artigos escritos para revistas.
• 1 livro.
• Mais de 500 profissionais treinados.
• Criação de 22 palestras.
• Criação de 10 treinamentos.
• Criação de mais de 3.000 slides.

Existe um fragmento de código que
poderia ser agrupado para tornar a
lógica mais fácil de ser entendida.
Transforme esse fragmento em um
método cujo nome explique o
propósito do mesmo.

1. public void exibirExtrato(Periodo periodo) {
2. // imprimir cabeçalho
3. System.out.println(“--------------------------------”);
4. System.out.println(“EXTRATO – SANTANDER”);
6. // imprimir detalhes
7. System.out.println(“NOME:” + nomeDoCliente);
8. for(Lancto lancto : getLanctos(periodo)) {
9. System.out.println(lancto);
10. }
11. System.out.println(“SALDO:” + saldoTotal);
12. // imprimir rodapé
14. System.out.println(getDataEHoraAtual());
15. }

3.
8. }
13. }

3. imprimirCabecalho();
8. }
13. }

5.
9. }

5. imprimirDetalhes(periodo);
9. }

7.
8. }

7. imprimirRodape();
8. }

2.
4.
6.
8. }

5. }

Atalho do Eclipse:
Shift + Alt + M

O corpo do método é tão claro
quanto seu nome.
Coloque o corpo do método
dentro do corpo do que o chama
e remova o método.

1. int lerAvaliacao( ) {
2. return (maisDeCincoAtrasos()) ? 2 : 1;
3. }
4.
5. boolean maisDeCincoAtrasos() {
6. return numeroDeAtrasos > 5;
7. }

2. return () ? 2 : 1;
3. }
4.
7. }

2. return (numeroDeAtrasos > 5) ? 2 : 1;
3. }
4.
7. }

2. return (numeroDeAtrasos > 5) ? 2 : 1;
3. }

Atalho do Eclipse:
Shift + Alt + I

Internalizar Variável
Temporária

Você tem uma variável temporária
que recebe uma única atribuição de
uma expressão simples.
Substitua todas as referências a
essa variável temporária pela
expressão.

1. boolean produtoCaro() {
2. double preco = pedido.getPreco();
3. return preco > 1000;
4. }

3. return > 1000;
4. }

3. return pedido.getPreco() > 1000;
4. }

2. return pedido.getPreco() > 1000;
3. }

Introduzir Variável
Explicativa

Você tem uma expressão
complicada.
Coloque a expressão, ou partes dela,
em uma variável temporária cujo único
objetivo é explicar o seu propósito.

1. double calculaValorDaCorrida() {
2. if (hora > 22:00 || hora < 06:00) {
3. return distancia * 3.90;
4. } else {
6. }
7. }

2. if () {
4. } else {
6. }
7. }

2. if (bandeiraDois) {
4. } else {
6. }
7. }

2. boolean bandeiraDois = hora > 22:00 || hora < 06:00;
3. if (bandeiraDois) {
5. } else {
7. }
8. }

Atalho do Eclipse:
Shift + Alt + L

Alternativa
Também é interessante optar por uma
extração de método para aumentar a
possibilidade de reuso.

2. if (bandeiraDois()) {
4. } else {
6. }
7. }

2. if (bandeiraDois()) {
4. } else {
6. }
7. }
8. boolean bandeiraDois() {
9. return hora > 22:00 || hora < 06:00;
10. }

Você tem uma variável temporária
que mais de uma vez, recebe uma
atribuição.
Crie uma variável temporária para cada
atribuição.

1. public class PoteDeWhey {
2. int pesoDoPote;
3. int pesoDaDose;
4. int proteinasPorDose;
5.
6. double calcularPrecoPorProteina(double precoPote) {
7. double temp = pesoDoPote / pesoDaDose;
8. temp = temp * proteinasPorDose;
9. temp = precoPote/temp;
10. return temp;
11. }
12. }

2. int pesoDoPote;
3. int pesoDaDose;
5.
7. double = pesoDoPote / pesoDaDose;
8. temp = * proteinasPorDose;
10. return temp;
11. }
12. }

2. int pesoDoPote;
3. int pesoDaDose;
5.
7. double doses = pesoDoPote / pesoDaDose;
8. temp = doses * proteinasPorDose;
10. return temp;
11. }
12. }

2. int pesoDoPote;
3. int pesoDaDose;
5.
8. = doses * proteinasPorDose;
9. temp = precoPote/;
10. return temp;
11. }
12. }

2. int pesoDoPote;
3. int pesoDaDose;
5.
8. double proteinas = doses * proteinasPorDose;
9. temp = precoPote/proteinas;
10. return temp;
11. }
12. }

2. int pesoDoPote;
3. int pesoDaDose;
5.
9. = precoPote/proteinas;
10. return;
11. }
12. }

2. int pesoDoPote;
3. int pesoDaDose;
5.
9. double precoPorProteina = precoPote/proteinas;
10. return precoPorProteina;
11. }
12. }

2. int pesoDoPote;
3. int pesoDaDose;
5.
7. return getDoses()/getTotalProteinas();
8. }

Atalho do Eclipse:
Shift + Alt + R

Remover Atribuições a
Parâmetros

O código faz atribuições a
parâmetros.
Utilize uma variável temporária no lugar
da atribuição

1. void desconto(Carrinho carrinho) {
2. if (carrinho.getQuantidadeDeProdutos() > 50) {
3. carrinho.setDesconto(0.10);
4. }
5. }

1. desconto(Carrinho carrinho) {
4. }
5. }

1. double desconto(Carrinho carrinho) {
4. }
5. }

3.
4. }
5. }

3. return 0.10;
4. }
5. }

3. return 0.10;
4. }
5.
6. }

3. return 0.10;
4. }
5. return 0.0;
6. }

Substituir Números
Mágicos por Constantes

Você tem um número literal com um
significado especial.
Crie uma constante, nomeie-a de
acordo com seu significado e substitua
o número por ela.

1. public class Fisica {
2.
3. double energiaPotencial(double massa, double altura) {
4. return massa * 9.81 * altura;
5. }
6.
7. }

2.
4. return massa * * altura;
5. }
6.
7. }

2.
4. return massa * GRAVIDADE * altura;
5. }
6.
7. }

2. public static final double GRAVIDADE = 9.81;
4. return massa * GRAVIDADE * altura;
5. }
6.
7. }

Eclipse:
Ctrl + 3, Extract Constant

O nome de um método não está
revelando seu propósito.
Altere o nome do método.

1. public void processar() {
2. // Código para processar
3. }

1. public void () {
2. // Código para processar
3. }

1. public void processarFolhaDePagamento() {
2. // Código para processar folha de pagamento
3. }

Você está lendo diverso valores de um
objeto e passando esses valores como
parâmetros em uma chamada de
método.
Em vez de fazer isso, envie o
objeto inteiro.

1. public class Boletim {
2. public void renderizarMedia() {
3. int nota1 = notasParciais.getNota1();
7. double media = calcularMedia(nota1, nota2, nota3, nota4);
8. }
9. }

E se houver uma modificação que
solicita a inclusão de mais uma nota?

8. double media = calcularMedia(nota1, nota2, nota3, nota4,
nota5);
9. }
10. }

9. double media = calcularMedia(nota1, nota2, nota3, nota4,
nota5, nota6);
10. }
11. }

A tendência é o método crescer...

7. double media = calcularMedia();
8. }
9. }

7. double media = calcularMedia(notasParciais);
8. }
9. }

3. double media = calcularMedia(notasParciais);
4. }
5. }

Cuidado com o HttpServletRequest

Você tem um algoritmo confuso e as
refatorações não estão ajudando.
Substitua o corpo do método por
um novo algoritmo.

Simplificando Expressões
Condicionais

Você tem uma estrutura condicional
complicada.
Extraia métodos para a condição, para
a parte após o then e para a parte após
o else.

2. if (isBandeiraDois()) {
4. } else {
6. }
7. }

3.
4. } else {
6. }
7. }

3. return calcularBandeiraDois(distancia);
4. } else {
6. }
7. }

4. } else {
5.
6. }
7. }

4. } else {
5. return calcularBandeiraUm(distancia);
6. }
7. }

4. }
5. return calcularBandeiraUm(distancia);
6. }

Consolidar Expressão
Condicional

Você tem uma sequência de testes com
o mesmo resultado.
Consolide-os em uma única expressão
e extraia-a.

1. int calcularEntrada(int valor) {
2. if (estudante) {
3. if (temCarteirinha) {
4. if (naoEhFalsa) {
5. return valor * 0.5;
6. }
7. }
8. }
9. return valor;
10. }

2. if (estudante) {
3. if (temCarteirinha) {
4.
6.
7. }
8. }
9. return valor;
10. }

2. if (estudante) {
3. if (temCarteirinha && naoEhFalsa) {
4.
6.
7. }
8. }
9. return valor;
10. }

2. if (estudante) {
3. if (temCarteirinha && naoEhFalsa) {
5. }
6. }
7. return valor;
8. }

2. if (estudante) {
3.
5.
6. }
7. return valor;
8. }

2. if (estudante && temCarteirinha && naoEhFalsa) {
3.
5.
6. }
7. return valor;
8. }

2. if (estudante && temCarteirinha && naoEhFalsa) {
4. }
5. return valor;
6. }

2. if () {
4. }
5. return valor;
6. }

2. if (aptoAPagarMeiaEntrada()) {
4. }
5. return valor;
6. }

2. if (aptoAPagarMeiaEntrada()) {
4. }
5. return valor;
6. }
7.
8. boolean aptoAPagarMeiaEntrada() {
9. return estudante && temCarteirinha && naoEhFalsa;
10. }

2. if (aptoAPagarMeiaEntrada()) return valor * 0.5;
3. return valor;
4. }
5.
6. boolean aptoAPagarMeiaEntrada() {
7. return estudante && temCarteirinha && naoEhFalsa;
8. }

Consolidar Fragmentos
Condicionais Duplicados

O mesmo fragmento de código aparece
duplicado em todos os remos de uma
expressão condicional.
Mova-os para fora da expressão.

1. public void sendRequest(Object data) {
2. if (data == null) {
3. resource.send();
4. } else {
5. resource.setData(data);
6. resource.send();
7. }
8. }

3. } else {
5. }
6. }

3. } else {
5. }
6. resource.send();
7. }

2. if (data != null) {
3. } else {
5. }
6. resource.send();
7. }

2. if (data != null) {
4. }
5. resource.send();
6. }

2. if (data != null) resource.setData(data);
3. resource.send();
4. }

Remover Condição
Aninhada por Cláusulas
Guarda

Um método tem lógica condicional que
não deixa claro o fluxo normal da
execução.
Use cláusulas-guarda para todos os
casos especiais.

1. public boolean fecharCaixa() {
2. if(!caixaFechado) {
3. if(saldo > 0) {
4. if (dataDeAberturaDoCaixa.equals(hoje)) {
5. transferirDinheiroParaContaBancaria(saldo);
6. } else {
7. throw new DataRetroativaException();
8. }
9. } else {
10. throw new SaldoNegativoException();
11. }
12. } else {
13. return true;
14. }
15. }

3. if(saldo > 0) {
6. } else {
8. }
9. } else {
11. }
12. }

3.
4. }
5. if(saldo > 0) {
8. } else {
10. }
11. } else {
13. }
14. }

2. if(caixaFechado) {
3.
4. }
5. if(saldo > 0) {
8. } else {
10. }
11. } else {
13. }
14. }

2. if(caixaFechado) {
3. return true;
4. }
5. if(saldo > 0) {
8. } else {
10. }
11. } else {
13. }
14. }

2. if(caixaFechado) return true;
3. if(saldo > 0) {
6. } else {
8. }
9. } else {
11. }
12. }

3. if(saldo > 0) {
6. } else {
8. }
9. }

3. if(saldo > 0) {
4. }
7. } else {
9. }
10. }

3. if(saldo < 0) {
4. }
7. } else {
9. }
10. }

3. if(saldo < 0) {
5. }
8. } else {
10. }
11. }

3. if(saldo < 0) throw new SaldoNegativoException();
6. } else {
8. }
9. }

6. }

5. }
7. }

4. if (!dataDeAberturaDoCaixa.equals(hoje)) {
5. }
7. }

4. if (!dataDeAberturaDoCaixa.equals(hoje)) {
6. }
8. }

4. if () {
6. }
8. }

4. if (dataRetroativa) {
6. }
8. }

4. if (dataRetroativa) throw new DataRetroativaException();
6. }

Substituir Comando
Condicional por
Polimorfismo

Você tem um comando condicional que
seleciona diferentes comportamentos
de acordo com o tipo de objeto.
Mova cada ramificação do comando
condicional para um método de
sobrescrita em uma subclasse. Torne
abstrato o método original.

1. public void emitirExtrato(String tipo) {
2. if(tipo.equals(“SimplificadoMensal”)) {
3. // Código para emissão do extrato simplificado mensal.
4. } else if(tipo.equals(“SimplificadoQuinzenal”)) {
5. // Código para emissão do extrato simplificado quinzenal.
6. } else if(tipo.equals(“SimplificadoSemanal”)) {
7. // Código para emissão do extrato simplificado semanal.
8. } else if(tipo.equals(“Completo”)) {
9. // Código para emissão do extrato completo.
10. }
11. }

E se houver um novo tipo de extrato?

10. } else if(tipo.equals(“CompletoTrimestral”)) {
11. // Código para emissão do extrato completo trimestral.
12. }
13. }

10. } else if(tipo.equals(“CompletoTrimestral”)) {
11. // Código para emissão do extrato completo trimestral.
12. } else if(tipo.equals(“CompletoAnual”)) {
13. // Código para emissão do extrato completo anual.
14. }
15. }

Este método tende ao infinito...

1. public abstract class Extrato {
2. public abstract void emitir();
3. }
4.
5. public class ExtratoSimplificadoMensal extends Extrato {
6. public void emitir() {
8. }
9. }
10.
11. public class ExtratoCompleto extends Extrato {
12. public void emitir() {
14. }
15. }

2. Extrato.criarExtrato(tipo).emitir();
3. }

Você tem um if apenas para decidir
qual atribuição realizar.
Utilize um comando ternário.

(expressão condicional) ? true : false;

1. public void calcularImposto(int valor) {
2. int imposto = 0;
3. if (valor > 1000) {
4. imposto = valor * 0.05;
5. } else {
6. imposto = valor * 0.02;
7. }
8. return imposto;
9. }

2. int imposto =
3. return imposto;
4. }

2. int imposto = (valor > 1000) ? valor * 0.05 : valor * 0.02;
3. return imposto;
4. }

2. return (valor > 1000) ? valor * 0.05 : valor * 0.02;
3. }

Você tem um ternário aninhado que se
tornou complexo de entender.
Mude o ternário para um if.

2. return (valor > 1000) ? (valor < 10000) ? valor * 0.05 : valor * 0.10 : valor * 0.02;
3. }

Você tem uma classe, perdendo
coesão, fazendo um trabalho que
poderia ser feito por duas ou mais
classes.
Crie uma nova classe e mova os
campos e métodos pertinentes.

1. public class Security {
2. private static final String RULES_PATH = “/usr/rules.xml”;
3.
4. public Security() {
5. this.loadRules(RULES_PATH);
6. }
7.
8. private void loadRules(String rulesPath) {
9. // Código que carrega as regras.
10. }
11.
12. public boolean verifyUser(User user) {
13. // Código que valida o usuário.
14. }
15. }

2.
4. }
5.
8. }
9. }

2.
4.
5. }
6.
9. }
10. }

2.
4. SecurityRulesLoader.loadRules();
5. }
6.
9. }
10. }

1. public class SecurityRulesLoader {
2. private static final String RULES_PATH = “/usr/rules.xml”;
3.
4. public static void loadRules() {
5. // Código que carrega as regras.
6. }
7.
8. }

Uma classe referencia uma outra
classe delegada por um objeto.
Crie métodos no servidor para ocultar
a delegação.

1. // Código da classe PaperBoy…
2. double valorAPagar = 2.00;
3. if (cliente.getCarteira().getTotal() > valorAPagar) {
4. cliente.getCarteira().retirarDinheiro(valorAPagar);
5. } else {
6. // Volte quando tiver dinheiro para pagar…
7. }

3. if () {
4.
5. } else {
7. }

3. if (cliente.pagar(valorAPagar)) {
4. // Agradecemos a preferência…
5. } else {
7. }

Substituindo Construtor
por Método Fábrica

Você tem muitos construtores
que fazem coisas diferentes.
Utilize métodos fábrica para
tornar a construção mais
intuitiva.

1. public class Triangulo {
2. private int lado1;
5. public Triangulo(int tamanho) {
6. this.lado1 = tamanho;
9. }
10. public Triangulo(int tamanho1, int tamanho2) {
11. this.lado1 = tamanho1;
14. }
15. public Triangulo(int tamanho1, int tamanho2, int tamanho3) {
19. }
20. }

9. }
14. }
19. }
20. }

6. }
11. }
16. }
17. }

6. this(tamanho, tamanho, tamanho);
7. }
12. }
17. }
18. }

7. }
9. }
14. }
15. }

7. }
9. this(tamanho1, tamanho2, tamanho2);
10. }
15. }
16. }

5. public (int tamanho) {
7. }
10. }
15. }
16. }

5. public static criarTrianguloEquilatero(int tamanho) {
7. }
10. }
15. }
16. }

6. (tamanho, tamanho, tamanho);
7. }
10. }
15. }
16. }

6. return new Triangulo(tamanho, tamanho, tamanho);
7. }
10. }
15. }
16. }

7. }
8. public (int tamanho1, int tamanho2) {
10. }
15. }
16. }

7. }
8. public static criarTrianguloIsosceles(int tamanho1, int tamanho2) {
10. }
15. }
16. }

7. }
9. (tamanho1, tamanho2, tamanho2);
10. }
15. }
16. }

7. }
9. return new Triangulo(tamanho1, tamanho2, tamanho2);
10. }
15. }
16. }

7. }
10. }
11. public static criarTrianguloEscaleno(int tamanho1, int tamanho2, int tamanho3) {
13. }
18. }
19. }

7. }
10. }
13. }
14. Triangulo(int tamanho1, int tamanho2, int tamanho3) {
18. }
19. }

5. public static Triangulo criarTrianguloEquilatero(int tamanho) {
7. }
10. }
13. }
14. private Triangulo(int tamanho1, int tamanho2, int tamanho3) {
18. }
19. }

7. }
10. }
13. }
14. private Triangulo(int tamanho1, int tamanho2, int tamanho3) {
18. }
19. }

Você tem dois métodos em subclasses
diferentes que executam passos
semelhantes na mesma ordem, mas
esses passos são diferentes.
Utilize um Template Method para
eliminar a duplicação.

1. public class Cafe {
2. public void fazerCafe() {
3. ferverAgua();
4. passarCafe();
5. colocarNaXicara();
6. colocarAcucar();
7. }
8. public void ferverAgua() {
9. System.out.println(“Fervendo a água...”);
10. }
11. public void passarCafe() {
12. System.out.println(“Passando o café...”);
13. }
14. public void colocaNaXicara() {
15. System.out.println(“Colocando na xícara...”);
16. }
17. public void colocarAcucar() {
18. System.out.println(“Colocando açucar...”);
19. }
20. }

1. public class Cha {
2. public void fazerCha() {
3. ferverAgua();
4. mergulharCha();
6. colocarLimao();
7. }
10. }
11. public void mergulharCha() {
12. System.out.println(“Mergulhando o chá...”);
13. }
16. }
17. public void colocarLimao() {
18. System.out.println(“Colocando limão...”);
19. }
20. }

1. public abstract class BebidaQuente {
2. public void prepararBebida() {
3. ferverAgua();
4. infusao();
6. condimentar();
7. }
10. }
11. public abstract void infusao();
14. }
15. public abstract void condimentar();
16. }

1. public class Café extends BebidaQuente {
2. public void infusao() {
3. System.out.println(“Passando o café...”);
4. }
5. public void condimentar() {
6. System.out.println(“Colocando açucar...”);
7. }
8. }

1. public class Cha extends BebidaQuente {
2. public void infusao() {
3. System.out.println(“Mergulhando o chá...”);
4. }
5. public void condimentar() {
6. System.out.println(“Colocando limão...”);
7. }
8. }

Você tem um switch ou aninhamento
de condicional e não quer criar um
conjunto de classes.
Utilize um enum com strategy
para absorver o polimorfismo.

1. public class Banco {
2.
12. }
13. }
14.
15. }

1. public enum TipoExtrato {
2. SimplificadoMensal,
3. SimplificadoQuinzenal,
4. SimplificadoSemanal,
5. Completo;
6. }

2. SimplificadoMensal,
5. Completo;
6.
7. public abstract void emitirExtrato();
8. }

2. SimplificadoMensal {
3. public void emitirExtrato() {
4. // Código da emissão do extrato.
5. }
6. },
9. Completo;
10.
11. public abstract void emitirExtrato();
12. }

2.
4. }
5.
6. }

2.
4. TipoExtrato.valueOf(tipo).emitir();
5. }
6.
7. }

Substituindo Construtores
por Fluent Interface

Você tem construtores que
recebem muitos parâmetros e
alguns deles são opcionais.
Utilize uma Fluent Interface para
flexibilizar a criação dos objetos.

1. new EmailMessage()
2. .from(“rodrigo.branas@gmail.com”)
3. .to(“contato@globo.com”)
4. .withSubject(“Fluent API - Demo”)
5. .withMessage(“Message…”)
6. .send();

1. Date data = november(20, 2005);

1. new Image(“cat.jpg”)
2. .rotate(90)
3. .watermark(“Copyright - 2012”)
4. .blackAndWhite()
5. .save(“catAfterChanges.jpg”);

Um método retorna uma coleção.
Faça-o retornar uma visão apenas de
leitura e forneça métodos de adição e
remoção.

1. ...
2. Biblioteca biblioteca = new Biblioteca();
3.
4. Set<Livro> livros = new HashSet<Livro>();
5. livros.add(new Livro(“Refactoring”);
6. livros.add(new Livro(“Clean Code”);
7. livros.add(new Livro(“Effective Java”);
8. livros.add(new Livro(“Design Patterns”);
9.
10. biblioteca.setLivros(livros);
11. ...

1. public class Biblioteca {
2.
3. private Set<Livro> livros;
4.
5. public Set<Livro> getLivros() {
6. return livros;
7. }
8.
9. public void setLivros(Set<Livro> livros) {
10. this.livros = livros;
11. }
12. }

2.
4.
5. }

2.
4.
5. public void adicionarLivro(Livro livro) {
6. this.livros.add(livro);
7. }
8.
9. public void removerLivro(Livro livro) {
10. this.livros.remove(livro);
11. }

1. ...
2. Biblioteca biblioteca = new Biblioteca();
3.
4. biblioteca.adicionarLivro(new Livro(“Refactoring”));
5. biblioteca.adicionarLivro(new Livro(“Clean Code”);
6. biblioteca.adicionarLivro(new Livro(“Effective Java”);
7. biblioteca.adicionarLivro(new Livro(“Design Patterns”);
8. ...

Evite lançar exceções genéricas

Você está lançando uma exceção
genérica
Tente lançar exceções específicas

1. public void calcularImposto(int salario) throws Exception {
2. if(salario < 0) {
3. throw new Exception(“Salário não pode ser negativo”);
4. }
5. // Código de cálculo do imposto retido na fonte
6. }

1. public void calcularImposto(int salario) {
3. throw new (“Salário não pode ser negativo”);
4. }
6. }

1. public void calcularImposto(int salario) {
3. throw new IllegalArgumentException(“Salário não pode ser
negativo”);
4. }
6. }

Evite tratar exceções de forma
genérica

Você possui um bloco catch
tratando exceções genéricas
Utilize exceções específicas

1. try {
2. // Código que lança a exceção.
3. } catch (Exception e) {
4. // Código de tratamento da exceção
5. }

1. try {
3. } catch (Throwable e) {
5. }

Você possui um bloco catch vazio
Avalie se faz sentido continuar
utilizando uma exceção verificada
(checked)

1. try {
3. } catch (SomeException e) {
4. // ???
5. }

1. try {
4.
5. }

1. try {
4. e.printStacktrace();
5. }

Exceção lançada sem
informações de captura

Existem exceções sendo lançadas sem
uma mensagem contendo a explicação
detalhada da falha
Define uma mensagem detalhando a
falha

1. public void gerarBoleto(Boleto boleto) throws BoletoException {
2. // Código de geração do boleto
3. throw new BoletoException();
4. }

3. throw new BoletoException(boleto);
4. }

3. throw new BoletoException(boleto);
4. }
5.
6. public class BoletoException extends Exception {
7. private Boleto boleto;
8.
9. public BoletoException(Boleto boleto) {
10. super(“Não foi possível gerar o boleto. Cedente: ” +
boleto.getCedente() + “ Sacado: ” + boleto.getSacado() + “
Valor: ” + boleto.getValor());
11. this.boleto = boleto;
12. }

Substituir Código de Erro
por Exceção

Um método retorna um código especial
para indicar um erro.
Em vez disso, gere uma exceção.

1. public class CaixaEletronico {
2. public void pedidoDeSaque(double valor) {
3. int resultado = banco.processarSaque(valor);
4. if (resultado == 0) {
5. dispensarDinheiro(valor);
6. } else if (resultado == -1) {
7. exibirMensagem(“Saldo Insuficiente”);
8. }
10. public int processarSaque(double valor) {
11. if (valor <= saldo) {
12. saldo -= valor;
13. return 0;
14. } else {
15. return -1;
16. }
17. }
18. }

8. }
10. public processarSaque(double valor) {
12. saldo -= valor;
13. return 0;
14. } else {
15. return -1;
16. }
17. }
18. }

8. }
10. public void processarSaque(double valor) {
12. saldo -= valor;
13. return 0;
14. } else {
15. return -1;
16. }
17. }
18. }

8. }
12. saldo -= valor;
13. } else {
14. }
15. }
16. }

8. }
12. saldo -= valor;
13. } else {
14. throw new SaldoInsuficienteException();
15. }
16. }
17. }

Que tipo de exceção utilizar nesse
cenário?

8. }
10. public void processarSaque(double valor) throws SaldoInsuficienteEx... {
12. saldo -= valor;
13. } else {
15. }
16. }
17. }

3. banco.processarSaque(valor);
6. }
10. saldo -= valor;
11. } else {
13. }
14. }
15. }

3. try {
6. } catch(SaldoInsuficienteException e) {
8. }
9. }
13. saldo -= valor;
14. } else {
16. }
17. }
18. }

3. try {
8. }
9. }
12. if (valor > saldo) {
13. saldo -= valor;
14. } else {
16. }
17. }
18. }

3. try {
8. }
9. }
12. if (valor > saldo) throw new SaldoInsuficienteException();
13. saldo -= valor;
14. }
15. }

Substituir Exceção por
Teste

Você está gerando uma exceção em
uma condição que o solicitante poderia
ter verificado primeiro.
Faça o teste primeiro.

1. public class ConnectionPool {
2. private Stack available;
3.
4. public Connection getConnection() {
5. Connection connection;
6. try {
7. connection = (Connection) available.pop();
8. return connection;
9. } catch(EmptyStackException e) {
10. connection = new Connection();
12. }
13. }
14. }

3.
6.
7. try {
13. }
14. }
15. }

3.
6. if (available.isEmpty()) {
7.
8. }
9. try {
15. }
16. }

3.
8. }
9. try {
14. }
15. }
16. }

3.
9. }
10. try {
14. }
15. }
16. }

3.
9. }
12. }
13. }

3.
7. return new Connection();
8. }
11. }
12. }

3.
8. }
9. return (Connection) available.pop();
10. }
11. }

3.
7. }
9. }
10. }

3.
5. if (available.isEmpty()) return new Connection();
7. }
8. }

3.
5. return (available.isEmpty()) ? new Connection() : (Connection) available.pop();
6. }
7. }

Prefira o uso de exceções
padrão da linguagem

Você pode utilizar uma das exceção
padrão da linguagem para tratar
um cenário específico
Substitua a exceção customizada
pela padrão da linguagem

1. public void converterVideo(Video video) {
2. if(video == null) {
3. throw new VideoInvalidoException();
4. }
5. // Código da conversão do video
6. }

Principais exceções da linguagem:
IllegalArgumentException
IllegalStateException
NullPointerException
IndexOutOfBoundsException
UnsupportedOperationException

3. throw new ();
4. }
6. }

3. throw new IllegalArgumentException();
4. }
6. }

Exceção no nível de abstração
inadequado

Exceções de camadas inferiores
estão sendo tratadas em camadas
superiores, fora de seu nível de
abstração
Trate a exceção em sua camada de
forma correta

1. public class CadastroGUI {
2. CadastroBusiness cadastroBusiness;
3.
4. public void mostrarCliente(int id) {
5. Cliente cliente;
6. try {
7. cliente = cadastroBusiness.buscarCliente(id);
8. } catch (SQLException e) {
10. }
11. // Código de exibição do cliente
12. }
13. }

3.
5. Cliente cliente;
6. try {
8. } catch (e) {
9. // Código de tratamento
10. }
12. }
13. }

3.
5. Cliente cliente;
6. try {
8. } catch (ClienteNaoEncontradoException e) {
9. // Código de tratamento de clientes não encontrados
10. }
12. }
13. }

3.
5. Cliente cliente;
6. try {
8. } catch (ClienteNaoEncontradoException e) {
9. // Código de tratamento de clientes não encontrados
10. } catch (ClienteDesatualizadoException e) {
11. // Código de tratamento de clientes desatualizados
12. }
14. }
15. }

Encapsular Múltiplas
Exceções

Você está tratando exceções
verificadas (checked) em casos
onde não existe recuperação
Substitua a exceção verificada por
um wrapper que trate as exceções
como tempo de execução (Runtime)

1. public void tratarConteudoDoArquivo(String path) {
2. File arquivo = new File(path);
3. try {
4. FileInputStream input = new FileInputStream(arquivo);
5. byte[] conteudo = new byte[input.available()];
6. input.read(conteudo);
7. for (byte eachByte : conteudo) {
8. // Código de tratamento do conteúdo
9. }
10. } catch(FileNotFoundException e) {
11. // Fazer o que???
12. } catch (IOException e) {
13. // Fazer o que???
14. }
15. }

1. public class FileReader {
2. }

2. public byte[] readFile(String path) {
3. }
4. }

3. try {
4. File file = new File(path);
5. FileInputStream input = new FileInputStream(file);
8. return conteudo;
9. } catch (FileNotFoundException e) {
11. }
12. }
13. }

3. try {
8. return conteudo;
10. throw new FileReaderException(e);
12. }
13. }
14. }

3. try {
8. return conteudo;
13. }
14. }
15. }

2. public byte[] readFile(String path) throws FileReaderExc… {
3. try {
8. return conteudo;
13. }
14. }
15. }

2. byte[] conteudo = FileReader.readFile(path);
3. for(byte eachByte : conteudo) {
5. }
6. }

2. try {
4. } catch (FileReaderException e) {
5. }
8. }
9. }

2. try {
5.
6. }
9. }
10. }

2. try {
6. }
9. }
10. }

Técnicas de Refactoring

Mais conteúdo relacionado

Mais procurados

Destaque

Semelhante a Técnicas de Refactoring

Mais de Rodrigo Branas

Técnicas de Refactoring