Java Academy · Lektion

Schnittstellen in der Praxis

Verwenden Sie Schnittstellen als Typen, übergeben Sie sie an Methoden und tauschen Sie Implementierungen einfach aus. Üben Sie kleine Muster für flexiblen Code.

Schnittstellen in der Praxis ist eine kostenlose Java Academy-Lektion auf CoddyKit. Dies ist Lektion 1 von 3. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Java Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Java Academy-Kurs umfasst insgesamt 3 Lektionen.

Überblick

Interfaces in der Praxis: Behandeln Sie Fähigkeiten als Typen und halten Sie aufrufenden Code von konkreten Klassen unabhängig. Sie können ein Interface an eine Methode übergeben, in einer Liste speichern und bei Bedarf durch eine andere Implementierung ersetzen.

Interface als Parameter

Wenn Methoden den Typ interface als Parameter akzeptieren, werden sie flexibler:

Der aufrufende Code bleibt unverändert.
Verschiedene Klassen können denselben Vertrag implementieren und verwendet werden.
In Tests können Sie schnell ein Fake oder Stub einsetzen.

Code: Printable-Fähigkeit

Die Methode verwendet den Vertrag Printable und nicht die konkrete Klasse. Selbst wenn sich die Implementierungen ändern, bleibt der aufrufende Code unverändert.

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 als Rückgabetyp

Manchmal gibt eine Factory-Methode ein Interface zurück. Der aufrufende Code sieht nur die verfügbaren Fähigkeiten und muss die konkrete Klasse nicht kennen. Das verringert Abhängigkeiten und erhöht die Modularität.

Code: Strategy mit Formatter

Dieselbe Methode funktioniert mit verschiedenen Formatter-Implementierungen. Wir konnten das Verhalten ändern, ohne die Klasse zu verändern.

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: Interface-Liste

Ein Array/eine Liste kann vom Typ eines Interfaces sein. Die Schleife führt denselben Aufruf aus; jedes Element führt seine eigene Implementierung aus.

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

Übungstest zu Interfaces

Kurzer Check: Warum ist es sinnvoll, „gegen ein Interface zu programmieren“?

Zusammenfassung

Zusammenfassung: Die Verwendung eines Interface-Typs als Parameter, Rückgabewert oder Collection macht den Code flexibel. Sie können Implementierungen austauschen und im Test schnell mit Mock-Objekten experimentieren.

Häufig gestellte Fragen

Ist die Lektion „Schnittstellen in der Praxis“ kostenlos?

Ja — der vollständige Text von „Schnittstellen in der Praxis“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Java Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Java Academy-Kurs umfasst insgesamt 3 Lektionen.

Was lerne ich in „Schnittstellen in der Praxis“?

Verwenden Sie Schnittstellen als Typen, übergeben Sie sie an Methoden und tauschen Sie Implementierungen einfach aus. Üben Sie kleine Muster für flexiblen Code. Du übst Java Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Java Academy zu starten?

Keine Vorkenntnisse erforderlich. Java Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 1 von 3.

Wie lange dauert die Lektion „Schnittstellen in der Praxis“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Java Academy-Lektion Code schreiben und ausführen?

Ja. Jede Java Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu Java Academy