Guia Linguagem Java

Introdução aos Default Methods do Java 8

Você precisa estar logado para dar um feedback. Clique aqui para efetuar o login
Para efetuar o download você precisa estar logado. Clique aqui para efetuar o login
Confirmar voto
0
 (8)  (0)

Veremos neste artigo um novo recurso do Java 8 que permite economizar tempo, simplificar a implementação e evitar a cópia direta de códigos que necessariamente se repetem no projeto.

Motivação

Na Programação Orientada a Objetos em Java, quando utilizamos interfaces, é obrigatório adicionar os métodos da mesma em cada classe que a implemente. Mesmo que um deles não precise executar nada, é necessário manter ao menos a sua assinatura na classe. Respeitando o contrato, chega um momento em que os métodos implementados da interface em várias classes tornam-se idênticos e repetitivos, levando o desenvolvedor a copiar e colar código para ganhar tempo de codificação, replicando os métodos iguais de uma classe para outra.

Até o Java 7, a melhor solução para não cair nessa prática era o uso de padrões de projetos, como o Strategy, que permitem reaproveitar métodos já implementados. Pensando nesse problema, na versão 8 da linguagem foi introduzido o recurso Default Methods. Com ele, deixa de ser necessário implementar todos os métodos da interface, o que possibilita redução no tempo gasto com o desenvolvimento e simplifica o uso desse tipo de estrutura.

button Saiba mais sobre o Java 8

Opções antes dos Default Methods

Para evitar lidar com a necessidade de implementar todos os métodos de uma interface em todas as classes que a estendem, os desenvolvedores geralmente adotam uma das seguintes “técnicas”:

  1. Copiar e colar;
  2. Desistir de utilizar interfaces e utilizar classes abstratas;
  3. Usar o padrão de projeto Strategy.

Nas Listagens 1, 2 e 3 veremos como cada uma dessas opções se aplica a um sistema desenvolvido para uma autoescola, o qual consiste de um simulador que pode conter vários tipos de veículos para o aluno selecionar, por exemplo, quando desejar fazer uma aula.

Nos códigos que serão analisados, trabalharemos com três opções de veículos, representadas por três classes. Dessas, duas são idênticas, fato que permite a má prática de copiar e colar código.

  01     public interface IAceleracao {
  02        void acelerar();
  03        void desacelerar();
  04     }
  05     
  06     public abstract class Veiculo implements IAceleracao{
  07        Motor motor = new Motor();
  08     }
  09     
  10     public class Gol extends Veiculo {
  11        @Override
  12        public void acelerar() {
  13           System.out.println("Aceleração Constante");         
  14        }
  15     
  16        @Override
  17        public void desacelerar() {
  18           System.out.println("Desaceleração Constante");             
  19        }
  20     }
  21     
  22     public class Fiesta extends Veiculo {
  23        @Override
  24        public void acelerar() {
  25           System.out.println("Aceleração Constante");         
  26        }
  27     
  28        @Override
  29        public void desacelerar() {
  30           System.out.println("Desaceleração Constante");             
  31        }
  32     }
  33     
  34     public class Maverick extends Veiculo {
  35        public Maverick()
  36        {
  37           motor = new Motor("V8");
  38        }
  39     
  40        @Override
  41        public void acelerar() {
  42                  System.out.println("Aceleração Super Rápida");
  43        }
  44     
  45        @Override
  46        public void desacelerar() {
  47              System.out.println("Desaceleração Lenta");
  48        }
  49     }
  
Listagem 1. Exemplo de classes com código dos métodos copiado

Linhas 1 a 4: Código da interface IAceleracao com os métodos acelerar() e desacelerar();

Linhas 6 a 8: Código da classe abstrata, que, além de implementar a interface, adiciona também um atributo, referente ao motor do veículo;

Linhas 10 a 20: Código da classe Gol, que estende a classe Veiculo. Note que aqui implementamos os métodos acelerar() e desacelerar() da interface IAceleracao;

Linhas 22 a 32: Implementação da classe Fiesta. Observe que ela é idêntica à da classe Gol, o que permitiu ao desenvolvedor copiar e colar o código sem fazer qualquer revisão;

Linhas 34 a 49: Código da classe Maverick. Note que ela contém uma implementação diferente das classes Gol e Fiesta, assim, não é possível apenas copiar o código.

Apesar de muitas vezes esse se mostrar o caminho mais rápido, copiar e colar código é considerado uma das piores práticas de desenvolvimento, pois se torna um multiplicador de erros e vai de encontro a um dos objetivos básicos da Orientação a Objetos: o reuso.

