Een interface declareert een contract — een set methoden die een type moet bieden — met geen (of minimale) implementatie. Een abstracte klasse is een gedeeltelijk geïmplementeerde klasse die gedeelde status en concrete methoden kan bevatten, maar niet kan worden geïnstantieerd. Het cruciale verschil: een klasse kan veel interfaces implementeren, maar kan slechts van één klasse erven.
| Interface | Abstracte klasse | |
|---|---|---|
| Instantieerbaar | Nee | Nee |
| Meervoudige overerving | Ja (veel implementeren) | Nee (enkele basis) |
| Velden / status | Nee (alleen constanten*) | Ja |
| Methodeteksten | Alleen standaardmethoden* | Ja, volledig |
| Modellen | Een mogelijkheid ("kan doen") | Een is-een met gedeelde code |
*Modern Java staat default methoden en constanten toe; de essentie blijft gelijk.
interface Drawable { // a capability
void draw();
}
abstract class Shape { // shared identity + state
protected String color;
Shape(String color) { this.color = color; }
abstract double area(); // subclasses must define
String describe() { // shared concrete behavior
return color + " shape, area=" + area();
}
}
class Circle extends Shape implements Drawable {
private double r;
Circle(String c, double r) { super(c); this.r = r; }
double area() { return Math.PI * r * r; }
public void draw() { /* render */ }
}
Circle is een Shape (één basis, gedeelde code) en kan een Drawable zijn (een mogelijkheid gemengd in).
Een verkeerde keuze vergrendelt uw ontwerp: een abstracte basis forceert een enkele erfelijner, terwijl een interface types vrij laat om mogelijkheden te combineren.
Interfaces zijn de voorkeur voor ontkoppeling — afhankelijk van een contract in plaats van een concrete hiërarchie houdt code testbaar en uitbreidbaar.