Polymorphisme Java

Dans ce didacticiel, nous allons découvrir le polymorphisme Java et son implémentation à l'aide d'exemples.

Le polymorphisme est un concept important de la programmation orientée objet. Cela signifie simplement plus d'un formulaire.

Autrement dit, la même entité (méthode ou opérateur ou objet) peut effectuer différentes opérations dans différents scénarios.

Exemple :Polymorphisme Java

class Polygon {

  // method to render a shape
  public void render() {
    System.out.println("Rendering Polygon...");
  }
}

class Square extends Polygon {

  // renders Square
  public void render() {
    System.out.println("Rendering Square...");
  }
}

class Circle extends Polygon {

  // renders circle
  public void render() {
    System.out.println("Rendering Circle...");
  }
}

class Main {
  public static void main(String[] args) {
    
    // create an object of Square
    Square s1 = new Square();
    s1.render();

    // create an object of Circle
    Circle c1 = new Circle();
    c1.render();
  }
}

Sortie

Rendering Square...
Rendering Circle...

Dans l'exemple ci-dessus, nous avons créé une superclasse :Polygon et deux sous-classes :Square et Cercle . Remarquez l'utilisation du render() méthode.

L'objectif principal du render() méthode consiste à rendre la forme. Cependant, le processus de rendu d'un carré est différent du processus de rendu d'un cercle.

D'où le render() La méthode se comporte différemment dans différentes classes. Ou, nous pouvons dire render() est polymorphe.

Pourquoi le polymorphisme ?

Le polymorphisme nous permet de créer un code cohérent. Dans l'exemple précédent, nous pouvons également créer différentes méthodes :renderSquare() et renderCircle() pour rendre Carré et Cercle , respectivement.

Cela fonctionnera parfaitement. Cependant, pour chaque forme, nous devons créer différentes méthodes. Cela rendra notre code incohérent.

Pour résoudre cela, le polymorphisme en Java nous permet de créer une seule méthode render() qui se comporteront différemment pour différentes formes.

Remarque :Le print() est aussi un exemple de polymorphisme. Il est utilisé pour imprimer des valeurs de différents types comme char , int , string , etc.

Nous pouvons réaliser le polymorphisme en Java en utilisant les méthodes suivantes :

Remplacer la méthode
Surcharge de méthode
Surcharge de l'opérateur

Remplacement de la méthode Java

Lors de l'héritage en Java, si la même méthode est présente à la fois dans la superclasse et la sous-classe. Ensuite, la méthode dans la sous-classe remplace la même méthode dans la superclasse. C'est ce qu'on appelle le remplacement de méthode.

Dans ce cas, la même méthode effectuera une opération dans la superclasse et une autre opération dans la sous-classe. Par exemple,

Exemple 1 :Polymorphisme utilisant le remplacement de méthode

class Language {
  public void displayInfo() {
    System.out.println("Common English Language");
  }
}

class Java extends Language {
  @Override
  public void displayInfo() {
    System.out.println("Java Programming Language");
  }
}

class Main {
  public static void main(String[] args) {

    // create an object of Java class
    Java j1 = new Java();
    j1.displayInfo();

    // create an object of Language class
    Language l1 = new Language();
    l1.displayInfo();
  }
}

Sortie :

Java Programming Language
Common English Language

Dans l'exemple ci-dessus, nous avons créé une superclasse nommée Language et une sous-classe nommée Java . Ici, la méthode displayInfo() est présent dans les deux langue et Java .

L'utilisation de displayInfo() est d'imprimer les informations. Cependant, il imprime des informations différentes en langue et Java .

En fonction de l'objet utilisé pour appeler la méthode, les informations correspondantes sont imprimées.

Remarque :La méthode qui est appelée est déterminée lors de l'exécution du programme. Par conséquent, le remplacement de méthode est un polymorphisme d'exécution .

2. Surcharge de méthode Java

Dans une classe Java, nous pouvons créer des méthodes avec le même nom si elles diffèrent en paramètres. Par exemple,

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

C'est ce qu'on appelle la surcharge de méthode en Java. Ici, la même méthode effectuera différentes opérations en fonction du paramètre.

