Notion de polymorphisme :
Le polymorphisme consiste à accéder à un objet via une référence qui peut être de différents types :
class Animal { public voidmakeSound() { [Link]("Animal makesa sound"); }}
class Dog extendsAnimal { public voidmakeSound() { [Link]("Dog barks"); } }
interface Pet { voidmakeSound(); }
class Dog implementsPet { public voidmakeSound() { [Link]("Dog barks"); } }
Changer le type de référence d'un objet ne fait qu'élargir ou restreindre l'accès
aux membres de l'objet
Exemple :
class Animal { public void eat() { [Link]("Animal eats"); } }
class Dog extends Animal {
public boolean isDomestic = true
public void eat() { [Link]("Dog eats"); }
public void bark() { [Link]("Dog barks"); } }
public class Main { public static void main(String[] args) {
Dog dog = new Dog();
Animal animal = dog;
[Link]([Link]);//true
[Link](); // Dog eats
[Link](); // Dog eats
[Link](); // Dog barks
[Link]([Link]);//erreur
[Link](); //meme erreur } }
Cas de override d’une méthode : La methode eat de calass Animal est redéfinir dans sont classe fille
Dog donc ré[Link]() appel la méthode de classe fille(Dog) quelque soit type de réf mére ou fille (Animal
Dog ) mais il ya une exception si meth() static donc il appel la meth de la classe mére.
Compilation et exécution :
en compilation on ne regarde pas l'objet on concentre sur référance son type et est ce qu'il
posséde l'attribut ou non a l'exécution voir le type réel de l'objet pour déterminer quelle
version de la méthode doit être appelée et quelle valeur de la propriété ne voir pas la
référance.
Casting :
erreur de compilation
erreur d’execution
Animal animal_ = new Animal();
Dog dog2 = (Dog)animal_; // Compile but ClassCastException at Runtime
Ce cas engendre une erreur d’execution car on met un objet Animal dans un
réference de type Dog.
Dog dog = new Dog(); Animal animal = dog;
[Link](); //ne compile pas car animal est un réf de type Animal (meme s’il
contient un objet de type Dog en compilation on ne voir pas l’objet juste la réf)
Solution : ((Dog)animal).bark();// affiche Dog barks ici le ref animal devient de type
dog
Les règles de redéfinition (override)
1. Signature de la méthode
La méthode redéfinie doit avoir le même nom, le même type de retour et les mêmes
paramètres que la méthode de la superclasse.
2. Accès
La méthode redéfinie ne peut pas avoir un niveau d'accès plus restreint que la méthode dans
la [Link] exemple : une méthode public ne peut pas être redéfinie en protected ou
private.
3. Méthodes final
Une méthode déclarée final dans une classe ne peut pas être redéfinie.
En polymorphisme si méthode est redéfinie, on applique la méthode en
fonction du type de l’objet en mémoire (l’appel de méthode selon type de l’objet est pas le
type de réf )
exemple :
Resultat d’ex : Bark
Dans cet exemple, l'objet manipulé en mémoire est un :Dog
La méthode getSound() est redéfinie dans la sous-classe Dog, ce qui signifie que
tous les appels à cette méthode sont remplacés à l'exécution.
Bien que printSound()soit défini dans la classe Animal et Même en utilisant la référence this,
qui est optionnelle dans cet exemple, cela n'appelle pas la version parent car la méthode a
été redéfinie.
Remarque :
Modifier la classe Dog pour afficher "Some generic sound" au lieu de "Bark" la seul solution est :
ajouter @Override
public void printSound() { [Link]([Link]());// appel celle de classe mère .
Méthode masqué : Une méthode static dans la superclasse n'est pas redéfinie mais
masquée (hidden). Le polymorphisme ne s'applique pas ici, et la méthode appelée dépend du
type de la référence, pas du type réel de l'objet.
Exemple :
si la méthode est masqué, on applique la méthode en fonction du type de la référence
Remarque :
Variable masqué :
une variable déclarée dans une sous-classe a le même nom qu'une variable dans une superclasse. Dans ce cas,
la variable de la sous-classe masque celle de la superclasse. Pas de polymorphisme l'accès aux variables ne
dépend pas du type réel de l'objet mais uniquement du type de la référence.
Re_déclaration des méthodes :
Une méthode déclaré private dans la classe mère et la classe fille utilise la meme nom de cette méthode :c’et la
redéclaration et pas de polymorphisme l’appel selon type de réf.
public class Camel {private String getNumberOfHumps() { return "Undefined"; }
public static void main(String[] args) { Camel cam = newDromedaryCamel();
[Link]([Link]()); }}
class DromedaryCamel extends Camel { public intgetNumberOfHumps() { return 1; } }
Résultat d’exécution : Undefined
Classe abstraite :
une classe abstraite est une classe marquée abstract
une classe abstraite ne peut pas être instanciée (mais elle peut contenir des
constructeurs. )
une classe abstraite peut inclure zero une ou plusieurs méthodes abstraites
une classe qui admet une méthode abstraite doit être abstraite
une classe abstraite est utile quand elle est héritée par une classe concrète
elle peut être héritée par une classe abstraite
la classe concrète qui hérite de la classe abstraite, doit fournir une
implémentation (redéfinition/override) de toutes les méthodes abstraites
héritées
si une classe abstraite hérite une classe abstraite aussi, alors elle ne doit pas
(n’est pas obligatoire )fournir une implémentation des méthodes abstraites
héritées.c’est la redéfinition optionnel
une classe abstraite ne peut pas être marqué final
Classe abstraite :
une méthode abstraite est une méthode marquée abstract
une méthode abstraite est déclarée sans implémentation
une méthode abstraite peut être déclarée dans une classe abstraite ou une
interface
une méthode abstraite ne peut pas être private ou final
L’implémentation de la méthode abstraite dans une sous-classe doit
respecter les règles de redéfinition
Interface :
déclare une liste de méthodes abstraites.
peut également inclure des variables constantes. (déclarer final)
peut hériter un nombre quelconque d’interfaces
interface A extends B, C, D, E{
ne peut pas hériter une classe et une classe ne peut pas hériter une
interface
ne peut pas implémenter une autre interface
est implémenté par une classe (concrète ou abstraite)
une classe peut implémenter un nombre quelconque d’interfaces
class Ampl implements B, C, D, E{
La classe (concrète) qui implémente une interface doit fournir une
implémentation de toutes les méthodes abstraites de l’interface
L’implémentation de la méthode abstraite doit respecter les règles de
redéfinition
