Polymorphism: dynamic dispatch and toString() · Polymorphisme : dispatch dynamique et toString()
Polymorphism: one type, many behaviours
- Polymorphism means "many forms": one superclass type, many subclass behaviours.
- You can hold a
Dogor aCatin anAnimalvariable, because each is-anAnimal. - When you call a method, the object's real type decides which version runs.
Polymorphisme : un type, plusieurs comportements
- Le polymorphisme signifie "multiforme" : un type de superclasse, plusieurs comportements de sous-classes.
- Vous pouvez garder un
Dogou unCatdans une variable de typeAnimal, car chacun est unAnimal. - Lorsque vous appelez une méthode, c'est le type réel de l'objet qui décide quelle version s'exécute.
Dynamic dispatch
- The variable's type (
Animal) decides which methods you are allowed to call. - But at run time, the actual object (
Dog) decides which overridden version runs. - This run-time choice is called dynamic dispatch — it is the heart of polymorphism.
Dispatch dynamique
- Le type de la variable (
Animal) décide quelles méthodes vous êtes autorisé à appeler. - Mais à l'exécution, c'est l'objet réel (
Dog) qui décide quelle version redéfinie s'exécute. - Ce choix à l'exécution s'appelle le dispatch dynamique — c'est le cœur du polymorphisme.
public class Main {
public static void main(String[] args) {
Animal[] zoo = { new Dog(), new Cat(), new Dog() };
for (Animal a : zoo) {
System.out.println(a.speak()); // Woof, then Meow, then Woof
}
}
}
class Animal {
public String speak() { return "some sound"; }
}
class Dog extends Animal {
public String speak() { return "Woof"; }
}
class Cat extends Animal {
public String speak() { return "Meow"; }
}
One loop handles every subclass
- The loop above never asks "is this a Dog or a Cat?" — it just calls
speak(). - Each object answers in its own way. That keeps the loop short and general.
- Add a brand-new subclass later and the same loop works on it, unchanged.
Une boucle gère chaque sous-classe
- La boucle ci-dessus ne demande jamais "est-ce un Dog ou un Cat ?" — elle appelle simplement
speak(). - Chaque objet répond à sa propre manière. Cela garde la boucle courte et générale.
- Ajoutez une toute nouvelle sous-classe plus tard et la même boucle fonctionnera dessus, inchangée.
toString(): every object inherits it from Object
- Every class in Java secretly extends a class called
Object, which has atoString(). - Override
toString()to say how your object should look as text. - Java calls it automatically when you print an object or join it with
+.
toString() : chaque objet l'hérite de Object
- Chaque classe en Java étend secrètement une classe nommée
Object, qui possède untoString(). - Redéfinissez
toString()pour dire comment votre objet devrait apparaître en texte. - Java l'appelle automatiquement lorsque vous imprimez un objet ou le concaténez avec
+.
public class Main {
public static void main(String[] args) {
Object x = new Fraction(3, 4);
System.out.println(x); // 3/4 -- toString() runs
System.out.println("ratio " + x); // ratio 3/4
}
}
class Fraction {
private int numerator;
private int denominator;
public Fraction(int numerator, int denominator) {
this.numerator = numerator;
this.denominator = denominator;
}
public String toString() {
return numerator + "/" + denominator;
}
}
Common mistakes
- The actual object's method runs at run time (dynamic dispatch), not the variable's type.
- Override
toString()for readable output.
Erreurs courantes
- La méthode de l'objet réel s'exécute à l'exécution (dispatch dynamique), pas celle du type de la variable.
- Redéfinissez
toString()pour obtenir une sortie lisible.
Now you try
- Use a superclass array, add a new subclass, and override
toString(). - A hidden Harness checks that the right version runs for each object.
- Press Run to compile, then Check answer. Your code runs on the server, so even the first run is fast.
À vous maintenant
- Utilisez un tableau de superclasse, ajoutez une nouvelle sous-classe, et redéfinissez
toString(). - Un Harness caché vérifie que la bonne version s'exécute pour chaque objet.
- Cliquez sur Run pour compiler, puis Check answer. Votre code s'exécute sur le serveur, donc même le premier lancement est rapide.
Animal, Dog, and Cat are written for you. Complete the static method Zoo.chorus(Animal[] animals) so it returns every animal's sound joined by single spaces. Example: a Dog, Cat, Dog array gives "Woof Meow Woof". An empty array gives "". Loop and call speak() — let polymorphism pick the right sound. · Animal, Dog, et Cat sont écrits pour vous. Complétez la méthode statique Zoo.chorus(Animal[] animals) pour qu'elle retourne le son de chaque animal joint par des espaces simples. Exemple : un tableau Dog, Cat, Dog donne "Woof Meow Woof". Un tableau vide donne "". Faites une boucle et appelez speak() — laissez le polymorphisme choisir le bon son.
Click Run to see the output here. · Cliquez sur Exécuter pour voir le résultat ici.
Animal, Dog, Cat, and a working Zoo.chorus are written for you. Add a class Cow that extends Animal and overrides speak() to return "Moo". Notice the existing chorus loop handles your new Cow with no changes. · Animal, Dog, Cat, et un Zoo.chorus fonctionnel sont écrits pour vous. Ajoutez une classe Cow qui étend Animal et redéfinit speak() pour retourner "Moo". Remarquez que la boucle existante chorus gère votre nouvelle Vache sans aucun changement.
Click Run to see the output here. · Cliquez sur Exécuter pour voir le résultat ici.
Complete Fraction by overriding toString() so it returns the fraction as "numerator/denominator" — for 3 and · et 4 it returns "3/4". Java calls toString() automatically when you print a Fraction or join it with +. · Complétez Fraction en redéfinissant toString() pour qu'il retourne la fraction sous forme de "numerator/denominator" — pour 3 et 4 il retourne "3/4". Java appelle toString() automatiquement lorsque vous imprimez un Fraction ou le joignez avec +.
Click Run to see the output here. · Cliquez sur Exécuter pour voir le résultat ici.