Java Academy · Leçon

Les interfaces en pratique

Utilisez les interfaces comme types, transmettez-les aux méthodes et remplacez facilement les implémentations. Entraînez-vous à de petits schémas pour un code flexible.

Les interfaces en pratique est une leçon Java Academy gratuite sur CoddyKit. Ceci est la leçon 1 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.

Vue d'ensemble

Les interfaces en pratique : traitez les capacités comme des types et gardez le code appelant indépendant des classes concrètes. Vous pouvez transmettre une interface à une méthode, la stocker dans une liste et la remplacer par une autre implémentation lorsque c'est nécessaire.

Interface comme paramètre

Lorsque les méthodes prennent un type d'interface comme paramètre, elles gagnent en souplesse :

Le code appelant reste inchangé.
Des classes différentes peuvent appliquer le même contrat et être utilisées.
Lors des tests, vous pouvez brancher un faux objet ou un bouchon et expérimenter rapidement.

Code : capacité Printable

La méthode utilise le contrat Printable, et non la classe concrète ; le code appelant reste inchangé même si les implémentations changent.

public class Main {
  // 1) Define a tiny capability
  static interface Printable { void print(); }

  // 2) Two implementations
  static class TextDoc implements Printable {
    public void print() { System.out.println("[TextDoc] Printing text pages"); }
  }
  static class Photo implements Printable {
    public void print() { System.out.println("[Photo] Printing a photo"); }
  }

  // 3) A method that depends on capability, not class
  static void runJob(Printable p) {
    p.print(); // caller does not care which class it is
  }

  public static void main(String[] args) {
    runJob(new TextDoc());
    runJob(new Photo());
  }
}

Interface comme type de retour

Parfois, une méthode fabrique renvoie une interface. L'appelant ne voit que les capacités ; il n'a pas besoin de connaître la classe réelle. Cela réduit le couplage et augmente la modularité.

Code : stratégie avec Formatter

La même méthode fonctionne avec différentes implémentations de Formatter. Nous avons pu modifier le comportement sans changer la classe.

public class Main {
  // Strategy: different ways to format text
  static interface Formatter { String format(String s); }

  static class UpperFormatter implements Formatter {
    public String format(String s) { return s.toUpperCase(); }
  }
  static class LowerFormatter implements Formatter {
    public String format(String s) { return s.toLowerCase(); }
  }

  // Uses any Formatter
  static String show(String title, Formatter f) {
    return title + " -> " + f.format(title);
  }

  public static void main(String[] args) {
    System.out.println(show("Hello", new UpperFormatter()));
    System.out.println(show("Hello", new LowerFormatter()));
  }
}

Code : liste d’interfaces

Un tableau ou une liste peut être de type interface. La boucle effectue un seul type d’appel ; chaque élément exécute sa propre implémentation.

public class Main {
  static interface Task { void run(); }

  static class EmailTask implements Task { public void run(){ System.out.println("Send email"); } }
  static class ReportTask implements Task { public void run(){ System.out.println("Generate report"); } }
  static class CleanupTask implements Task { public void run(){ System.out.println("Clean temp files"); } }

  public static void main(String[] args) {
    Task[] queue = { new EmailTask(), new ReportTask(), new CleanupTask() };
    for (int i = 0; i < queue.length; i = i + 1) {
      queue[i].run(); // same call, different behavior
    }
  }
}

Vérification pratique des interfaces

Vérification rapide : Pourquoi est-il utile de « programmer avec une interface » ?

Récapitulatif

Récapitulatif : Utiliser un type interface pour un paramètre, une valeur de retour ou une collection rend le code flexible. Vous pouvez remplacer les implémentations et essayer rapidement des objets fictifs dans les tests.

Questions Fréquemment Posées

La leçon « Les interfaces en pratique » est-elle gratuite ?

Oui — le texte complet de « Les interfaces en pratique » 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 « Les interfaces en pratique » ?

Utilisez les interfaces comme types, transmettez-les aux méthodes et remplacez facilement les implémentations. Entraînez-vous à de petits schémas pour un code flexible. 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 1 sur 3.

Combien de temps prend la leçon « Les interfaces en pratique » ?

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

← Retour à Java Academy