Vous êtes ici :
Accueil Cours Programmations La Programmation Orientée Objet en Java Le Polymorphisme

La Programmation Orientée Objet en Java : Le Polymorphisme

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

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

Il est important de savoir que la seule façon possible d'accéder à un objet est par une variable de référence. Une variable de référence peut être d'un seul type. Une fois déclaré, le type de variable de référence ne peut pas être modifié.

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

Une variable de référence peut se référer à tout objet de son type déclaré ou à tout sous-type de son type déclaré. Une variable de référence peut être déclarée comme classe ou type d'interface.

Exemple:

Examinons 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 puisqu'elle a des héritages multiples. Les exemples suivants sont vrais pour l'exemple ci-dessus:

  • Un Deer IS-A Animal
  • Un Deer IS-A Vegetarian
  • Un Deer IS-A Deer
  • Un Deer IS-A Object

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

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

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

Méthodes virtuelles

Dans cette section, je vais vous montrer comment le comportement des méthodes redéfinies en Java vous permet de profiter du polymorphisme lors de la conception de vos classes.

Nous avons déjà discuté de la méthode de substitution, où une classe d'enfant peut redéfinir une méthode de son parent. Une méthode redéfinie est essentiellement cachée dans la classe parent et n'est pas invoquée à moins que la classe enfant n'utilise le mot clé super dans la méthode primordiale.

/* 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;
   }
}

 Maintenant, supposons que nous étendons 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();
    }
}

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 créons deux objets de type Salary. Une utilisant une référence de Salary, et l'autre en utilisant une référence de Employee.

En invoquant 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.

L’appel de mailCheck ( ) sur l’objet e est tout à fait différent car e est une référence d'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 déclaration. Au moment de l'exécution, cependant, la JVM invoque mailCheck ( ) dans la classe Salary.

Ce comportement est appelé l'invocation de méthode virtuelle, et les méthodes sont appelées méthodes virtuelles. Toutes les méthodes en Java se comportent de cette manière, par quoi une méthode surchargée est invoquée au moment de l'exécution, quel que soit le type de données utilisé dans le code source au moment de la compilation.




Vous êtes ici :
Accueil Cours Programmations La Programmation Orientée Objet en Java Le Polymorphisme