Como alternativa a essa prática, a Listagem 2 apresenta uma segunda solução para a implementação do mesmo simulador: desistir do uso de interface e aplicar apenas herança. Nesse novo modelo deixamos os métodos com implementação padrão na superclasse e sobrescrevemos as variações dele somente naquelas que precisarem.

  01     public abstract class Veiculo{
  02        Motor motor = new Motor();
  03     
  04        public void acelerar(){
  05           System.out.println("Aceleração Constante");
  06        }
  07     
  08        public void desacelerar(){
  09           System.out.println("Desaceleração Constante");
  10        }
  11     }
  12     
  13     public class Gol extends Veiculo { }
  14     
  15     public class Fiesta extends Veiculo { }
  16     
  17     public class Maverick extends Veiculo {
  18        public Maverick(){
  19           motor = new Motor("V8");
  20        }
  21     
  22        @Override
  23        public void acelerar() {
  24           System.out.println("Aceleração Super Rápida");
  25        }
  26     
  27        @Override
  28        public void desacelerar() {
  29              System.out.println("Desaceleração Lenta");
  30        }
  31     } 
  
Listagem 2. Exemplo de implementação sem o uso de interfaces

Linhas 1 a 11: Código da classe abstrata Veiculo, na qual se pode notar o atributo motor e a implementação dos métodos acelerar() e desacelerar(), com a finalidade de dispensar o uso de interfaces;

Linhas 13 e 15: Código das classes Gol e Fiesta. A ausência de conteúdo aqui indica que elas herdarão os métodos implementados da classe abstrata;

Linha 17 a 31: Código da classe Maverick, que utiliza polimorfismo para sobrescrever os métodos herdados da classe Veiculo.

Nesse exemplo, embora pareça que tenhamos resolvido o problema e o código tenha ficado mais limpo e de fácil manutenção, a solução perdeu em flexibilidade, em relação à opção anterior (com interfaces). Além disso, apesar de nesse caso ter funcionado, em outras situações se torna inviável resolver o problema apenas com herança. Por exemplo, se houvesse a necessidade de aumentar o número de classes que herdam de Veiculo, contendo cada uma implementações diferentes para os métodos, o uso de polimorfismo em relação aos métodos seria frequente, aumentando proporcionalmente a complexidade e a manutenção do sistema. Isso acaba prejudicando também a aplicação de boas práticas da Programação Orientação a Objetos, que presam por reusabilidade e fraco acoplamento entre objetos (o que se obtém pelo uso correto de interfaces).

A próxima alternativa, e que se mostrará a melhor opção até aqui, se baseia na utilização de padrões de projeto. Observe na Listagem 3 a solução proposta para o mesmo simulador, mas dessa vez aplicando o design pattern Strategy.

  01     public interface IAceleracao {
  02        void acelerar();
  03        void desacelerar();
  04     }
  05     
  06     public class AceleracaoMotorComum implements IAceleracao {
  07        @Override
  08        public void acelerar() {
  09           System.out.println("Aceleração Constante");
  10        }
  11     
  12        @Override
  13        public void desacelerar() {
  14           System.out.println("Desaceleração Constante");
  15        }
  16     }
  17     
  18     public class AceleracaoMotorV8 implements IAceleracao{
  19        @Override
  20        public void acelerar() {
  21           System.out.println("Aceleração Super Rápida");
  22        }
  23     
  24        @Override
  25        public void desacelerar() {
  26           System.out.println("Desaceleração Lenta");
  27        }
  28     }
  29     
  30     public abstract class Veiculo{
  31        Motor motor = new Motor();
  32        IAceleracao acelerador = new AceleracaoMotorComum();
  33        
  34        public void acelerar(){
  35           acelerador.acelerar();
  36        }
  37     
  38        public void desacelerar(){
  39           acelerador.desacelerar();
  40        }
  41     }
  42     
  43     public class Gol extends Veiculo {}
  44     
  45     public class Fiesta extends Veiculo {}
  46     
  47     public class Maverick extends Veiculo {
  48        public Maverick()
  49        {
  50           acelerador = new AceleracaoMotorV8();
  51           motor = new Motor("V8");
  52        }
  53     }
  
Listagem 3. Exemplo de implementação utilizando o padrão de projeto Strategy

Linhas 1 a 4: Código da interface IAceleracao, que representa o comportamento de aceleração do motor, com os métodos acelerar() e desacelerar();

