2. Plan
1-Intoduction
2-Définition
3-Le polymorphisme dans la POO
4-Implémentation du polymorphisme
5-Types de polymorphisme en Java
6-La ligature dynamique des méthodes
7-Le polymorphisme pour les tableaux
8-Polymorphisme, redéfinition et surdéfinition
9-Avantages de polymorphisme
10-Conclusion
3. 1-Intoduction
• Après la notion de l'héritage, l'abstraction et l'encapsulation qui
sont les principaux éléments constitutifs de la programmation
orientée objet.
• Il est une autre caractéristique la plus importante de la POO. Le
concept de polymorphisme.
• Voyons dans cet exposé comment Java permet de mettre en
œuvre ce concept de polymorphisme.
4. 2-Définition
• Littéral sens : polymorphisme mot latin
qui composé de Poly signifie plusieurs et
Morphes signifie formes.
• En général, le polymorphisme est la
capacité d’avoir plus d'une forme d’une
même entité.
5. 3-Le polymorphisme dans la POO
• Dans le contexte de la POO, en termes plus simples, le polymorphisme est la
capacité par laquelle, nous pouvons créer des méthodes ou des variables de
référence qui se comporte différemment dans différents contexte
programmatique.
• Il s’agit d’un concept extrêmement puissant en P.O.O., qui complète l’héritage.
On peut caractériser le polymorphisme en disant qu’il permet de manipuler
des objets sans en connaître le type.
• Mais il ne s’agira pas de traiter ainsi n’importe quel objet. En se basant sur la
relation d’héritage.
6. 4-Implémentation du polymorphisme
class Point
{ public Point (int x, int y) { ..... }
public void affiche () { ..... }
}
class Pointcol extends Point
{ public Pointcol (int x, int y, byte couleur)
public void affiche () { ..... }
}
7. // p de type Point contient la référence
// a un objet de type Point (3, 5) ;
• Point p ;
• p = new Point (3, 5) ;
// p de type Point contient la référence
// a un objet de type Pointcolnt (4, 8,2) ;
p = new Pointcol (4, 8, (byte)2) ;
8. 5-Types de polymorphisme en Java
• Il existe deux types de polymorphisme en java :
1. polymorphisme dynamique :(polymorphisme Runtime ) c'est le véritable
polymorphisme. Le sens de la fonction est déterminé par le type effectif de
l'objet à l'appel (effectuée à l'exécution).
2. polymorphisme statique: c'est la surcharge. Le sens de la fonction est
déterminé statiquement par la signature des arguments à l'appel (effectuée à
la compilation).
9. 6-La ligature dynamique des méthodes
Point p = new Point (3, 5) ;
p.affiche () ; // appelle la méthode affiche de la classe Point
p = new Poincol (4, 8, 2) ;
p.affiche () ; // appelle la méthode affiche de la classe Pointcol
• L’instruction p.affiche() appelle alors la méthode affiche de la classe Pointcol.
• Autrement dit, elle se fonde, non pas sur le type de la variable p, mais bel et
bien sur le type effectif de l’objet référencé par p au moment de l’appel.
• Ce choix d’une méthode au moment de l’exécution (et non plus de la
compilation) porte généralement le nom de ligature dynamique (ou encore de
liaison dynamique).
10. 7-Le polymorphisme pour les tableaux
• Jusqu’ici, nous avons considéré les tableaux comme des objets. Cependant, il
n’est pas possible de définir exactement leur classe.
• Le polymorphisme peut s’appliquer à des tableaux d’objets. Plus précisément, si
B dérive de A, un tableau de B est compatible avec un tableau de A :
class B extends A { ..... }
A ta[] ;
B tb[] ;
.....
ta = tb ; // OK car B dérive de A
tb = ta ; // erreur
11. Remarque :
• Cette propriété des tableaux d’objets dérivés ne se retrouvera pas
dans les collections génériques.
• Ainsi un ArrayList <B> (collection d’objets de type B, ressemblant à
un tableau) ne sera pas compatible avec un ArrayList <A>.
12. 8-Polymorphisme, redéfinition et surdéfinition
class A{
public void f (float x) { ..... }
.....
}
class B extends A{
public void f (float x) { ..... } // redéfinition de f de A
public void f (int n) { ..... } // surdefinition de f pour A et B
.....
}
13. A a = new A(...) ;
B b = new B(...) ;
int n ;
a.f(n) ; // appelle f (float) de A (ce qui est logique)
b.f(n) ; // appelle f(int) de B comme on s’y attend
a = b ; // a contient une référence sur un objet de type B
a.f(n) ; // appelle f(float) de B et non f(int)
14. 9-Avantages de polymorphisme
• Simplicité : Si vous avez besoin d'écrire du code qui traite avec une famille de
types, le code peut ignorer les détails spécifiques de type et juste interagir
avec le type de la famille de base Même si le code pense qu'il utilise un objet
de la classe de base, la classe de l'objet pourrait en fait être la classe de base
ou l'un de ses sous-classes Cela rend votre code plus facile pour vous d'écrire
et plus facile pour les autres à comprendre.
• Extensibilité : D'autres sous-classes peuvent être ajoutés plus tard à la famille
des types, et les objets de ces nouvelles sous-classes devraient également
travailler avec le code existant.
15. 10-Conclusion
Le polymorphisme en Java se traduit par :
• La compatibilité entre un type dérivée et un type
ascendant.
• La ligature dynamique des méthodes, dans le sens où il
permet d’obtenir le comportement adapté à chaque type
d’objet, sans avoir besoin de tester sa nature de quelque
façon que ce soit.
16. Les références :
• http://www.slideshare.net/gauravsitu/polymorphism-12270448
• http://howtodoinjava.com/object-oriented/what-is-polymorphism-in-
java/
• Programmer en Java.
• http://www.slideshare.net/DrAZaanin/polymorphism-41840651
• http://www.technologuepro.com/Programmation-Oriente-
Objets/Polymorphisme.pdf
• http://www.slideshare.net/raffaele.doti/polymorphism
