Interfaces en Java

Déclarez un interface avec des en-têtes de méthode vides, puis remplissez ces méthodes dans une classe avec implements. Écrivez interface Signal avec void horn(); et sans corps. Écrivez class Truck implements Signal et donnez à horn un corps qui affiche 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 laisse une classe implements deux interfaces à la fois. Laissez les enums pour la page suivante — cette leçon est la promesse d’une méthode et la classe qui la tient.

Implémentez une méthode d’interface

La page de redéfinition a réécrit horn sur un enfant qui extends Car déjà. Cette page part d’une promesse sans corps. Ouvrez Yard.java. Gardez le nom de classe public Yard. Supprimez les démos Car/Truck avec extends restantes si elles enterrent l’histoire de l’interface, les affichages constructeur avec super, 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 l’interface au-dessus des classes :
interface Signal {
void horn();
}
L’en-tête se termine par un point-virgule. Il n’y a pas de corps { } pour horn dans l’interface sous cette forme débutant.
Déclarez la classe qui tient la promesse :
class Truck implements Signal {
Dans Truck, écrivez une méthode public avec le même nom et remplissez le corps :
public void horn() {
System.out.println("honk");
}
Le mot-clé est implements, pas extends. La classe doit fournir un corps pour chaque méthode listée sur l’interface. Sur cette page, c’est seulement 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.

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. L’interface Signal et la classe auxiliaire 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 qui a promis Signal. t.horn() exécute le corps sur Truck et affiche honk. Vous n’écrivez jamais new Signal() — l’interface nomme les méthodes ; la classe fournit les corps et l’objet.
Si javac refuse, vérifiez trois points. D’abord, la ligne de classe doit dire implements Signal, pas extends Signal. Ensuite, chaque méthode d’interface a besoin d’une méthode correspondante sur la classe. Enfin, la méthode d’implémentation est public dans cette forme pédagogique pour correspondre au contrat public de l’interface. Si vous voyez encore beep d’un ancien fichier override, passez au fichier pédagogique d’interface et relancez java Yard.
Dites la règle à voix haute en regardant l’écran : l’interface nomme l’appel, la classe remplit le corps, l’objet exécute ce corps. Gardez implements sur la classe qui possède l’affichage. N’inventez pas un enum sur cette page. Les enums attendent la leçon suivante.

Implémentez deux interfaces sur une classe

Un second programme garde Yard et Truck. Maintenant Truck implémente deux interfaces. Signal demande encore horn. Mark demande show. La classe remplit les deux corps. main appelle les deux méthodes.

Compilez avec javac Yard.java, puis exécutez java Yard. L’écran montre honk, puis truck. La première ligne vient de la promesse Signal remplie sur Truck. La deuxième ligne vient de la promesse Mark remplie sur la même classe. Séparez les noms d’interface par une virgule dans la liste implements : implements Signal, Mark.
Relisez l’en-tête de classe une fois. Une classe. Deux interfaces. Deux corps de méthode. C’est l’image débutant de tenir plus d’une promesse sans deux parents extends. Java laisse une classe étendre une seule classe ; elle peut implémenter plusieurs interfaces. Cette page montre cette liste à virgules dans un petit fichier Yard.
Si vous omettez show alors que Mark est listé, javac refuse car chaque méthode d’interface listée a besoin d’un corps. Si vous omettez Mark de la liste implements mais écrivez encore show, vous avez une méthode ordinaire, pas un accomplissement d’interface pour Mark. Gardez les deux noms sur la ligne de classe quand vous voulez que les deux promesses soient vérifiées.

Comparé à la redéfinition via extends

Sur la page de redéfinition, Truck extends Car et a réécrit horn qui avait déjà un corps parent. Sur cette page, Signal commence sans corps, et Truck implements Signal fournit le premier corps. Vous compilez encore Yard.java et exécutez java Yard. Vous appelez encore t.horn(). Les nouveaux jetons sont interface, implements et — dans la deuxième démo — une liste implements séparée par des virgules.
Si un fichier override restant est encore ouvert, vous verrez extends Car et peut-être beep à côté de honk. Passez au fichier pédagogique d’interface pour que le haut du fichier montre interface Signal et que la ligne de classe montre implements. Gardez les démos enum hors de cette page. Gardez la saisie clavier hors de cette page.

Ce que cette page laisse pour les enums

Cette page remplit les méthodes d’interface avec implements. La page suivante montre les enums, où un type liste un ensemble fixe de valeurs nommées. Restez avec les promesses d’interface ici. Ne remplacez pas encore les démos d’aujourd’hui par une liste enum comme exigence.
Quand vous utiliserez plus tard les enums, vous pourrez encore implémenter des interfaces sur d’autres types dans le même programme. Traitez cette page comme la moitié interface de cette histoire voisine. Terminez les deux démos Yard jusqu’à ce que honk — puis honk plus truck — semblent automatiques avant d’ouvrir la leçon enums.

Avant les enums

Vous pouvez écrire interface Signal avec horn() vide, l’implémenter sur Truck, et voir honk depuis t.horn(). Vous pouvez implémenter Signal et Mark sur une classe et voir honk puis truck. Compilez Yard.java et exécutez java Yard pour chaque démo conservée. La classe a tenu les promesses d’interface. La page suivante est les enums, où un type liste des noms fixes.
Gardez la démo à une interface avec honk pour une histoire implements claire. Gardez la démo à deux interfaces pour une liste à virgules claire. Gardez les fichiers enum 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 quand la deuxième démo imprime aussi truck après show() — les interfaces ont fait leur travail pour cette leçon et vous êtes prêt pour le sujet suivant sur les enums.
Un dernier passage dans le dossier : un Yard public, des en-têtes d’interface avec méthodes vides, une classe qui les implements, pas d’attente clavier, pas d’enum forcé. Exécutez javac Yard.java et java Yard une fois de plus sur la démo ouverte. Si l’écran imprime encore les remplissages d’interface que vous avez écrits, les promesses sont solides et le cours peut passer aux enums à la page suivante.