Sobrescrita (override) de métodos

Computação II - Ciência da Computação


Prof.: Danilo S. Carvalho

Nessa aula, falaremos da especificação de métodos em subclasses.


Ao final da aula, poderemos alterar a implementação de um método já existente em uma subclasse através do mecanismo de sobrescrita de métodos.

Como vimos na aula sobre herança, uma subclasse herda os campos e métodos da sua superclasse.


Isso que dizer que não precisamos implementar novamente os métodos da superclasse e eles apresentarão o mesmo comportamento.


Mas e se quisermos que o comportamento de algum método da superclasse seja diferente na subclasse?

Para isso, precisamos sobrescrever/reescrever (override) o método a ser alterado na subclasse.

Isso é feito declarando o método novamente com a mesma assinatura, mudando apenas o corpo.

Por exemplo, na classe VeiculoComRodas, podemos implementar a ação de acelerar com um método genérico de aceleração de todos os veículos com rodas: ...torque aplicado nas rodas produz rotação, que produz atrito com o solo...

Já no caso da classe Carro, especificamos como a aceleração é obtida nesse tipo específico de veículo.

O mesmo pode ser feito para a bicicleta, e assim por diante. 

                        
                            public class VeiculoComRodas {
                                ...

                                public void acelerar(float intensidade) {
                                    ...  // Como um veículo com rodas acelera.
                                }
                            }
                        
                    
                        
                            public class Carro extends VeiculoComRodas {
                                ...

                                public void acelerar(float intensidade) {
                                    ... // Como um carro acelera.
                                }
                            }
                        
                    
                        
                            public class Bicicleta extends VeiculoComRodas {
                                ...

                                public void acelerar(float intensidade) {
                                    ... // Como uma bicicleta acelera.
                                }
                            }

Assim como nos construtores, podemos fazer uso do comportamento da superclasse dentro de um método da subclasse usando a palavra chave super.

Assim, podemos não precisamos reimplementar partes da superclasse que se repetem nas subclasses. 

                        
                            public class Bicicleta extends VeiculoComRodas {
                                ...

                                public void acelerar(float intensidade) {
                                    super.acelerar(intensidade); // Ativa o comportamento da classe mãe.
                                    ... // Realiza o restante da ação particular a essa classe.
                                }
                            }

É possível deixar explícito que um determinado método está sendo sobrescrito usando a anotação @Override do Java. Tal como no exemplo abaixo:

Essa anotação informa ao compilador que o método anotado deve sobrescrever o método de mesmo nome da superclasse. Dessa forma, obriga o programador a usar a assinatura correta, evitando erros. 

                        
                            public class Bicicleta extends VeiculoComRodas {
                                ...

                                @Override
                                public void acelerar(float intensidade) {
                                    super.acelerar(intensidade); // Ativa o comportamento da classe mãe.
                                    ... // Realiza o restante da ação particular a essa classe.
                                }
                            }

Podemos agora especificar o comportamento de uma subclasse modificando os métodos da superclasse através da sobrescrita (override) de método.


Comportamento já desenvolvido para a superclasse pode ser aproveitado nos métodos usando a palavra chave super, assim como nos construtores.

Perguntas:

  1. Como poderiamos fazer para incorporar o comportamento de uma classe avó (dois níveis hierárquicos acima) de uma subclasse que estamos criando.
  2. Porque os construtores não são herdados da superclasse e como isso está relacionado com a sobrescrita de métodos?
  3. Podemos sobrescrever atributos?

Exercício:

  1. Sobrescreva o método toString() da classe ArrayList<String> para que as strings contidas na lista apareçam uma em cada linha.

Até a próxima aula!