Java Academy · Lezione

Interfacce nella pratica

Utilizzare le interfacce come tipi, passarle ai metodi e sostituire facilmente le implementazioni. Esercitarsi con piccoli schemi per un codice flessibile.

Interfacce nella pratica è una lezione Java Academy gratuita su CoddyKit. Questa è la lezione 1 di 3. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Java Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Java Academy include 3 lezioni in totale.

Panoramica

Le interfacce nella pratica: trattate le capacità come tipi e mantenete il codice chiamante indipendente dalle classi concrete. È possibile passare un'interfaccia a un metodo, memorizzarla in un elenco e sostituirla con un'implementazione diversa quando necessario.

Interfaccia come parametro

Quando i metodi accettano il tipo interface come parametro, si ottiene maggiore flessibilità:

Il codice chiamante resta invariato.
È possibile usare classi diverse che implementano lo stesso contratto.
Nei test, è possibile inserire rapidamente un Fake o uno Stub e fare una prova.

Codice: capacità Printable

Il metodo usa il contratto Printable, non la classe concreta; anche se le implementazioni cambiano, il codice chiamante resta invariato.

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());
  }
}

Interfaccia come tipo restituito

A volte un metodo factory restituisce un'interfaccia. Il codice chiamante vede solo le capacità e non ha bisogno di conoscere la classe reale. Questo riduce le dipendenze e aumenta la modularità.

Codice: Strategy con Formatter

Lo stesso metodo funziona con diverse implementazioni di Formatter. Abbiamo potuto cambiare il comportamento senza modificare 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()));
  }
}

Codice: elenco di interfacce

Un array o una lista può contenere elementi di tipo interfaccia. Il ciclo effettua una chiamata uniforme; ogni elemento esegue la propria implementazione.

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
    }
  }
}

Verifica pratica sulle interfacce

Verifica rapida: perché è utile "programmare su un'interfaccia"?

Riepilogo

Riepilogo: utilizzare un tipo di interfaccia per parametri, valori restituiti e collezioni rende il codice flessibile. È possibile sostituire le implementazioni e provare rapidamente il codice con oggetti fittizi nei test.

Domande Frequenti

La lezione «Interfacce nella pratica» è gratuita?

Sì — il testo completo di «Interfacce nella pratica» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Java Academy, passa a CoddyKit PRO. Il corso Java Academy include 3 lezioni in totale.

Cosa imparerò in «Interfacce nella pratica»?

Utilizzare le interfacce come tipi, passarle ai metodi e sostituire facilmente le implementazioni. Esercitarsi con piccoli schemi per un codice flessibile. Eserciti Java Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Java Academy?

Non è richiesta alcuna esperienza precedente. Java Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 1 di 3.

Quanto tempo richiede la lezione «Interfacce nella pratica»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Java Academy?

Sì. Ogni lezione Java Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

← Torna a Java Academy