Menu

Java @override: Substituição de método e polimorfismo de tempo de execução

  • Principal
  • Outro
  • Java @override: Substituição de método e polimorfismo de tempo de execução

java override method overriding

Experimente Nosso Instrumento Para Eliminar Problemas

Este tutorial explica como obter polimorfismo de tempo de execução em Java usando a substituição de método e a anotação @override com exemplos simples:

Já discutimos o conceito de polimorfismo e o polimorfismo de tempo de compilação em detalhes. Neste tutorial, prosseguiremos com o polimorfismo de tempo de execução em Java.

Em contraste com o polimorfismo de tempo de compilação em que a chamada de método é resolvida em tempo de compilação, no polimorfismo de tempo de execução, a chamada de método é resolvida em tempo de execução.

=> Verifique TODOS os tutoriais Java aqui.

Substituição de método @override_ em Java

O que você aprenderá:

Polimorfismo de tempo de execução em Java

Um polimorfismo de tempo de execução que também é conhecido como polimorfismo dinâmico ou Despacho de Método Dinâmico é um técnica na qual uma chamada de método substituída é resolvida dinamicamente no tempo de execução.

O polimorfismo de tempo de execução em Java é obtido usando “ substituição de método ”. A substituição de método é uma técnica pela qual um método na classe pai é redefinido ou substituído na classe filha.

Quando o método é sobrescrito em uma classe, a técnica de despacho do método dinâmico resolve a chamada do método sobrescrito em tempo de execução e não em tempo de compilação.

Atingir polimorfismo de tempo de execução em Java - Substituição de método

A substituição de método é a abordagem que usamos para obter polimorfismo de tempo de execução em Java. Como já mencionado, a substituição de método é uma técnica na qual a subclasse adiciona um método que já está presente em sua classe pai e adiciona uma nova funcionalidade a esse método. Então dizemos que o método da classe base é sobrescrito.

O novo método que definimos na subclasse com o mesmo protótipo que o método da classe pai, mas implementação diferente é chamado de “ método de substituição ” . O método na classe pai é conhecido como “ Método substituído ”.

o que é chave de segurança de rede no roteador

Depois que o método é substituído, a questão permanece: como a chamada para esse método substituído é resolvida?

Normalmente chamamos o método substituído por meio da referência da classe base. Vamos criar uma referência do tipo base e então atribuir um objeto de classe filho usando a nova palavra-chave.

Portanto, depende do conteúdo da variável de referência ou de qual objeto é referenciado pela referência de classe base que determina qual método deve ser chamado. Portanto, se os objetos de referência apontam para o objeto da classe filha, o método de substituição é chamado.

Caso contrário, se o objeto de referência contiver um objeto de classe base, o método substituído será chamado. Um tópico que precisamos esclarecer no polimorfismo de tempo de execução, especialmente para despacho de método dinâmico, é “Upcasting”, explicado a seguir.

Upcasting

Quando um objeto de referência da classe pai que discutimos acima aponta ou se refere ao objeto da subclasse, então o chamamos de Upcasting.

Upcasting

Vamos entender o upcasting usando um exemplo simples.

Considere que temos uma classe ‘BaseClass’ e estendemos esta BaseClass para criar uma nova classe DerivedClass. Esta estrutura se parece com a mostrada abaixo.

class BaseClass { ….//BaseClass code here } class DerivedClass extends BaseClass{ ….//DerivedClass code here }

Agora, para implementar o upcasting, declararemos uma variável de referência do tipo BaseClass. Em seguida, atribuímos um objeto de DerivedClass à referência da classe BaseClass, conforme feito na instrução de código a seguir.

BaseClass base = new DerivedClass (); //Upcasting

Portanto, aqui podemos dizer que atualizamos o objeto DerivedClass para BaseClass. No que diz respeito ao polimorfismo de tempo de execução, o conceito de upcasting é muito importante.

Portanto, em geral, upcasting é o processo de atribuir objetos filho ou subclasse à referência de um pai ou superclasse.

SuperClass reference = new Subclass Object;

O programa Java abaixo demonstra a substituição do método e também mostra como o upcasting é executado para resolver chamadas de método substituídas no tempo de execução.

//base/parent class class Parent { void Print() //print method { System.out.println('Parent::Print() method'); } } //child class 1 inheriting from Parent class child1 extends Parent { void Print() //overridden print method { System.out.println('child1::Print() method'); } } //child class 2 inheriting from Parent class child2 extends Parent { void Print() //overridden print method { System.out.println('child2::Print() method'); } } class Main { public static void main(String() args) { Parent parent = new Parent(); parent.Print(); //executes parent Print () method parent = new child1(); //upcasting parent.Print(); //executes child1 Print () method parent = new child2(); //upcasting parent.Print(); //executes child2 Print () method

Resultado:

Upcasting - saída

No programa acima, temos duas classes, ou seja, filho1 e filho2, ambos derivados de uma classe ‘Pai’. A classe pai tem um método ‘Print’ que é substituído nas classes child1 e child2. Então, no método principal, criamos um objeto de referência da classe Parent denominado ‘pai’.

Primeiro, atribuímos a ele um objeto da classe Parent e depois chamamos o método “Print ()“. Em seguida, repetimos isso atribuindo primeiro o objeto filho1 e, em seguida, o objeto filho2 à referência Pai.

o melhor baixador de música mp3 grátis

A saída é exibida, dependendo do conteúdo da referência pai, e o método Print apropriado é chamado.

Vantagens do polimorfismo dinâmico / tempo de execução

