0Pricing
Java Academy · Leçon

Interfaces (introduction et comparaison)

Définissez des interfaces, implémentez-les dans des classes et comparez-les aux classes abstraites. Découvrez les méthodes par défaut et les implémentations multiples.

Interfaces (introduction et comparaison) est une leçon Java Academy gratuite sur CoddyKit. Ceci est la leçon 2 sur 3. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Java Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Java Academy comprend 3 leçons au total.

Qu'est-ce qu'une interface ?

Interface : un contrat qui répertorie les signatures de méthodes qu'une classe doit fournir. Utilisez-la pour décrire une capacité, comme Drivable ou Printable, sans imposer de hiérarchie de classes.

Code : implémenter une interface

Les classes implémentent des interfaces pour garantir un certain comportement. Vous pouvez référencer l'objet par son type d'interface et appeler les méthodes déclarées.

public class Main {
  // Interface that declares a capability
  static interface Drivable {
    void drive(); // method to implement
  }

  // A class implements the interface
  static class Car implements Drivable {
    public void drive() {
      System.out.println("Car is driving");
    }
  }

  public static void main(String[] args) {
    Drivable d = new Car(); // upcast to interface
    d.drive();              // runs Car's method
  }
}

Interfaces et classes abstract

Classe abstract = relation « est une » avec du code partagé. Interface = capacité. Une classe peut étendre une seule classe, mais implémenter plusieurs interfaces, ce qui permet de garder des conceptions flexibles et d'éviter les hiérarchies trop profondes.

Code : méthode par défaut

Les interfaces peuvent contenir des méthodes par défaut avec du code. Les classes qui implémentent l'interface héritent automatiquement de ce petit comportement.

public class Main {
  // Interface with a default method (has a body)
  static interface Greeter {
    void greet(String name);
    default void sayBye() { // default provides a reusable tiny implementation
      System.out.println("Bye");
    }
  }

  static class SimpleGreeter implements Greeter {
    public void greet(String name) {
      System.out.println("Hello, " + name);
    }
  }

  public static void main(String[] args) {
    Greeter g = new SimpleGreeter();
    g.greet("Ada");
    g.sayBye(); // default method from the interface
  }
}

Plusieurs interfaces

Une classe peut implémenter plusieurs interfaces à la fois (par exemple, Drivable et Maintainable). Cela permet de modéliser des capacités sans imposer une chaîne fixe de classes parentes.

Code : plusieurs interfaces

Une classe implémente les deux interfaces. Vous pouvez la considérer comme Drivable, Maintainable ou comme son type concret, selon le contexte.

public class Main {
  static interface Drivable { void drive(); }
  static interface Maintainable { void maintain(); }

  static class ServiceCar implements Drivable, Maintainable {
    public void drive() { System.out.println("ServiceCar driving"); }
    public void maintain() { System.out.println("ServiceCar maintenance"); }
  }

  public static void main(String[] args) {
    ServiceCar s = new ServiceCar();
    s.drive();
    s.maintain();
  }
}

Vérification des interfaces

Vérification rapide : quelle affirmation au sujet des interfaces en Java est correcte ?

Récapitulatif

Récapitulatif : les interfaces définissent des contrats de comportement, et les classes les implémentent. Utilisez les méthodes par défaut pour un petit code partagé et combinez plusieurs capacités dans une seule classe lorsque c'est nécessaire.

Questions Fréquemment Posées

La leçon « Interfaces (introduction et comparaison) » est-elle gratuite ?

Oui — le texte complet de « Interfaces (introduction et comparaison) » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Java Academy, passe à CoddyKit PRO. Le cours Java Academy comprend 3 leçons au total.

Qu'est-ce que j'apprendrai dans « Interfaces (introduction et comparaison) » ?

Définissez des interfaces, implémentez-les dans des classes et comparez-les aux classes abstraites. Découvrez les méthodes par défaut et les implémentations multiples. Tu pratiques Java Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Java Academy ?

Aucune expérience préalable n'est requise. Java Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 2 sur 3.

Combien de temps prend la leçon « Interfaces (introduction et comparaison) » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Java Academy ?

Oui. Chaque leçon Java Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Classes abstraites
  2. Interfaces (introduction et comparaison)
  3. Conversion ascendante/descendante et instanceof
← Retour à Java Academy