Menu

O que é polimorfismo em Java - Tutorial com exemplos

  • Principal
  • Outro
  • O que é polimorfismo em Java - Tutorial com exemplos

what is polymorphism java tutorial with examples

Experimente Nosso Instrumento Para Eliminar Problemas

Este tutorial explica o que é polimorfismo em Java, tipos de polimorfismo e como implementar polimorfismo em tempo de compilação com exemplos:

A palavra 'polimorfismo' deriva de duas palavras, ou seja, 'Poli' o que significa muitos e “ se transforma ”Formas de significado. Assim, polimorfismo significa muitas formas. Em uma linguagem de programação, podemos dizer que um objeto pode assumir muitas formas e, portanto, o objeto é polimórfico.

O polimorfismo é uma das características mais importantes da OOP e nos permite expressar uma característica (um objeto ou uma mensagem ou método ou um operador) de várias formas.

=> Dê uma olhada no guia para iniciantes em Java aqui.

O que é polimorfismo em Java

O que você aprenderá:

Introdução ao polimorfismo em Java

A entidade polimórfica se comporta de maneira diferente em diferentes cenários.

Por exemplo, considere um operador ‘+’ (adição) em Java. Este é um operador binário e leva dois operandos. Quando os operandos que são passados ​​para o operador ‘+’ são números, uma operação de adição que retorna a soma de dois números é realizada.

Quando os operandos mudam para o tipo String, o operador ‘+’ não adiciona os objetos String, mas concatena ou junta o conteúdo da string para formar uma terceira string resultante.

Por exemplo, E se ' 1 ' e ' dois ”São os conteúdos de dois objetos String então “Um” + “dois” vai resultar em ' um dois ”. Isso é concatenação.

Em Java, todos os objetos são polimórficos, pois todos são derivados da classe 'Object' e, portanto, cumprem o relacionamento 'IS-A 'com a classe Object.

Um objeto é sempre acessado por meio de uma variável de referência desse tipo de classe específico. Depois que uma variável de referência de um tipo específico é declarada, ela não pode ser modificada. No entanto, se a variável de referência não for declarada como ‘Final’, podemos reatribuí-la para apontar para outros objetos.

O tipo desta referência de objeto decidirá os métodos ou funções da classe que devem ser chamados.

Por exemplo,se houver uma classe ABC e uma classe XYZ derivada de ABC, as duas classes terão um método polimórfico func ().

class ABC{ void func(){} } class XYZ extends ABC{ void func() {} }

Vamos criar uma referência do tipo ABC.

obj = new XYZ ();

Agora, quando chamamos o método func (), uma vez que o objeto apontado por obj é da classe XYZ, o método func () da classe XYZ será invocado.

Como vimos no exemplo acima, o método func () tem implementações diferentes, mas o mesmo protótipo. Dependendo do objeto apontado pelo objeto de referência, temos a implementação apropriada nesse cenário invocado. Isso é polimorfismo.

Vamos discutir o polimorfismo em Java em detalhes.

Exemplo de polimorfismo Java

Vamos entender um exemplo simples de polimorfismo em Java com a operação de adição, conforme discutido anteriormente.

Aqui, usamos dois métodos com o mesmo nome, mas parâmetros diferentes. A primeira função aceita dois parâmetros inteiros e o segundo método aceita dois parâmetros de string.

Dependendo do tipo de parâmetro passado, o método apropriado é chamado e adiciona dois inteiros e imprime o resultado ou concatena as duas strings e imprime a string resultante.

O programa Java é fornecido abaixo:

class Addition_operation{ //method to add two integers void addition_func(int num1,int num2){ System.out.println('ABC::addition_func:' + (num1+num2)); } //overloaded method to add two strings void addition_func(String str1, String str2){ String result = str1 + ' ' + str2; System.out.println('XYZ::addition_func:' + result); } } public class Main { public static void main(String() args) { Addition_operation abc = new Addition_operation(); //create a class object abc.addition_func (3,4); //calls 1st method abc.addition_func ('Hello' , 'World!'); //calls 2nd method } }

Resultado:

Saída - exemplo de polimorfismo

Aqui, vimos que, na primeira vez que passamos dois parâmetros inteiros para o Added_func, o primeiro método é chamado. Na segunda chamada de função, passamos dois parâmetros do tipo String e, portanto, o segundo método sobrecarregado é chamado.

Tipos de polimorfismo

Java oferece suporte a dois tipos de polimorfismo:

