Polimorfismo Java

在本教程中，我们将通过示例学习多态，不同类型的多态以及如何在Java中实现它们。

多态是面向对象编程的重要概念。它只是意味着不止一种形式。也就是说，同一实体（方法，运算符或对象）在不同情况下的行为会有所不同。例如，

No Java+运算符用于执行两个特定功能。与数字（整数和浮点数）一起使用时，将执行加法运算。

int a =　5;
int b =　6;
int sum = a　+　b;　　　　　//　　sum =　11

Quando adicionamos+Quando usamos operadores com strings, eles executam a concatenação de strings. Por exemplo,

String firstName = "abc \";
String lastName = "xyz";
name = firstName　+　lastName;　　　　　//　　name = abc xyz

多态性的类型

在Java中，多态可以分为两种类型：

• 运行时多态

• Polimorfismo de tempo de compilação

运行时多态

在Java中，可以通过方法重写来实现运行时多态。

假设在父类及其子类中创建了相同的方法。在这种情况下，将要调用的方法取决于用于调用该方法的对象。例如，

Exemplo1：方法重写

abstract class Animal {
　　　public abstract void makeSound();
}
class Dog extends Animal {
　　　@Override
　　　public　void　makeSound()　{
　　　　　　System.out.println("Bark　bark..");
　　　}
}
class　Cat　extends　Animal　{
　　　@Override
　　　public　void　makeSound()　{
　　　　　　System.out.println("Meow　meow..");
　　　}
}
class Main {
　　　public static void main(String[] args) {
　　　　　Dog　　d1　= new Dog();
　　　　　　d1.makeSound();
　　　　　　Cat　c1　=　new　Cat();
　　　　　　c1.makeSound();
　　　}
}

Saída:

Bark　bark…
Meow-meow...

Para entender como a sobrescrita de métodos funciona, acesseSobrescrita de métodos em Java.

No exemplo acima, o método makeSound() tem uma implementação diferente em duas classes diferentes. Quando executamos o programa

• a expressão d1.makeSound() chamará o método da classe Dog. Isso é porque d1é um objeto da classe Dog.

• a expressão c1.makeSound() chamará o método da classe Cat. Isso é porque c1é um objeto da classe Cat.

Determina o método a ser chamado durante a execução do programa. Portanto, a sobrescrita de métodos é polimorfismo de tempo de execução.

Polimorfismo de tempo de compilação

Pode-se alcançar a polimorfismo de tempo de compilação através da sobrecarga de métodos e sobrecarga de operadores no Java.

Sobrecarga de métodos

Em uma classe Java, se os parâmetros forem diferentes, você pode criar métodos com o mesmo nome. Por exemplo,

void　func()　{　...　}
void　func(int　a)　{　...　}
float　func(double　a)　{　...　}
float　func(int　a,　float　b)　{　...　}

Isso é chamado de sobrecarga de métodos em Java.

Vamos usar o exemplo de sobrecarga de métodos.

Exemplo3：método sobrecarregado

class　Demo　{
　public　void　displayPattern(){
　　　for(int　i　=　0;　i　<　10;　i++)　{
　　　　　System.out.print("*");
　　　}
　}
　public　void　displayPattern(char　symbol)　{
　　　for(int　i　=　0;　i　<　10;　i++)　{
　　　　　System.out.print(symbol);
　　　}
　}
}
class Main {
　public static void main(String[] args) {
　　　Demo　d1　=　new　Demo();
　　　d1.displayPattern();
　　　System.out.println("\n");
　　　d1.displayPattern('#');
　}
}

Saída:

**********
##########

No programa acima, o método displayPattern() foi sobrecarregado.

• 　Se chamarmos o método sem passar nenhum parâmetro, ele será criado * Padrão de caractere.
  

• 　Se chamarmos o método passando um caractere como parâmetro, será criado um padrão de #.
  

Para obter mais informações sobre a sobrecarga de métodos, acesseSobrecarga de métodos

Sobrecarga de métodos no Java VS Sobrescrita de métodos

• No caso da sobrescrita de métodos, os métodos devem estar em classes diferentes. No entanto, no caso da sobrecarga de métodos, os métodos devem estar na mesma classe.

• 　A sobrescrita de métodos é executada em tempo de execução, enquanto a sobrecarga de métodos é executada em tempo de compilação.
  

Sobrecarga de operadores

Alguns operadores no Java têm comportamentos diferentes para diferentes operandos. Por exemplo,

• + Os operadores são sobrecarregados para executar adição numérica e concatenação de strings.

• &、| e ! são sobrecarregados para operações lógicas e bit a bit.

Vamos ver como os operadores são sobrecarregados no Java.

No Java+Os operadores são usados para executar duas funções específicas. Quando usados com números (inteiros e números de ponto flutuante), eles executam a adição. Por exemplo,

int a =　5;
int b =　6;
int sum = a　+　b;　　　　　//　　sum =　11

Quando adicionamos+Quando usamos operadores com strings, eles executam a concatenação de strings. Por exemplo,

String firstName = "abc \";
String lastName = "xyz";
name = firstName　+　lastName;　　　　　//　　name = abc xyz

Em linguagens como C ++Nestas linguagens, podemos definir operadores para tratar diferentes operandos de maneira diferente. No entanto, o Java não suporta a sobrecarga de operadores definida pelo usuário.

Por que o polimorfismo?

O polimorfismo nos permite criar código consistente. Por exemplo,

Suponhamos que precisamos desenhar um círculo e um quadrado. Para isso, podemos criar uma classe Polygon, dos quais Circle e square herdam duas subclasses. Neste caso, é necessário criar um método com o mesmo nome render() nas duas subclasses, em vez de criar métodos com nomes diferentes.

Em nosso exemplo de sobrecarga de métodos, usamos o mesmo nome de método displayPattern() para exibir dois padrões diferentes, para manter a consistência.

O método print() no Java também é um exemplo de polimorfismo (sobrecarga de métodos). O mesmo método é usado para imprimir valores de diferentes tipos, como char, int, String, etc. Também podemos usar o mesmo método para imprimir vários valores ao mesmo tempo.

variável polimórfica

No Java, as variáveis de objeto (variáveis de instância) representam o comportamento das variáveis polimórficas. Isso é porque as variáveis de objeto da classe podem referenciar objetos da sua classe e dos seus subclasses. Por exemplo,

class Animal {
　　　public void displayInfo() {}}
　　　　　　System.out.println("Eu sou um animal.");
　　　}
}
class Dog extends Animal {
　　　@Override
　　　public void displayInfo() {}}
　　　　　　System.out.println("Eu sou um cachorro.");
　　　}
}
class Main {
　　　public static void main(String[] args) {
　　　　
　　　　　　//declaração da variável de objeto da classe Animal a1
　　　　　　Animal a1;
　　　　
　　　　　//criação de um objeto da classe Animal
　　　　　　a1　= new Animal();
　　　　　　a1.displayInfo();
　　　　　//criação de um objeto da classe Dog
　　　　　　a1　= new Dog();
　　　　　　a1.displayInfo();
　　　}
}

Saída:

Eu sou um animal.
Eu sou um cachorro.

no exemplo acima, criamos a variável de objeto da classe Animal a1. Aqui, a1é uma variável polimórfica.

porque

• na expressão a1 = new Animal(), a1referenciando um objeto da classe Animal.

• na expressão a1 = new Dog(), a1referenciando um objeto da classe Dog.

Este é um exemplo de upcasting em Java. Para obter mais informações, acesseJava Upcasting and Downcasting.