Java Academy · Les

Interfaces (introductie en verschillen)

Definieer interfaces, implementeer ze in klassen en vergelijk ze met abstracte klassen. Leer default-methoden en meerdere implementaties.

Les 2 van 38 stappen

Interfaces (introductie en verschillen) is een gratis Java Academy-les op CoddyKit. Dit is les 2 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.

Wat is een interface?

Interface: een contract met de methodesignaturen die een klasse moet aanbieden. Gebruik het om een vaardigheid te beschrijven, zoals Drivable of Printable, zonder een klassenhiërarchie vast te leggen.

Code: een interface implementeren

Klassen implementeren interfaces om bepaald gedrag te garanderen. Je kunt naar het object verwijzen met het interfacetype en de gedeclareerde methoden aanroepen.

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 versus abstracte klassen

Abstracte klasse = is-een-relatie met gedeelde code. Interface = kan-doen-vaardigheid. Een klasse kan één klasse uitbreiden, maar veel interfaces implementeren. Zo blijven ontwerpen flexibel en voorkom je diepe boomstructuren.

Code: standaardmethode

Interfaces kunnen standaardmethoden met code bevatten. Klassen die de interface implementeren, nemen dat kleine stukje gedrag automatisch over.

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

Meerdere interfaces

Een klasse kan meerdere interfaces tegelijk implementeren (bijv. Drivable en Maintainable). Zo modelleer je vaardigheden zonder een vaste keten van superklassen op te leggen.

Code: meerdere interfaces

Eén klasse implementeert beide interfaces. Afhankelijk van de context kun je haar behandelen als Drivable, Maintainable of als haar concrete type.

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

Controle van interfaces

Korte controle: welke uitspraak over interfaces in Java is juist?

Samenvatting

Samenvatting: Interfaces definiëren gedragscontracten; klassen implementeren ze. Gebruik standaardmethoden voor kleine gedeelde stukjes code en combineer indien nodig meerdere vaardigheden in één klasse.

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

Veelgestelde vragen

Is de les “Interfaces (introductie en verschillen)” gratis?

Ja — de volledige tekst van “Interfaces (introductie en verschillen)” 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 (introductie en verschillen)”?

Definieer interfaces, implementeer ze in klassen en vergelijk ze met abstracte klassen. Leer default-methoden en meerdere implementaties. 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 2 van 3.

Hoe lang duurt de les “Interfaces (introductie en verschillen)”?

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

  1. Abstracte klassen
  2. Interfaces (introductie en verschillen)
  3. Upcasten/downcasten en instanceof
← Terug naar Java Academy