Polymorphisme Java

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

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

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

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

Lorsque nous+Lorsque l'opérateur est utilisé avec une chaîne, il effectue une concaténation de chaînes. Par exemple,

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

多态性的类型

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

• 运行时多态

• Polymorphisme à compilation

运行时多态

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

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

示例1：方法重写

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();
　　　}
}

Output:

Bark　bark…
Meow-meow...

Pour comprendre le fonctionnement de la redéfinition de méthode, veuillez visiterRedéfinition de méthode en Java.

Dans l'exemple ci-dessus, la méthode makeSound() a des implémentations différentes dans deux classes différentes. Lorsque nous exécutons le programme

• l'expression d1.makeSound() appellera la méthode de la classe Dog. C'est parce que d1est un objet de la classe Dog.

• l'expression c1.makeSound() appellera la méthode de la classe Cat. C'est parce que c1est un objet de la classe Cat.

Il détermine la méthode à appeler pendant l'exécution du programme. Par conséquent, la redéfinition de méthode est un polymorphisme à l'exécution.

Polymorphisme à compilation

On peut réaliser la polymorphisme à compilation avec la redéfinition de méthode et l'overloading des opérateurs en Java.

Surcharge de méthode

Dans une classe Java, si les paramètres sont différents, vous pouvez créer des méthodes avec le même nom. Par exemple,

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

Cela s'appelle la redéfinition de méthode en Java.

Nous allons prendre l'exemple de la redéfinition de méthode.

示例3：方法重载

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('#');
　}
}

Output:

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

Dans le programme ci-dessus, la méthode displayPattern() est redéfinie.

• 　Si nous appelons cette méthode sans passer de paramètres, elle créera * Motif de caractères.
  

• 　Si nous appelons cette méthode en passant un caractère en tant que paramètre, elle crée un motif de caractères #.
  

Pour en savoir plus sur la surcharge de méthode, veuillez visiterSurcharge de méthode

Surcharge de méthode en Java VS Redéfinition de méthode

• Dans le cas de la surcharge de méthode, la méthode doit se trouver dans des classes différentes. Cependant, dans le cas de la surcharge de méthode, la méthode doit se trouver dans la même classe.

• 　La surcharge de méthode est exécutée au moment de l'exécution, tandis que la surcharge de méthode est exécutée lors de la compilation.
  

Surcharge de l'opérateur

Certains opérateurs en Java comportent des différences de comportement pour différents opérateurs. Par exemple,

• + Les opérateurs sont surchargés pour effectuer l'addition numérique et la concaténation de chaînes.

• &、| et ! sont surchargés pour les opérations logiques et bit à bit.

Voyons comment les opérateurs sont surchargés en Java.

Dans Java+Les opérateurs sont utilisés pour exécuter deux fonctions spécifiques. Lorsqu'ils sont utilisés avec des nombres (entiers et nombres à virgule flottante), ils effectuent une addition. Par exemple,

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

Lorsque nous+Lorsque l'opérateur est utilisé avec une chaîne, il effectue une concaténation de chaînes. Par exemple,

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

Dans un langage comme C ++Dans une telle langue, nous pouvons définir des opérateurs pour traiter différemment des opérateurs différents. Cependant, Java ne supporte pas la surcharge d'opérateurs définis par l'utilisateur.

Pourquoi le polymorphisme ?

Le polymorphisme nous permet de créer un code cohérent. Par exemple,

Supposons que nous devions dessiner un cercle et un carré. Pour cela, nous pouvons créer une classe Polygon, et Circle et square en héritent comme sous-classes. Dans ce cas, il est nécessaire de créer une méthode render() portant le même nom dans les deux sous-classes, plutôt que de créer des méthodes portant des noms différents.

Dans notre exemple de surcharge de méthode, nous utilisons le même nom de méthode displayPattern() pour afficher deux motifs différents pour maintenir la cohérence.

La méthode print() en Java est également un exemple de polymorphisme (surcharge de méthode). La même méthode est utilisée pour imprimer différentes valeurs de types, telles que char, int, String, etc. Nous pouvons également utiliser la même méthode pour imprimer plusieurs valeurs en une seule fois.

Variable polymorphe

En Java, les variables d'objet (variables d'instance) représentent le comportement des variables polymorphes. C'est parce que les variables d'objet de la classe peuvent renvoyer à des objets de leur propre classe et des sous-classes. Par exemple,

class Animal {
　　　public void displayInfo() {}}
　　　　　　System.out.println("Je suis un animal.");
　　　}
}
class Dog extends Animal {
　　　@Override
　　　public void displayInfo() {}}
　　　　　　System.out.println("I am a dog.");
　　　}
}
class Main {
　　　public static void main(String[] args) {
　　　　
　　　　　　//Declaration of Animal class object variable a1
　　　　　　Animal a1;
　　　　
　　　　　//creation of Animal class object
　　　　　　a1　= new Animal();
　　　　　　a1.displayInfo();
　　　　　//creation of Dog class object
　　　　　　a1　= new Dog();
　　　　　　a1.displayInfo();
　　　}
}

Output:

I am an animal.
I am a dog.

In the above example, we created an object variable a of the Animal class1. Here, a1is a polymorphic variable.

This is because,

• In the statement a1 = new Animal(), a1Reference to an object of the Animal class.

• In the statement a1 = new Dog(), a1Reference to an object of the Dog class.

This is an example of upcasting in Java. For more information, please visitJava upcasting and downcasting.