O interfață declară un contract — o serie de metode pe care un tip trebuie să le furnizeze — fără (sau cu implementare minimă). O clasă abstractă este o clasă parțial implementată care poate deține stare partajată și metode concrete, dar nu poate fi instanțiată. Distincția cheie: o clasă poate implementa multe interfețe, dar poate moșteni din doar o singură clasă.
| Interfață | Clasă abstractă | |
|---|---|---|
| Instantaneoasă | Nu | Nu |
| Moștenire multiplă | Da (implementează multe) | Nu (bază unică) |
| Câmpuri / stare | Nu (doar constante*) | Da |
| Corpuri de metode | Doar metode implicite* | Da, complet |
| Modele | O capacitate ("poate face") | O relație este-un cu cod partajat |
*Java modern permite metode default și constante; esența se menține.
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 este un Shape (o bază, cod partajat) și poate fi Drawable (o capacitate amestecată).
A alege greșit vă blochează designul: o bază abstractă forțează o singură linie de moștenire, în timp ce o interfață ține tipurile libere să combine capacități.
Interețele sunt implicit-ul preferat pentru decuplare — a depinde de un contract în loc de o ierarhie concretă menține codul testabil și extensibil.