Wat is het verschil tussen een interface en een abstracte klasse?

Question

Accepted Answer

Beide definiëren abstracte types die niet rechtstreeks kunnen worden geïnstantieerd en bedoeld zijn om te worden geïmplementeerd/uitgebreid — maar ze dienen verschillende ontwerpdoeleinden. De belangrijkste onderscheidingen zijn **meervoudige overerving**, **status** en de relatie die ze modelleren.

## Interface — een contract ("can-do" / mogelijkheid)

```java
public interface Drawable {
    void draw();                          // abstract method (implicitly public abstract)

default void render() {                // default method — has a body (Java 8+)
        System.out.println("rendering");
    }
    int MAX = 100;                         // implicitly public static final (constant only)
}

class Circle implements Drawable {
    public void draw() { /* must implement */ }
}
```

Een interface definieert een **contract** van gedrag. Een klasse kan **meerdere** interfaces implementeren — dit is hoe Java een vorm van meervoudige overerving bereikt. Interfaces hebben (traditioneel) geen instantiestatus.

## Abstracte klasse — een gedeeltelijke basis ("is-a" met gedeelde code)

```java
public abstract class Animal {
    protected String name;                 // ✅ can have instance FIELDS (state)

public Animal(String name) {           // ✅ can have a constructor
        this.name = name;
    }
    public abstract void makeSound();      // abstract — subclasses must implement
    public void sleep() {                   // ✅ concrete method with shared logic
        System.out.println(name + " sleeps");
    }
}

class Dog extends Animal {                 // can extend only ONE class
    public Dog(String n) { super(n); }
    public void makeSound() { System.out.println("Woof"); }
}
```

Een abstracte klasse kan **status (velden)**, **constructors** en concrete methoden met gedeelde implementatie bevatten — maar een klasse kan slechts **één** abstracte klasse uitbreiden (enkelvoudige overerving).

## Belangrijkste verschillen

```text
                    Interface              Abstract class
Multiple inheritance ✓ (implement many)    ✗ (extend only one)
Instance fields/state ✗ (constants only)   ✓ (fields)
Constructor           ✗                    ✓
Method bodies         default/static only  ✓ (concrete methods)
Models                capability ("can-do") "is-a" with shared base
```

## Wanneer welke gebruiken

```text
Interface → define a capability multiple unrelated classes can have
            (Comparable, Runnable, Serializable); when you need multiple inheritance
Abstract class → share common state + code among closely related subclasses
            (a base class with fields and partial implementation)
```

## Waarom het belangrijk is

Het kiezen tussen een interface en een abstracte klasse is een fundamentele Java-ontwerpbeslissing.

Interfaces definiëren **contracten/mogelijkheden** en stellen een klasse in staat om er veel van te implementeren (Java's antwoord op meervoudige overerving) — ideaal voor cross-cutting mogelijkheden.

Abstracte klassen bieden een **gedeelde basis met status en gedeeltelijke implementatie** voor nauw verwante subklassen, maar beperken u tot enkelvoudige overerving.

Het begrijpen van de afwegingen (meervoudige implementatie versus gedeelde status/constructors, mogelijkheid versus is-a relatie) leidt goed API- en klasseën-hiërarchie-ontwerp.

Met Java 8+ standaardmethoden die de lijn vervagen, wetende wanneer elk past — en de kernbeperkingen (één abstracte klasse maar veel interfaces, status alleen in abstracte klassen) — is essentieel voor het ontwerpen van flexibele, goed gestructureerde code.