Linhas 6 a 28: Código das classes de comportamento AceleracaoMotorComum e AceleracaoMotorV8 que implementam a interface IAceleracao e, consequentemente, seus métodos. O termo “classes de comportamento” não é um padrão da POO, ele apenas indica que a classe não representa uma abstração de um objeto, mas sim a abstração de um comportamento;

Linha 30: Código da classe abstrata Veiculo, a partir da qual serão geradas as demais classes;

Linha 32: Declaração do atributo acelerador, do tipo IAceleracao, que recebe como default uma instância da classe de comportamento AceleracaoMotorComum;

Linhas 34 a 40: Declaração de dois métodos para a classe Veiculo, que chamam internamente os métodos de mesmo nome da instância atribuída a acelerador;

Linha 43 a 45: Código das classes Gol e Fiesta, que estendem a classe Veiculo. Como essas classes mantêm o mesmo funcionamento da sua classe pai, seus métodos acelerar() e desacelerar() executarão os métodos que estão na classe de comportamento AceleracaoMotorComum (acionados nas linhas 34 e 39);

Linhas 47 a 53: A classe Maverick atribui uma nova instância para o atributo de interface acelerador. Ao fazer isso, os métodos acelerar() e desacelerar() passam a apresentar outro comportamento e executam as rotinas de mesmo nome implementadas na classeAceleracaoMotorV8.

Essa é considerada uma solução eficiente, flexível e que aplica corretamente as práticas da Orientação a Objetos, sendo útil principalmente em situações em que há um número considerável de classes que implementam a interface, já que permite a reusabilidade de código para executar comportamentos semelhantes. Porém, ela se torna pouco eficaz quando utilizada em um contexto onde há poucas classes, já que gera um código extenso. Nesse caso, o esforço de desenvolvimento despendido não terá valido a pena, pois o uso da estrutura gerada será mínimo.

Solução com Default Methods

Com a introdução desse recurso na linguagem Java, obteve-se uma solução simples e que reduz bastante o esforço de programação, simplificando o código ao possibilitar a criação de interfaces que já possuam uma implementação padrão para alguns de seus métodos (mesmo que sejam para lançar apenas uma exceção, por exemplo). Assim, quando uma classe implementar uma interface, mas não sobrescrever seus métodos, será utilizado exatamente o código que foi definido como implementação padrão na interface. Na Listagem 4 apresentamos o mesmo exemplo do simulador, agora com Default Methods.

  01    public interface IAceleracao{
  02       default void acelerar(){
  03          System.out.println("Aceleração Constante");
  04       }
  05       
  06       default void desacelerar(){
  07          System.out.println("Desaceleração Constante");
  08       }
  09    }
  10    
  11    public abstract class Veiculo implements IAceleracao{
  12       Motor motor = new Motor();
  13    }
  14    
  15    public class Maverick extends Veiculo {
  16       public Maverick(){
  17          motor = new Motor("V8");
  18       }
  19       
  20       @Override
  21       public void acelerar() {
  22             System.out.println("Aceleração Super Rápida");
  23       }
  24    
  25       @Override
  26       public void desacelerar() {
  27             System.out.println("Desaceleração Lenta");
  28       }
  29    }
  30    
  31    public class Gol extends Veiculo {}
  32    
  33    public class Fiesta extends Veiculo {} 
  
Listagem 4. Exemplo de implementação utilizando Default Methods

Linhas 2 e 6: Ao declarar as assinaturas dos métodos da interface IAceleracao, a cláusula default foi adicionada. Isso sinaliza o uso do recurso Default Methods, permitindo adicionar uma implementação padrão dentro da própria interface para cada método;

Linhas 15 a 29: Ao declarar a classe Maverick, optamos por seguir o padrão conhecido na linguagem Java, implementando os métodos da interface;

Linhas 31 e 33: Diferentemente do que é de costume, nas classes Gol e Fiesta os métodos da interface não foram implementados. Contudo, como esses métodos estão marcados como default, isso não irá gerar erro durante a compilação.

Nesse exemplo é perceptível a facilidade obtida ao acrescentar a cláusula default antes da assinatura dos métodos da interface. Isso possibilita acrescentar uma rotina padrão que normalmente só seria definida nas classes que a implementassem. Esse código padrão será executado sempre que o compilador verificar, na classe, que esses métodos não foram implementados.

 
Você precisa estar logado para dar um feedback. Clique aqui para efetuar o login
Receba nossas novidades
Ficou com alguma dúvida?