Polymorphism

le polymorphisme est relatif aux méthodes des objets.
Le polymorphisme veut dire que le même service (opération ou méthode), peut avoir un comportement différent selon les situations.
Le polymorphisme permet alors d’appeler la bonne méthode selon le type d’objet

On distingue généralement trois types de polymorphisme :

Le polymorphisme ad hoc (également surcharge ou en anglais overloading) compile time polymorphism
Le polymorphisme paramétrique (également généricité ou en anglais template)
Le polymorphisme d’héritage (également redéfinition, spécialisation ou en anglais overriding)

** “one interface, many implementations”. Polymorphism is a characteristic of being able to assign a different meaning or usage to something in different contexts – specifically, to allow an entity such as a variable, a function, or an object to have more than one form. There are two types of polymorphism:

Compile time polymorphism
Run time polymorphism

Le polymorphisme ad hoc

Le polymorphisme ad hoc permet d’avoir des fonctions de même nom, avec des
fonctionnalités similaires, dans des classes sans aucun rapport entre elles (si ce n’est bien sûr d’être des filles de la classe objet). Par exemple, la classe complexe, la classe image et la classe lien peuvent avoir chacune une fonction “afficher”. Cela permettra de ne pas avoir à se soucier du type de l’objet que l’on a si on souhaite l’afficher à l’écran.

Polymorphisme paramétrable

Le polymorphisme paramétrique, appelé généricité, représente la possibilité de définir plusieurs fonctions de même nom mais possédant des paramètres différents (en nombre et/ou en type). Le polymorphisme paramétrique rend ainsi possible le choix automatique de la bonne méthode à adopter en fonction du type de donnée passée en paramètre.

Ainsi, on peut par exemple définir plusieurs méthodes homonymes addition() effectuant une somme de valeurs.

Polymorphisme d’héritage

La possibilité de redéfinir une méthode dans des classes héritant d’une classe de base s’appelle la spécialisation. Il est alors possible d’appeler la méthode d’un objet sans se soucier de son type intrinsèque : il s’agit du polymorphisme d’héritage.

Resume

  • The behavior you get depends on the type of the object you send the message not on the type of the variable (reference)
  • RETURN TYPE IS NOT CONSIDERED
  • IDENTITY IS THE NAME AND THE ARG TYPES

Polymorphisme
Polymorphisme
Polymorphisme

The type of the varialbe defines what you could do
The type of the object define the behavior you get

You can mix overloading and overriding

overriding must not cause surprises

You can add @Override Annotation to validate that you want to do an Override in child class
not mandatory but will validate that you don’t have done a typo or missing arguments

Polymorphisme

Exemple

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
package polymorph;

class Parent {
    void showMe() {
        System.out.println("I'm a Parent!");
    }
}

class Child extends Parent {
    void showMe() { // Name and arg types are identical
        System.out.println("I'm a Child!");
    }
}

public class Example1 {

    public static void main(String[] args) {
        Parent p = new Parent();
        //  Parent p = new Child();
        p.showMe();
    }
}

Exercice

1
2
3
4
5
6
7
8
9
10
class X { 
    void doStuff() { 
        sout("I'm an X"); 
    } 
}
class Y extends X { 
    void doStuff2() { 
        sout("I'm a Y"); 
    }
}

given:

1
2
X x = new X();
x.doStuff2();

What happens?
A) I’m an X
B) I’m a Y
C) Fails.

Response : C
X does not have a method doStuff2()

Polymorphisme

given

1
2
X x = new Y();
x.doStuff2();

What happens?
A) I’m an X
B) I’m a Y
C) Fails.

Response : C
X does not have a method doStuff2()