Polymorphisme en Java
Stockez des objets différents dans une variable typée parent pour qu’un seul nom d’appel puisse exécuter des corps différents. Gardez horn sur Machine affichant tone. Sur Truck, réécrivez horn pour afficher honk. Sur Car, réécrivez horn pour afficher beep. Dans Yard.java, assignez Machine m = new Machine();, Machine t = new Truck(); et Machine c = new Car();, puis appelez horn sur chacune. Compilez avec javac Yard.java et exécutez java Yard. L’écran doit montrer tone, puis honk, puis beep. Une deuxième démo garde seulement les deux enfants comme références Machine. Laissez equals pour la page suivante — cette leçon est un type parent qui porte de nombreuses formes.
Un type parent, trois corps horn
La page abstract a laissé une méthode inachevée pour que les enfants la remplissent. Cette page se concentre sur l’appel via une variable typée parent. Ouvrez Yard.java. Gardez le nom de classe public Yard. Supprimez les démos abstract-only si elles enterrent l’histoire typée parent, les fichiers enum Level restants, les démos de chemin, et tout Scanner clavier. Le programme ne doit pas attendre la frappe. Vous n’avez pas besoin de ligne import.
Déclarez un parent normal avec un corps horn :
class Machine {
void horn() {
System.out.println("tone");
}
}
Déclarez les enfants avec extends Machine et leurs propres corps horn qui affichent honk et beep. Le nom assorti et la liste de paramètres vide signifient que chaque enfant redéfinit la méthode parent.
Dans Yard.main, construisez trois variables dont le type déclaré est Machine :
Machine m = new Machine();
Machine t = new Truck();
Machine c = new Car();
Puis appelez :
m.horn();
t.horn();
c.horn();
Le type déclaré est Machine pour les trois. L’objet réel décide quel corps horn s’exécute.
class Machine {
void horn() {
System.out.println("tone");
}
}
class Truck extends Machine {
void horn() {
System.out.println("honk");
}
}
class Car extends Machine {
void horn() {
System.out.println("beep");
}
}
public class Yard {
public static void main(String[] args) {
Machine m = new Machine();
Machine t = new Truck();
Machine c = new Car();
m.horn();
t.horn();
c.horn();
}
}
Depuis le dossier qui contient Yard.java, lancez javac Yard.java. Quand parenthèses, accolades et points-virgules correspondent, javac n’écrit aucune ligne de son côté. Puis lancez java Yard — pas java Yard.java. Laissez l’extension .java hors de la commande d’exécution. Gardez une classe public dans le fichier pour que le nom corresponde à Yard. Les types auxiliaires restent sans public dans cette forme débutante.
L’écran montre tone, puis honk, puis beep. Parcourez l’exécution une fois. Java démarre à Yard.main. m contient une Machine simple, donc m.horn() affiche tone. t contient un Truck même si le type de variable dit Machine, donc t.horn() affiche honk. c contient un Car, donc c.horn() affiche beep. Même orthographe d’appel. Trois corps.
Montrez chaque affectation pendant que vous lisez la ligne d’écran qui lui correspond. La première ligne appartient à la machine simple. La deuxième ligne appartient à l’objet truck derrière un nom typé machine. La troisième ligne appartient à l’objet car derrière un nom typé machine. Ce jeu d’appariement est toute la leçon en un passage.
Si vous voyez encore seulement honk puis park d’une démo abstract, passez au fichier d’enseignement du polymorphisme et relancez java Yard. Si chaque variable est typée seulement Truck ou Car, vous ne montrez pas encore la forme typée parent de cette page — gardez le type Machine à gauche des affectations pour la démo.
Dites la règle à voix haute en regardant l’écran : le type de variable peut être le parent, l’objet peut être l’enfant, l’appel exécute le corps de l’enfant quand l’enfant a redéfini la méthode. N’inventez pas de redéfinition equals sur cette page. Ce sujet attend la leçon suivante.
Deux enfants via des références Machine
Un second programme garde les redéfinitions. main construit seulement Truck et Car, toujours stockés comme Machine, et appelle horn sur chacun.
class Machine {
void horn() {
System.out.println("tone");
}
}
class Truck extends Machine {
void horn() {
System.out.println("honk");
}
}
class Car extends Machine {
void horn() {
System.out.println("beep");
}
}
public class Yard {
public static void main(String[] args) {
Machine t = new Truck();
Machine c = new Car();
t.horn();
c.horn();
}
}
Compilez avec javac Yard.java, puis exécutez java Yard. L’écran montre honk, puis beep. Il n’y a pas d’objet Machine simple dans cette deuxième démo, et pourtant les deux variables restent typées Machine. Les objets enfants fournissent les corps. C’est la même idée de polymorphisme avec un écran plus court.
Relisez les lignes d’affectation : à gauche Machine, à droite new Truck() ou new Car(). La gauche nomme le type parent par lequel vous appellerez. La droite nomme l’objet réel. Gardez extends Machine sur les deux enfants pour que ces affectations restent légales.
Si des démos abstract restent à proximité, gardez-les comme historique. Pour cette leçon, exécutez le fichier d’enseignement du polymorphisme pour que l’écran montre tone / honk / beep ou honk / beep, pas park comme histoire principale. Si javac se plaint de classes public en double, gardez seulement Yard public.
Quel corps horn s’exécute
📊 Who runs for each Machine variable
| Variable | Real object | horn prints |
|---|---|---|
m |
Machine |
tone |
t |
Truck |
honk |
c |
Car |
beep |
Comparé aux remplissages abstract
Sur la page abstract, Machine a laissé horn inachevé et les enfants l’ont rempli, souvent avec un park partagé. Sur cette page, Machine a déjà un corps tone, les enfants le redéfinissent, et des variables typées parent contiennent les objets. Vous compilez encore Yard.java et exécutez java Yard. Les nouveaux jetons sont les affectations typées parent comme Machine t = new Truck(); et les trois affichages différents d’un seul nom d’appel.
Si un fichier abstract est encore ouvert, vous pouvez voir abstract void horn(); et park. Passez au fichier polymorphisme pour que Machine ait un corps horn normal et que main assigne des variables Machine à des objets différents. Gardez les démos equals hors de cette page. Gardez la saisie clavier hors de cette page.
Avant equals
Vous pouvez assigner des variables Machine à des objets Machine, Truck et Car et voir tone, puis honk, puis beep. Vous pouvez garder seulement les deux enfants comme références Machine et voir honk puis beep. Compilez Yard.java et exécutez java Yard pour chaque démo conservée à tour de rôle. L’appel a utilisé le propriétaire du corps. La page suivante est equals, où deux objets sont comparés pour l’égalité de façon sûre pour l’enseignement.
Gardez la démo à trois objets pour un écran clair parent plus enfants. Gardez la démo à deux enfants pour une paire typée parent claire. Gardez les fichiers equals hors de cette page. Ces trois habitudes sont le point de contrôle avant d’avancer. Quand honk apparaît depuis une variable truck typée Machine, le polymorphisme a fait son travail pour cette leçon et vous êtes prêt pour le sujet suivant sur equals.
Un dernier passage dans le dossier : un Yard public, des corps horn parent et enfant, des variables typées parent dans main, pas d’attente clavier, pas de equals forcé. Lancez javac Yard.java et java Yard une fois de plus sur la démo ouverte. Si l’écran correspond encore au tableau, l’appel à plusieurs formes est solide et le cours peut passer à equals à la page suivante.
🧠 Testez Vos Connaissances
Testez Vos Connaissances
Mettez-vous au défi avec ce quiz interactif et voyez à quel point vous comprenez le sujet
📝 Instructions
- Lisez chaque question attentivement
- Sélectionnez la meilleure réponse pour chaque question
- Vous pouvez refaire le quiz autant de fois que vous le souhaitez
- Votre progression sera affichée en haut