Java Academy · Les

Interfaces in de praktijk

Gebruik interfaces als typen, geef ze door aan methoden en wissel eenvoudig tussen implementaties. Oefen kleine patronen voor flexibele code.

Les 1 van 38 stappen

Interfaces in de praktijk is een gratis Java Academy-les op CoddyKit. Dit is les 1 van 3. Je kunt de volledige les hieronder gratis lezen en daarna in de browser praktisch oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Java Academy. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Java Academy bevat in totaal 3 lessen.

Overzicht

Interfaces in de praktijk: behandel vaardigheden als typen en houd aanroepende code onafhankelijk van concrete klassen. Je kunt een interface aan een methode doorgeven, in een lijst opslaan en indien nodig vervangen door een andere implementatie.

Interface als parameter

Methoden worden flexibeler als ze het type interface als parameter accepteren:

De aanroepende code blijft hetzelfde.
Verschillende klassen kunnen hetzelfde contract implementeren en worden gebruikt.
In een test kun je snel een Fake of Stub gebruiken en uitproberen.

Code: Printable-vaardigheid

De methode gebruikt het contract Printable, niet de concrete klasse; ook als implementaties veranderen, blijft de aanroepende code hetzelfde.

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 retourtype

Soms retourneert een factorymethode een interface. De aanroeper ziet alleen de mogelijkheden; die hoeft de echte klasse niet te kennen. Dat vermindert afhankelijkheden en vergroot de modulariteit.

Code: Strategy met Formatter

Dezelfde methode werkt met verschillende Formatter-implementaties. We konden het gedrag wijzigen zonder de klasse te veranderen.

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: lijst met interfaces

Een array of lijst kan van een interfacetype zijn. De lus doet één type aanroep; elk element voert zijn eigen implementatie uit.

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

Controle-oefening voor interfaces

Korte controle: waarom is het nuttig om "tegen een interface te programmeren"?

Beantwoord dit in de interactieve les

Herhaling

Herhaling: een interfacetype gebruiken voor parameters, retourwaarden en collecties maakt code flexibel. Je kunt implementaties verwisselen en tijdens het testen snel met nepobjecten experimenteren.

Gratis beginnen

Leer Java met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen: 104
Lessen: 374

Gratis beginnen met leren Bekijk de volledige cursus

Veelgestelde vragen

Is de les “Interfaces in de praktijk” gratis?

Ja — de volledige tekst van “Interfaces in de praktijk” kun je hier gratis op het web lezen. Als je interactief wilt oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is, en de rest van de cursus Java Academy wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus Java Academy bevat in totaal 3 lessen.

Wat leer ik in “Interfaces in de praktijk”?

Gebruik interfaces als typen, geef ze door aan methoden en wissel eenvoudig tussen implementaties. Oefen kleine patronen voor flexibele code. Je oefent met Java Academy door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met Java Academy te beginnen?

Ervaring vooraf is niet nodig. Java Academy op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 1 van 3.

Hoe lang duurt de les “Interfaces in de praktijk”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over Java Academy?

Ja. Elke les over Java Academy bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

← Terug naar Java Academy