Java - Polymorphisme

Le polymorphisme est la capacité d'un objet à prendre plusieurs formes. L'utilisation la plus courante du polymorphisme dans la POO se produit lorsqu'une référence de classe parent est utilisée pour faire référence à un objet de classe enfant.

Tout objet Java qui peut réussir plus d'un test IS-A est considéré comme polymorphe. En Java, tous les objets Java sont polymorphes puisque tout objet passera le test IS-A pour son propre type et pour la classe Object.

Il est important de savoir que le seul moyen possible d'accéder à un objet est via une variable de référence. Une variable de référence ne peut être que d'un seul type. Une fois déclaré, le type d'une variable de référence ne peut plus être modifié.

La variable de référence peut être réaffectée à d'autres objets à condition qu'elle ne soit pas déclarée finale. Le type de la variable de référence déterminerait les méthodes qu'elle peut invoquer sur l'objet.

Une variable de référence peut faire référence à n'importe quel objet de son type déclaré ou à n'importe quel sous-type de son type déclaré. Une variable de référence peut être déclarée comme une classe ou un type d'interface.

Exemple

Prenons un exemple.

public interface Vegetarian{}
public class Animal{}
public class Deer extends Animal implements Vegetarian{}

Maintenant, la classe Deer est considérée comme polymorphe car elle a un héritage multiple. Les exemples suivants sont vrais pour les exemples ci-dessus −

• Un cerf est un animal
• Un cerf est un végétarien
• Un cerf est un cerf
• Un cerf est un objet

Lorsque nous appliquons les faits variables de référence à une référence d'objet Deer, les déclarations suivantes sont légales −

Exemple

Deer d = new Deer();
Animal a = d;
Vegetarian v = d;
Object o = d;

Toutes les variables de référence d, a, v, o font référence au même objet Deer dans le tas.

Méthodes virtuelles

Dans cette section, je vais vous montrer comment le comportement des méthodes surchargées en Java vous permet de tirer parti du polymorphisme lors de la conception de vos classes.

Nous avons déjà discuté du remplacement de méthode, où une classe enfant peut remplacer une méthode dans son parent. Une méthode surchargée est essentiellement masquée dans la classe parent et n'est invoquée que si la classe enfant utilise le mot-clé super dans la méthode de remplacement.

Exemple

/* File name : Employee.java */
public class Employee {
   private String name;
   private String address;
   private int number;

   public Employee(String name, String address, int number) {
      System.out.println("Constructing an Employee");
      this.name = name;
      this.address = address;
      this.number = number;
   }

   public void mailCheck() {
      System.out.println("Mailing a check to " + this.name + " " + this.address);
   }

   public String toString() {
      return name + " " + address + " " + number;
   }

   public String getName() {
      return name;
   }

   public String getAddress() {
      return address;
   }

   public void setAddress(String newAddress) {
      address = newAddress;
   }

   public int getNumber() {
      return number;
   }
}

Supposons maintenant que nous étendions la classe Employee comme suit −

/* File name : Salary.java */
public class Salary extends Employee {
   private double salary; // Annual salary
   
   public Salary(String name, String address, int number, double salary) {
      super(name, address, number);
      setSalary(salary);
   }
   
   public void mailCheck() {
      System.out.println("Within mailCheck of Salary class ");
      System.out.println("Mailing check to " + getName()
      + " with salary " + salary);
   }
   
   public double getSalary() {
      return salary;
   }
   
   public void setSalary(double newSalary) {
      if(newSalary >= 0.0) {
         salary = newSalary;
      }
   }
   
   public double computePay() {
      System.out.println("Computing salary pay for " + getName());
      return salary/52;
   }
}

Maintenant, vous étudiez attentivement le programme suivant et essayez de déterminer sa sortie −

/* File name : VirtualDemo.java */
public class VirtualDemo {

   public static void main(String [] args) {
      Salary s = new Salary("Mohd Mohtashim", "Ambehta, UP", 3, 3600.00);
      Employee e = new Salary("John Adams", "Boston, MA", 2, 2400.00);
      System.out.println("Call mailCheck using Salary reference --");   
      s.mailCheck();
      System.out.println("\n Call mailCheck using Employee reference--");
      e.mailCheck();
   }
}

Cela produira le résultat suivant −

Sortie

Constructing an Employee
Constructing an Employee

Call mailCheck using Salary reference --
Within mailCheck of Salary class
Mailing check to Mohd Mohtashim with salary 3600.0

Call mailCheck using Employee reference--
Within mailCheck of Salary class
Mailing check to John Adams with salary 2400.0

Ici, nous instancions deux objets Salary. Un utilisant une référence de salaire s , et l'autre en utilisant une référence Employé e .

Lors de l'appel de s.mailCheck() , le compilateur voit mailCheck() dans la classe Salary au moment de la compilation et la JVM invoque mailCheck() dans la classe Salary au moment de l'exécution.

mailCheck() sur e est assez différent parce que e est une référence Employé. Lorsque le compilateur voit e.mailCheck() , le compilateur voit la méthode mailCheck() dans la classe Employee.

Ici, au moment de la compilation, le compilateur a utilisé mailCheck() dans Employee pour valider cette instruction. Au moment de l'exécution, cependant, la JVM invoque mailCheck() dans la classe Salary.

Ce comportement est appelé appel de méthode virtuelle et ces méthodes sont appelées méthodes virtuelles. Une méthode surchargée est invoquée au moment de l'exécution, quel que soit le type de données de référence utilisé dans le code source au moment de la compilation.