  • Polimorfismo de tempo de compilação
  • Polimorfismo de tempo de execução

Tipos de polimorfismo em Java

Como o nome sugere, o polimorfismo do tempo de compilação é executado no tempo de compilação e o polimorfismo do tempo de execução é feito no tempo de execução.

Conforme mostrado na figura acima, o polimorfismo em tempo de compilação é implementado por meio de sobrecarga. Podemos sobrecarregar o método ou o operador. O polimorfismo de tempo de execução é obtido por meio da Substituição.

Neste tutorial, discutiremos o polimorfismo em tempo de compilação em detalhes. Vamos abordar o polimorfismo de tempo de execução no próximo tutorial.

Polimorfismo de tempo de compilação em Java

O polimorfismo em tempo de compilação também é conhecido como “polimorfismo estático”. Como parte do polimorfismo em tempo de compilação, qualquer polimorfismo a ser executado, é executado em tempo de compilação.

Em Java, o polimorfismo em tempo de compilação é realizado usando “ Sobrecarga de método ”. Usando a sobrecarga de método, podemos ter um ou mais métodos com o mesmo nome e apenas diferenciados em números ou tipo ou ordem de parâmetros.

A sobrecarga de método é a implementação mais comum do polimorfismo de tempo de compilação em Java. Java também suporta sobrecarga de operador.

O que é sobrecarga em Java em geral?

Sobrecarga em Java é o processo de ter mais de um método com o mesmo nome e tipo de retorno, mas diferindo no sequente, número e tipos de argumentos. Também é chamado de sobrecarga de método em geral.

qual é o melhor downloader de mp3 grátis para android

Sobrecarga de método em Java

A sobrecarga de método é uma implementação do polimorfismo de tempo de compilação em Java. Quando temos um ou mais métodos com o mesmo nome e / ou tipos de retorno, mas listas de parâmetros diferentes, dizemos que “sobrecarregamos” os métodos.

Portanto, em uma determinada classe, podemos ter vários métodos com o mesmo nome, mas listas de argumentos diferentes.

Como invocamos métodos sobrecarregados? Ou como o compilador sabe qual método deve ser chamado?

A invocação do método exato que corresponde à chamada é realizada dependendo da lista de parâmetros.

Já vimos que uma classe em Java pode ter mais de um construtor. No caso de construtores, a lista de argumentos ou os argumentos que o construtor aceita é diferente em todos os construtores. Este é um exemplo de sobrecarga. Portanto, a sobrecarga do construtor é uma forma básica de sobrecarga de método em Java.

Agora vamos ver como sobrecarregar um método em Java?

Java fornece três maneiras de sobrecarga de método, dependendo das variações na lista de parâmetro / argumento.

# 1) Tipo de parâmetros

Podemos sobrecarregar métodos em Java dependendo do tipo de dados dos parâmetros.

Considere o exemplo a seguir, no qual fornecemos protótipos de três métodos.

adição (int, int);
adição (int, float);
adição (String, String);

Como visto acima, temos o mesmo nome de método em todos os três casos e o mesmo número de parâmetros, mas cada chamada de método possui diferentes tipos de parâmetros.

Portanto, desde que os métodos tenham diferentes tipos de parâmetros, podemos dizer que os métodos estão sobrecarregados. Quando invocamos o método, o compilador decide sobre o tipo de dados do parâmetro e, dependendo do tipo de dados da lista de parâmetros fornecida com a chamada do método, o método apropriado é chamado.

Por exemplo,se tivermos uma chamada de método como abaixo:

adição (3, 3,5);

Na chamada do método acima, podemos ver que o primeiro parâmetro é do tipo int, enquanto o segundo parâmetro é do tipo float. Quando a chamada acima é encontrada, o compilador resolve a lista de parâmetros e invoca o método apropriado, que é o segundo método acima.

Agora vamos implementar um programa Java completo para demonstrar a sobrecarga do método com base nos tipos de dados dos parâmetros.

class MethodOverload { //overloaded method - char parameter public void printParam(char ch) { System.out.println('Input character:' + ch); } //overloaded method - int parameter public void printParam(int num) { System.out.println('Input Number:' + num); } } class Main { public static void main(String args()) { MethodOverload obj = new MethodOverload(); obj.printParam('A'); //call overloaded method (char ) obj.printParam(10); //call overloaded method (int ) } }

Resultado:

Tipo de parâmetros - saída

# 2) Número de parâmetros

Outra implementação de sobrecarga de método é sobrecarregar métodos com um número diferente de parâmetros na chamada de função.

Por exemplo,vamos considerar as seguintes declarações de método:

addnum (int, int);

addnum (int, int, int);

Nas declarações de método acima, a primeira declaração de método tem dois parâmetros e a segunda declaração tem três parâmetros. Quando uma função é chamada, o compilador inspeciona o número de parâmetros e, a seguir, resolve a chamada do método de maneira apropriada.

O exemplo a seguir mostra o programa que usa a sobrecarga de método com base no número de parâmetros.

class MethodOverload { //overloaded method - 1 parameter public void printParam(char ch) { System.out.println(ch); } //overloaded method - 2 parameters public void printParam(char ch, int num) { System.out.println('Character: ' + ch + ' ; '+ 'Number:' +num); } } class Main { public static void main(String args()) { MethodOverload obj = new MethodOverload(); obj.printParam('A'); //call overloaded method (1 ) obj.printParam('A',10); //call overloaded method (2 ) } }

Resultado:

número de parâmetros - saída

Neste exemplo, temos dois métodos sobrecarregados com base no número de parâmetros. O primeiro método usa um parâmetro e o segundo método usa dois parâmetros. No método principal, chamamos os dois métodos um após o outro e o compilador resolve a chamada de função dependendo do número de parâmetros especificados.

# 3) Sequência de parâmetros

A terceira abordagem de implementação de sobrecarga de método é baseada na sequência de parâmetros em métodos sobrecarregados.

Considere o seguinte exemplo da declaração do método,

soma (int, float);
soma (float, int);

Aqui temos uma soma de método sobrecarregada. Na primeira declaração, os parâmetros são int e float. Também na segunda declaração, os parâmetros são int e float, mas sua ordem na lista de parâmetros é alterada.

Agora, o parâmetro float aparece primeiro, enquanto o parâmetro int é o segundo. Podemos atingir a sobrecarga do método, alterando a ordem dos parâmetros.

O abaixo o programa Java demonstra isso.

class MethodOverload { //overloaded method - char,int parameter public void printParam(char ch, int num) { System.out.println('Input character:' + ch + ' ; ' + 'Input Number:' + num); } //overloaded method - int,char parameter public void printParam(int num, char ch) { System.out.println('Input Number:' + num + ' ; ' + 'Input Character:' + ch); } } class Main { public static void main(String args()) { MethodOverload obj = new MethodOverload(); obj.printParam('A', 100); //call overloaded method (char,int) obj.printParam(100, 'A'); //call overloaded method (int,char) } }

Resultado:

Sequência de parâmetros - saída

No programa acima, temos um método sobrecarregado printParam que possui parâmetros int e char cuja ordem é alterada em duas declarações de método.

Casos inválidos de sobrecarga de método

Até agora, discutimos a sobrecarga de métodos usando a lista de parâmetros. Ainda não consideramos o tipo de método de retorno. Observe que não sobrecarregamos métodos com base em tipos de retorno.

Por exemplo, se dois métodos têm o mesmo nome e as mesmas listas de parâmetros, mas diferentes tipos de retorno, então não dizemos que esses dois métodos estão sobrecarregados. Este caso torna-se inválido por sobrecarga.

Portanto, se tivermos as seguintes declarações:

I int (int, int);
Soma de string (int, int);

Nesse caso, o compilador emitirá um erro, pois dois métodos não estão sobrecarregados. Portanto, com base apenas nos tipos de retorno, os métodos não são diferenciados.

Vamos demonstrar esse caso inválido usando um programa Java.

class OverloadDemo { public double myMethod(int num1, int num2) { System.out.println('OverloadDemo::myMethod returns double'); return num1+num2; } public int myMethod(int var1, int var2) { System.out.println('OverloadDemo::myMethod returns int'); return var1-var2; } } class Main { public static void main(String args()) { OverloadDemo obj2= new OverloadDemo(); obj2.myMethod(10,10); obj2.myMethod(20,12); } }

No programa acima, o método myMethod possui dois protótipos. Um protótipo leva dois parâmetros int e retorna double. O segundo protótipo de método usa dois parâmetros int e retorna um int.

Então, quando compilamos este programa, obtemos a saída abaixo.

Resultado:

Caso inválido de sobrecarga de método

O erro de compilação acima indica que o método foi declarado duas vezes. Isso significa que o compilador não considera esses métodos sobrecarregados apenas com base no tipo de retorno.

Sobrecarga do operador

A sobrecarga do operador é um mecanismo de sobrecarga no qual um significado diferente é atribuído a um operador existente.

Como discutimos na seção de introdução deste tutorial, um operador de adição ‘+’ é um exemplo clássico de sobrecarga de operador.

Quando os operandos desse operador são numéricos, o operador + retorna o total de dois valores. Mas quando os operandos são do tipo String, o resultado da operação de adição é a string concatenada. Observe que em Java, só podemos sobrecarregar o operador + (adição).

Este operador executa duas funções:

