super en Java

Utilisez super dans le constructeur enfant pour que le constructeur parent s’exécute d’abord. Gardez Truck extends Car. Dans Truck(), appelez super();, puis affichez truck. Dans Car(), affichez car. Compilez Yard.java et exécutez java Yard. L’écran doit montrer car, puis truck. Une deuxième démo passe une marque avec super("car") à Car(String mark). Laissez la redéfinition d’une méthode pour la page suivante — cette leçon porte sur l’ordre des constructeurs avec super.

Appelez d’abord le constructeur parent

La page d’héritage laissait un Truck vide utiliser horn de Car. Cette page ajoute des constructeurs. Ouvrez Yard.java. Gardez le nom de classe public Yard. Supprimez les démos de chemin restantes, les fichiers seulement-horn s’ils brouillent les constructeurs, 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 un constructeur sans argument qui affiche car :
class Car {
Car() {
System.out.println("car");
}
}
Déclarez l’enfant avec extends Car. Dans Truck(), faites de super(); la première instruction, puis affichez truck :
super();
System.out.println("truck");
Dans Yard.main, construisez un truck :
Truck t = new Truck();
Construire le truck entre dans Truck(). Cet appel commence par super(), qui exécute Car(). Après la fin du parent, l’affichage enfant s’exécute.

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 car, puis truck. Parcourez l’exécution une fois. Java démarre à Yard.main. new Truck() entre dans Truck(). La première instruction est super();, donc Car() s’exécute et affiche car. Le contrôle revient à Truck(), qui affiche truck. La ligne parent apparaît avant la ligne enfant parce que super() a tourné d’abord.
Dites l’ordre à voix haute en regardant l’écran : constructeur parent, puis affichage enfant. Cet ordre parlé correspond à ce que super() impose dans le constructeur enfant. Si les lignes arrivent dans le mauvais ordre, rouvrez le fichier pédagogique et vérifiez que super(); est encore la première instruction dans Truck() avant tout println.
Si vous affichez truck avant super() dans une expérience ultérieure où le constructeur parent a besoin d’arguments, javac peut refuser — super doit être la première instruction quand vous l’écrivez. Dans la première démo le parent n’a pas besoin d’arguments, et le fichier pédagogique garde super(); en premier exprès pour que l’ordre reste clair. Si vous ne voyez que beep d’une ancienne démo horn, passez au fichier pédagogique constructeur et relancez java Yard.
Ne réécrivez pas horn sur Truck sur cette page. La redéfinition d’une méthode est la leçon suivante. Aujourd’hui le constructeur enfant parle au parent avec super, puis affiche son propre mot. Gardez le mot car côté parent et le mot truck côté enfant pour que chaque ligne dise quel constructeur a fini.

Passez une valeur au parent avec super

Un second programme garde extends. Le constructeur parent prend maintenant un String mark et affiche cette marque. L’enfant appelle super("car") puis affiche truck.

Compilez avec javac Yard.java, puis exécutez java Yard. L’écran montre encore car, puis truck. Cette fois car est l’argument que vous avez passé via super("car"), pas un affichage figé dans un Car() sans argument. L’enfant a choisi la chaîne marque ; le constructeur parent l’a affichée. Ensuite l’enfant a affiché truck.
Relisez la signature du constructeur parent : Car(String mark). La chaîne entre guillemets dans super("car") est cette marque. Ne changez rien d’autre dans le fichier pour ce contrôle — gardez extends Car, gardez l’affichage enfant de truck, et gardez new Truck() dans main. L’écran se termine encore par truck sous car parce que l’affichage enfant ne tourne qu’après le retour de super("car").
Si vous omettez super("car") alors que Car n’a que Car(String mark), javac refuse, car le parent n’a plus de constructeur silencieux sans argument à appeler pour vous. Écrire l’appel super(...) correspondant est la façon dont l’enfant démarre le parent avec les valeurs dont il a besoin. Gardez super comme première instruction dans Truck(). Si javac se plaint d’un constructeur par défaut manquant sur Car, regardez d’abord le constructeur enfant et confirmez que la ligne super("car") est présente et encore en premier.

Comparé à extends simple sur la page horn

Sur la page d’héritage, un Truck vide appelait horn sans écrire de constructeurs. Sur cette page, les constructeurs s’exécutent en ordre via super. Gardez les démos horn comme historique si elles restent proches ; exécutez le fichier pédagogique super avec java Yard pour que l’écran montre car puis truck.
La page horn a prouvé que extends partage une méthode. Cette page prouve que extends partage aussi un chemin de construction : l’enfant démarre le parent via super, puis continue avec son propre affichage. Les deux leçons gardent Truck extends Car. Seul le corps de Truck change — d’accolades vides avec un appel horn plus tard, à un constructeur qui commence par super.
super(), super("car") et l’ordre des constructeurs sont les nouveaux jetons. Vous avez encore besoin de extends. Vous n’avez pas encore besoin de redéfinir une méthode. Si un appel horn restant siège encore dans main, retirez-le pour ces démos afin que l’écran ne montre que les affichages de constructeur.

Ce que cette page laisse pour la redéfinition

Cette page exécute les constructeurs parent avec super. La page suivante montre la redéfinition, où un enfant écrit sa propre version d’une méthode que le parent a déjà. Restez ici avec les appels super de constructeur. Ne remplacez pas encore horn sur Truck comme exigence de ces démos.
Quand vous redéfinirez plus tard une méthode, vous appellerez souvent encore d’abord un constructeur parent avec super. Traitez cette page comme la moitié constructeur de cette histoire. Terminez les deux démos Yard jusqu’à ce que car puis truck deviennent automatiques avant d’ouvrir la leçon de redéfinition.

Avant la redéfinition

Vous pouvez appeler super();, puis afficher truck et voir car d’abord. Vous pouvez appeler super("car") quand le parent prend une marque et voir encore car, puis truck. Compilez Yard.java et exécutez java Yard pour chaque démo conservée à tour de rôle. Le constructeur parent a fini avant l’affichage enfant. La page suivante est la redéfinition, où l’enfant remplace le corps d’une méthode.
Gardez la démo super() sans argument pour un ordre clair. Gardez la démo super("car") pour un passage d’argument clair. Gardez la redéfinition de méthode hors de cette page. Ces trois habitudes sont le point de contrôle avant d’avancer. Quand car apparaît au-dessus de truck après new Truck(), super a fait son travail pour cette leçon et vous êtes prêt pour le sujet suivant sur la redéfinition.
Un dernier passage dans le dossier : un Yard public, deux types auxiliaires, pas d’attente clavier, pas de restes de chemin, pas de réécriture forcée de horn. Exécutez javac Yard.java et java Yard une fois de plus sur la démo ouverte. Si l’écran affiche encore car puis truck, l’ordre des constructeurs est solide et le cours peut passer à la redéfinition sur la page suivante.