Exemple 3 :Polymorphisme utilisant la surcharge de méthode

class Pattern {

  // method without parameter
  public void display() {
    for (int i = 0; i < 10; i++) {
      System.out.print("*");
    }
  }

  // method with single parameter
  public void display(char symbol) {
    for (int i = 0; i < 10; i++) {
      System.out.print(symbol);
    }
  }
}

class Main {
  public static void main(String[] args) {
    Pattern d1 = new Pattern();

    // call method without any argument
    d1.display();
    System.out.println("\n");

    // call method with a single argument
    d1.display('#');
  }
}

Sortie :

**********

##########

Dans l'exemple ci-dessus, nous avons créé une classe nommée Pattern . La classe contient une méthode nommée display() qui est surchargé.

// method with no arguments
display() {...}

// method with a single char type argument
display(char symbol) {...}

Ici, la fonction principale de display() est d'imprimer le motif. Cependant, en fonction des arguments passés, la méthode effectue différentes opérations :

imprime un motif de * , si aucun argument n'est passé ou
imprime le modèle du paramètre, si un seul char l'argument de type est passé.

Remarque :La méthode appelée est déterminée par le compilateur. Par conséquent, il est également connu sous le nom de polymorphisme au moment de la compilation.

3. Surcharge de l'opérateur Java

Certains opérateurs en Java se comportent différemment avec différents opérandes. Par exemple,

+ l'opérateur est surchargé pour effectuer une addition numérique ainsi qu'une concaténation de chaînes, et
des opérateurs comme & , | , et ! sont surchargés pour les opérations logiques et au niveau du bit.

Voyons comment nous pouvons réaliser le polymorphisme en utilisant la surcharge d'opérateurs.

Le + L'opérateur est utilisé pour ajouter deux entités. Cependant, en Java, le + l'opérateur effectue deux opérations.

1. Lorsque + est utilisé avec des nombres (entiers et nombres à virgule flottante), il effectue une addition mathématique. Par exemple,

int a = 5;
int b = 6;

// + with numbers
int sum = a + b;  // Output = 11

2. Lorsque nous utilisons le + opérateur avec des chaînes, il effectuera une concaténation de chaînes (joindre deux chaînes). Par exemple,

String first = "Java ";
String second = "Programming";

// + with strings
name = first + second;  // Output = Java Programming

Ici, nous pouvons voir que le + L'opérateur est surchargé en Java pour effectuer deux opérations :addition et concaténation .

Remarque :Dans des langages comme C++, nous pouvons définir des opérateurs pour qu'ils fonctionnent différemment pour différents opérandes. Cependant, Java ne prend pas en charge la surcharge d'opérateur définie par l'utilisateur.

Variables polymorphes

Une variable est dite polymorphe si elle fait référence à différentes valeurs dans différentes conditions.

Les variables d'objet (variables d'instance) représentent le comportement des variables polymorphes en Java. C'est parce que les variables objet d'une classe peuvent faire référence à des objets de sa classe ainsi qu'à des objets de ses sous-classes.

Exemple :Variables polymorphes

class ProgrammingLanguage {
  public void display() {
    System.out.println("I am Programming Language.");
  }
}

class Java extends ProgrammingLanguage {
  @Override
  public void display() {
    System.out.println("I am Object-Oriented Programming Language.");
  }
}

class Main {
  public static void main(String[] args) {

    // declare an object variable
    ProgrammingLanguage pl;

    // create object of ProgrammingLanguage
    pl = new ProgrammingLanguage();
    pl.display();

    // create object of Java class
    pl = new Java();
    pl.display();
  }
}

Sortie :

I am Programming Language.
I am Object-Oriented Programming Language.

Dans l'exemple ci-dessus, nous avons créé une variable objet pl du ProgrammingLanguage classer. Ici, pl est une variable polymorphe. C'est parce que,

Dans l'instruction pl = new ProgrammingLanguage() , pl faire référence à l'objet du ProgrammingLanguage classe.
Et, dans la déclaration pl = new Java() , pl faire référence à l'objet du Java classe.

Ceci est un exemple d'upcasting en Java.

InterfaceJava Encapsulation Java

Java