  • Adicionando números inteiros ou valores numéricos.
  • Cordas de concatenação

Portanto, o suporte à sobrecarga de operador é limitado em Java, ao contrário de C ++, em que podemos sobrecarregar quase todos os operadores, exceto alguns como sizeof, operador de ponto, etc.

O programa a seguir demonstra a sobrecarga do operador em Java.

class OperatorOverload { //overloaded method for concatenating two strings void operator(String str1, String str2) { String resultStr = str1 + str2; System.out.println('Concatenated String: ' + resultStr); } //overloaded method for adding two numbers void operator(int num1, int num2) { int result = num1 + num2; System.out.println('Sum of two numbers : ' + result); } } class Main { public static void main(String() args) { OperatorOverload obj = new OperatorOverload(); obj.operator(10, 15); //add two numbers obj.operator('Hello ', 'World!!'); //concatenate two strings } }

Resultado:

Sobrecarga do operador - saída

No programa acima, sobrecarregamos o operador ‘+’. Quando passamos dois valores inteiros para o método sobrecarregado, uma soma de dois inteiros é retornada e quando duas Strings são passadas, o resultado é a string concatenada.

Certos pontos a serem observados em relação à sobrecarga e polimorfismo em tempo de compilação.

  1. A sobrecarga de método é a maneira de implementar o polimorfismo em tempo de compilação, também conhecido como polimorfismo estático.
  2. O polimorfismo estático também é conhecido como ligação inicial ou ligação em tempo de compilação.
  3. Como a vinculação de parâmetros e a chamada de função ocorre em tempo de compilação, a sobrecarga é chamada de vinculação de tempo de compilação.
  4. Só podemos sobrecarregar o operador ‘+’ em Java e ele realiza a adição de dois inteiros ou a concatenação de duas strings.

perguntas frequentes

P # 1) Por que precisamos do polimorfismo em Java?

Responda: O polimorfismo nos permite ter muitas implementações para um objeto. Por meio da sobrecarga de método, não precisamos de muitos métodos com nomes diferentes que são difíceis de lembrar. Em vez disso, podemos ter métodos sobrecarregados para que possamos ter uma implementação clara dos métodos que executam funções semelhantes.

A substituição também ajuda na implementação adequada da herança, o que nos permite adicionar mais funcionalidade às classes existentes de uma maneira mais fácil.

Q # 2) O que é polimorfismo OOP?

Responda: A definição de polimorfismo da programação orientada a objetos refere-se à capacidade das linguagens de programação de implementar um objeto de várias formas. O polimorfismo também é definido como a capacidade de um programa de substituir os métodos da classe pai na classe derivada para ter funcionalidade adicional.

P # 3) Podemos sobrecarregar e substituir o método principal?

Responda: Não. Não podemos substituir o método principal estático. Embora possamos sobrecarregar o método principal, a JVM nunca chamará o método principal sobrecarregado. Portanto, a melhor resposta é não sobrecarregar ou substituir o método principal.

P # 4) Os construtores podem ser sobrecarregados?

Responda: Sim, podemos sobrecarregar os construtores em Java da mesma forma que sobrecarregamos os métodos Java. Os construtores geralmente têm o mesmo nome, mas um número diferente de argumentos.

P # 5) Por que a sobrecarga do método é útil?

Responda: Podemos escrever código limpo usando a sobrecarga de método e também se torna legível, pois temos métodos com o mesmo nome. Portanto, se estivermos implementando funcionalidade para vários tipos de dados, podemos sobrecarregar os métodos e será mais fácil separar o código.

Conclusão

O polimorfismo em Java significa que um objeto pode ter muitas formas. O polimorfismo em Java tem dois tipos, ou seja, polimorfismo em tempo de compilação e polimorfismo em tempo de execução. O polimorfismo em tempo de compilação é feito em tempo de compilação. O polimorfismo de tempo de compilação é estático e é implementado por meio de sobrecarga de método e sobrecarga de operador.

O polimorfismo de tempo de execução é executado em tempo de execução e é dinâmico. Ele é implementado usando a substituição de método.

Neste tutorial, vimos as maneiras de implementar a sobrecarga de método. Também discutimos a sobrecarga do operador em detalhes. Java suporta a sobrecarga do operador ‘+’ apenas.

=> Leia a série de treinamento Easy Java.

Leitura recomendada

^