Redéfinition en Java
Réécrivez une méthode parent sur l’enfant pour que l’appel utilise le corps enfant. Gardez Truck extends Car. Sur Car, gardez horn qui affiche beep. Sur Truck, écrivez horn à nouveau pour afficher honk. Dans Yard.java, construisez un Truck et appelez t.horn(). Compilez avec javac Yard.java et exécutez java Yard. L’écran doit montrer honk. Une deuxième démo construit aussi un Car simple pour que vous entendiez beep du parent et honk de l’enfant. Laissez les interfaces pour la page suivante — cette leçon est un nom de méthode avec deux corps.
Réécrivez horn sur l’enfant
La page d’héritage laissait Truck vide pour que t.horn() garde le beep parent. La page super exécutait les constructeurs avec super. Cette page change le corps de la méthode sur l’enfant. Ouvrez Yard.java. Gardez le nom de classe public Yard. Supprimez les affichages constructeur-seuls de car et truck s’ils enterrent l’histoire de la méthode, les démos de chemin restantes, les écrivains Store, et tout Scanner clavier. Le programme ne doit pas attendre la frappe. Vous n’avez pas besoin de ligne import.
Déclarez le parent avec une méthode d’instance qui affiche beep :
class Car {
void horn() {
System.out.println("beep");
}
}
Déclarez l’enfant avec extends Car. Dans Truck, écrivez le même nom de méthode à nouveau, mais affichez honk :
void horn() {
System.out.println("honk");
}
Nom identique et liste de paramètres vide identique signifient que la version enfant remplace la version parent pour les objets Truck. Vous n’ajoutez pas une deuxième méthode sans lien. Vous redéfinissez horn.
Dans Yard.main, construisez un truck et appelez la méthode :
Truck t = new Truck();
t.horn();
L’appel exécute le corps écrit sur Truck, donc l’écran affiche honk.
class Car {
void horn() {
System.out.println("beep");
}
}
class Truck extends Car {
void horn() {
System.out.println("honk");
}
}
public class Yard {
public static void main(String[] args) {
Truck t = new Truck();
t.horn();
}
}
Depuis le dossier qui contient Yard.java, exécutez javac Yard.java. Quand parenthèses, accolades et points-virgules correspondent, javac n’écrit aucune ligne à lui. Puis exécutez java Yard — pas java Yard.java. Laissez la fin .java hors de la commande d’exécution. Gardez une seule classe publique dans le fichier pour que le nom corresponde à Yard. Les types auxiliaires Car et Truck restent sans public dans cette forme débutant.
L’écran montre honk. Parcourez l’exécution une fois. Java démarre à Yard.main. new Truck() construit un truck. t.horn() regarde le type réel de t. Parce que Truck a écrit son propre horn, ce corps enfant s’exécute et affiche honk. Le corps beep parent reste sur Car et n’est pas utilisé pour cet appel truck.
Si vous voyez encore beep, vérifiez si Truck contient vraiment une méthode horn. Un Truck vide de la page d’héritage hérite encore beep. La redéfinition exige que la méthode enfant soit présente avec le même nom. Si vous voyez encore car puis truck d’une démo constructeur, passez au fichier pédagogique de redéfinition et relancez java Yard.
Dites la règle à voix haute en regardant l’écran : même nom de méthode sur l’enfant, le corps enfant gagne pour cet objet. Gardez extends Car pour que Truck reste une sorte de Car. Sans extends, un horn sur Truck serait une histoire de type séparée, pas une redéfinition de la méthode parent.
N’inventez pas un fichier interface sur cette page. Les interfaces attendent la leçon suivante. Aujourd’hui une hiérarchie de classes porte deux corps horn, et le corps enfant répond à l’appel sur un truck.
beep parent et honk enfant côte à côte
Un second programme garde la redéfinition. main construit un Car et un Truck, puis appelle horn sur chacun. Le parent affiche encore beep. L’enfant affiche encore honk.
class Car {
void horn() {
System.out.println("beep");
}
}
class Truck extends Car {
void horn() {
System.out.println("honk");
}
}
public class Yard {
public static void main(String[] args) {
Car c = new Car();
Truck t = new Truck();
c.horn();
t.horn();
}
}
Compilez avec javac Yard.java, puis exécutez java Yard. L’écran montre beep, puis honk. La première ligne vient de l’objet Car. La seconde ligne vient de l’objet Truck. La redéfinition sur l’enfant n’efface pas la méthode parent pour les objets parent. Chaque objet utilise le corps qui appartient à son propre type.
Relisez les deux méthodes horn. Même nom. Même liste de paramètres vide. Texte d’affichage différent. Cette identité de signature fait de la version enfant une redéfinition plutôt qu’une nouvelle méthode sans lien. Si vous renommez la méthode enfant autrement, l’héritage garderait à nouveau beep sur les trucks, et vous n’enseigneriez plus la redéfinition.
Si des démos constructeur super() restent dans le dossier, gardez-les comme historique. Pour cette leçon exécutez le fichier pédagogique de redéfinition pour que l’écran montre des affichages de méthode, pas des mots d’ordre de constructeur. Si javac se plaint de classes publiques en double, vous avez encore plus d’une classe publique dans le fichier — gardez seulement Yard publique.
Corps parent versus corps enfant
📊 Who prints what for horn
| Role | horn body |
|---|---|
Parent Car |
prints beep |
Child Truck |
prints honk (overrides) |
Le tableau est la carte courte de cette page. L’héritage seul mettrait beep sur les deux rôles quand l’enfant reste vide. Après redéfinition, la ligne enfant passe à honk tandis que la ligne parent reste beep. Gardez cette carte en tête quand la deuxième démo affiche les deux lignes. |
Comparé à extends vide et à super
Sur la page d’héritage, un Truck vide gardait horn parent et affichait beep. Sur la page super, les constructeurs tournaient via super et affichaient car puis truck. Sur cette page, la méthode elle-même change sur l’enfant. Vous avez encore besoin de extends. Vous pourrez encore utiliser des constructeurs plus tard. Vous n’avez pas encore besoin d’une interface.
Si un Truck vide est encore ouvert, ajoutez le horn enfant qui affiche honk avant de juger l’écran. Si un fichier constructeur est encore ouvert, passez au fichier de redéfinition pour que t.horn() soit l’appel sous test. Les nouveaux jetons sont la méthode réécrite sur l’enfant et les deux mots d’écran différents beep et honk.
Avant les interfaces
Vous pouvez réécrire horn sur Truck et voir honk depuis t.horn(). Vous pouvez appeler c.horn() et t.horn() et voir beep puis honk. Compilez Yard.java et exécutez java Yard pour chaque démo gardée à tour de rôle. Le corps enfant a répondu à l’appel truck. La page suivante est les interfaces, où un type peut promettre des méthodes sans s’appuyer seulement sur extends.
Gardez la démo un-truck avec honk pour une redéfinition claire. Gardez la démo deux-objets pour un contraste clair parent versus enfant. Gardez les fichiers interface hors de cette page. Ces trois habitudes sont le point de contrôle avant d’avancer. Quand honk apparaît après t.horn() et que beep apparaît encore après c.horn(), la redéfinition a fait son travail pour cette leçon et vous êtes prêt pour le sujet suivant sur les interfaces.
Un dernier passage dans le dossier : un Yard public, deux types auxiliaires, un horn enfant qui affiche honk, pas d’attente clavier, pas d’interface forcée. Exécutez javac Yard.java et java Yard une fois de plus sur la démo ouverte. Si l’écran correspond encore au tableau — parent beep, enfant honk — la redéfinition est solide et le cours peut passer aux interfaces à 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