Leçons du module (1/2)
Interfaces
Alors que les classes abstraites peuvent contenir à la fois du code partiellement implémenté et des champs d'instance, les interfaces en Java sont des contrats de pur comportement. Une interface définit ce qu'une classe doit savoir faire, mais pas comment elle le fait.
Cela permet un découplage total entre la définition des opérations et leur implémentation réelle.
Définir une Interface (interface)
On utilise le mot-clé interface. Toutes les méthodes déclarées dans une interface sont implicitement public et abstract (il n'est pas nécessaire de le spécifier) :
interface Drivable {
void startEngine();
void stopEngine();
}
Implémenter une Interface (implements)
Une classe implémente une interface en utilisant le mot-clé implements et est obligée de fournir l'implémentation (avec le corps) pour toutes les méthodes définies :
class Motorcycle implements Drivable {
@Override
public void startEngine() {
System.out.println("Rombo del motore acceso!");
}
@Override
public void stopEngine() {
System.out.println("Motore spento.");
}
}
Avantages des Interfaces
- Héritage Multiple : En Java, une classe ne peut étendre qu'une seule classe parente (héritage simple), mais elle peut implémenter plusieurs interfaces en même temps.
Code
class HybridCar implements Drivable, Chargeable { ... } - Découplage : Vous pouvez définir des variables en utilisant le type de l'interface. Tout objet qui implémente cette interface peut être attribué à cette variable.
Code
Drivable vehicle = new Motorcycle(); vehicle.startEngine();
Constantes dans les Interfaces
Dans les interfaces, il est possible de déclarer des champs. Ces champs sont implicitement public static final (c'est-à-dire des constantes de classe), même si vous ne spécifiez pas ces modificateurs. Par conséquent, ils doivent être initialisés immédiatement au moment de la déclaration :
interface PhysicsConstants {
double GRAVITY = 9.81; // Implicitamente public static final
}
Méthodes par Défaut (default)
À partir de Java 8, il est possible de définir des méthodes avec une implémentation par défaut à l'intérieur d'une interface en utilisant le mot-clé default. Ces méthodes n'obligent pas les classes qui implémentent l'interface à les surcharger, fournissant ainsi un comportement de secours :
interface Logger {
void log(String message);
// Metodo di default con corpo
default void logError(String message) {
log("ERRORE: " + message);
}
}
À toi de jouer
Créez l'interface Flyable avec la méthode void fly(). Implémentez ensuite la classe Bird pour qu'elle implémente Flyable et affiche Flying à l'écran.
Afficher l'indice
Dans Flyable, écrivez `void fly();`. Dans la classe Bird, implémentez la méthode en la marquant avec `@Override public void fly() { System.out.println('Flying'); }`.
Solution disponible après 3 tentatives
Définissez l'interface Drawable avec la méthode void draw(). Ensuite, implémentez la classe Rectangle pour qu'elle implémente Drawable et affiche Drawing Rectangle.
Afficher l'indice
Définissez `void draw();` dans l'interface. Dans Rectangle, utilisez `@Override public void draw() { System.out.println('Drawing Rectangle'); }`.
Solution disponible après 3 tentatives
Complétez l'interface Swimmable en définissant la méthode void swim(). Ensuite, complétez la classe Duck pour qu'elle implémente à la fois Flyable et Swimmable, en affichant Flying dans la méthode fly() et Swimming dans la méthode swim().
Afficher l'indice
Déclarez `void swim();` dans Swimmable. Déclarez `class Duck implements Flyable, Swimmable` et implémentez les deux méthodes en affichant les chaînes de caractères requises.
Solution disponible après 3 tentatives