Un'interfaccia dichiara un contratto — un insieme di metodi che un tipo deve fornire — con nessuna (o minima) implementazione. Una classe astratta è una classe parzialmente implementata che può contenere stato condiviso e metodi concreti ma non può essere istanziata. La distinzione fondamentale: una classe può implementare molte interfacce ma ereditare da una sola classe.
| Interfaccia | Classe astratta |
|---|
| Istanziabile | No | No |
| Ereditarietà multipla | Sì (implementare molte) | No (base singola) |
| Campi / stato | No (solo costanti*) | Sì |
| Corpi dei metodi | Solo metodi default* | Sì, completamente |
| Modelli | Una capacità ("può fare") | Un è un con codice condiviso |
*Java moderno consente metodi default e costanti; lo spirito rimane comunque.
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 è un Shape (una base singola, codice condiviso) e può essere Drawable (una capacità mista).
Scegliere male blocca il tuo design: una base astratta forza una singola linea di ereditarietà, mentre un'interfaccia mantiene i tipi liberi di combinare capacità.
Le interfacce sono l'opzione predefinita preferita per il disaccoppiamento — dipendere da un contratto piuttosto che da una gerarchia concreta mantiene il codice testabile e estensibile.
Una raccolta di domande di colloquio IT con risposte dettagliate — da Junior a Senior.
Dona