  • Com o polimorfismo dinâmico, o programador pode substituir métodos.
  • Ele permite que as classes definam um método com implementação geral que seus derivados podem substituir e fornecer a implementação específica.
  • Com o despacho de método dinâmico, a chamada do método é resolvida em tempo de execução, ao contrário da sobrecarga que é decidida em tempo de compilação. Isso permite mais flexibilidade para os programadores.

Como o polimorfismo em tempo de execução liga o método apropriado à chamada em tempo de execução e também o chamamos ligação dinâmica ou ligação tardia . O polimorfismo de tempo de compilação, por outro lado, suporta ligação estática ou ligação inicial .

Vinculação estática vs. dinâmica

Ligação estáticaLigação dinâmica
A chamada de método resolvida em tempo de compilação é uma ligação estática.A chamada de método resolvida em tempo de execução é uma ligação dinâmica.
A sobrecarga de método é um exemplo de vinculação estática.A substituição de método é um exemplo de vinculação dinâmica.
Tipos de classe e campo são usados ​​para associação estática.Os objetos são usados ​​para vinculação dinâmica.
Entidades privadas, finais e estáticas usam vinculação estática.Os métodos virtuais usam vinculação dinâmica.

Função / Método Virtual em Java

A função ou método virtual em Java é um recurso usado com o polimorfismo Runtime. Ao contrário do C ++, Java não tem uma palavra-chave 'virtual' especial para denotar que um método é virtual. Um método definido na classe base e substituído na classe derivada é virtual.

Em Java, por padrão, todo método não estático, exceto private e final, é uma função virtual. Portanto, observe que os métodos que discutimos acima substituindo para implementar o polimorfismo de tempo de execução também são métodos virtuais.

Como o método estático está vinculado a Class e não pode ser chamado usando um objeto, ele não pode ser usado com polimorfismo em tempo de execução e também não é uma função virtual.

As interfaces em Java são virtuais por padrão. As classes que implementam interfaces fornecem implementações para os métodos de interface. Como no polimorfismo de tempo de execução, a chamada para métodos de interface também é resolvida em tempo de execução.

Lembre-se de que, como os métodos em uma interface são projetados para serem substituídos, todos os métodos de interface são funções virtuais.

Por exemplo, considere o seguinte código:

interface car{ void accelerate(); } class Maruti implements car{ void accelerate () { System.out.println(“Maruti car accelerated!!”); } }

No código acima, o método accelerate () é uma função virtual, pois faz parte da interface do carro e foi projetado para ser substituído.

@override Annotation In Java

A anotação @override é a anotação padrão em Java. Essa anotação foi introduzida no Java 1.5. A anotação @override é usada quando o método da subclasse sobrescreve seu método da superclasse.

Ao usar a anotação Java @override para indicar que o método está substituindo seu método de classe pai, um compilador emite um aviso se o método anotado não for substituído. Portanto, torna-se obrigatório que o método seja sobrescrito quando a anotação @override é usada.

Em segundo lugar, usando a anotação @override, tornamos o código mais legível. Podemos perceber imediatamente que o método que está sendo declarado deve ser sobrescrito.

A sintaxe geral da anotação Java @override é

public @interface override

O programa Java abaixo mostra o uso da anotação @override.

//base class definition class BaseClass { public void display() { System.out.println('BaseClass::display () method'); } } //derived class inheriting base class class DerivedClass extends BaseClass { @Override //indicates the display method being overridden public void display() { System.out.println('DerivedClass::display () method'); } } // main class public class Main { public static void main(String args()) { System.out.println('@Override Example'); //BaseClass type object;contain child object BaseClass testObj = new DerivedClass(); //call display method based on contents of object i.e. derived class display () testObj.display(); } }

Resultado:

@Override Exemplo

No programa acima, temos uma BaseClass que define um método de exibição. Em seguida, derivamos uma classe DerivedClass dessa BaseClass e marcamos o método de exibição com a anotação @override. Este método é sobrescrito no DerivedClass.

No método principal, criamos uma referência de objeto BaseClass e a apontamos para o objeto DerivedClass que faz com que a referência chame o método de exibição DerivedClass.

Se não tivéssemos implementado o método display () na classe Derived, o compilador teria dado um aviso do compilador, pois está marcado com a anotação @override.

Sobrecarregando e substituindo em Java

Agora que discutimos a sobrecarga e a substituição em Java, vamos resumir esses dois conceitos.

A sobrecarga está relacionada ao polimorfismo do tempo de compilação, ou seja, implementamos o polimorfismo do tempo de compilação usando a sobrecarga. A sobrecarga é feita de duas maneiras, ou seja, sobrecarga do método e sobrecarga do operador.

A sobrecarga de método é a técnica na qual temos mais de um método com o mesmo nome, mas listas de parâmetros diferentes. A lista de parâmetros é diferenciada com base no número de parâmetros, tipos de parâmetros ou sequência de parâmetros.

A sobrecarga do operador em Java é limitada e nos permite sobrecarregar apenas o operador ‘+’, que é usado para adicionar dois números e concatenar dois objetos String.

A sobrecarga é resolvida em tempo de compilação e é estática. Também é chamado ‘Encadernação antecipada’ .

Substituição de método é um recurso com o qual implementamos o polimorfismo de tempo de execução. Na substituição de método, um método da classe pai é substituído na classe filha. Isso significa que o protótipo do método na super e subclasse permanece o mesmo, mas as implementações são diferentes.

A substituição de método usa a técnica de despacho de método dinâmico para resolver a chamada do método e decidir se deve chamar um método de superclasse ou subclasse e isso é feito em tempo de execução.

Conseqüentemente, o polimorfismo em tempo de execução também é chamado de polimorfismo dinâmico ou ligação tardia.

A seguir, vamos tabularizar as diferenças entre sobrecarregar e substituir em Java.

Sobrecarregando vs. Substituindo em Java

SobrecarregandoSubstituindo
A sobrecarga é usada no polimorfismo em tempo de compilação.A substituição é implementada no polimorfismo de tempo de execução.
Pode ser feito na mesma aula. Pode ou não exigir herança.A substituição sempre requer herança.
Os métodos são sobrecarregados com o mesmo nome de método e listas de parâmetros diferentes.Os métodos substituídos têm os mesmos protótipos.
O tipo de retorno não é considerado na sobrecarga do método.O tipo de retorno deve ser o mesmo nos métodos sobrescritos e sobrescritos.
Melhora a legibilidade do programa.A substituição permite ter uma classe de implementação específica.

perguntas frequentes

P # 1) Podemos substituir o método estático?

Responda: Não. Os métodos estáticos não podem ser substituídos em Java. Isso ocorre porque os métodos estáticos são baseados em classe e são chamados diretamente pela classe. Eles não precisam de objetos para invocar em tempo de execução. Portanto, o despacho do método estático é determinado pelo compilador.

P # 2) Podemos substituir o construtor?

Responda: Não, não podemos substituir um construtor. Um construtor é chamado quando o objeto é criado. Não é chamado de objeto. Além disso, um dos requisitos de substituição é o método substituído e o método de substituição deve ter a mesma assinatura de método, o que não é possível no caso de construtores.

Q # 3) Por que a sobreposição de método é chamada de polimorfismo dinâmico?

Responda: No caso de substituição de método, a chamada do método é resolvida dinamicamente no tempo de execução. Por isso é chamado de polimorfismo dinâmico.

Q # 4) Qual é o uso do polimorfismo dinâmico em Java?

Responda: O polimorfismo dinâmico usa uma técnica de despacho de método dinâmico que oferece suporte à substituição de métodos para que a subclasse possa fornecer uma implementação específica para o método substituído. Dessa forma, podemos implementar os recursos específicos que nos permitem escrever programas eficientes.

Em segundo lugar, também não precisamos nos preocupar em resolver chamadas de método, pois o envio de método dinâmico decide qual método chamar.

exemplo de lista duplamente vinculada c ++

P # 5) Qual é a diferença entre vinculação estática e dinâmica?

Responda: A ligação entre uma chamada de método e sua implementação é chamada de ligação. Quando essa ligação é resolvida em tempo de compilação, nós a chamamos de ligação estática. Quando a vinculação é feita dinamicamente em tempo de execução, então a chamamos de vinculação dinâmica.

A associação estática usa o tipo de dados de classe e campos para resolver chamadas de método. A ligação dinâmica usa objetos para resolver chamadas de método. A ligação estática também é chamada de polimorfismo de tempo de compilação e a ligação dinâmica também é chamada de polimorfismo de tempo de execução.

Conclusão

Neste tutorial, discutimos o polimorfismo de tempo de execução em Java em detalhes.

O polimorfismo de tempo de execução é implementado usando a substituição de método. A substituição do método é feita na subclasse, em que um método definido na superclasse é redefinido ou substituído em sua subclasse. A assinatura do método permanece a mesma na super e na subclasse.

Ao usar a substituição de método, podemos fornecer implementação específica para o mesmo método na subclasse. Dessa forma, podemos escrever programas mais eficientes que envolvem herança. Java fornece a anotação @override para indicar que o método deve ser substituído.

Por padrão, todos os métodos não estáticos que não são finais são virtuais em Java. Todos os métodos virtuais podem ser substituídos.

=> Veja a série de treinamento simples em Java aqui.

Leitura recomendada

^