1. Che cos’è un’interfaccia?
Se una classe astratta è il progetto di una casa, un’interfaccia è piuttosto un accordo o un «contratto» per svolgere determinati lavori. Per esempio, se chiami un idraulico, ti aspetti che sappia «riparare il rubinetto» e «eliminare una perdita». Come lo farà — non ti interessa: l’importante è il risultato. In Java un’interfaccia è proprio un contratto del genere: dice quali metodi devono essere implementati, ma non dice come.
In breve e al sodo:
Un’interfaccia è un tipo speciale in Java che definisce un insieme di metodi che le classi che aderiscono a quell’interfaccia sono tenute a implementare.
- L’interfaccia descrive solo «che cosa fare», non «come farlo».
- Fino a Java 8 le interfacce non contenevano l’implementazione dei metodi.
- Un’interfaccia è un contratto puro: se una classe implementa un’interfaccia, deve implementarne tutti i metodi.
Perché è comodo?
- Si possono «agganciare» a una classe più interfacce — cioè attribuirle più «ruoli».
- Consente di costruire architetture flessibili ed estendibili, in cui le classi possono implementare diverse capacità.
- Le interfacce sono ampiamente usate nella libreria standard di Java (ad esempio, Comparable, Serializable, Runnable ecc.).
2. Sintassi di dichiarazione di un’interfaccia
Dichiarare un’interfaccia in Java è semplicissimo. Si usa la parola chiave interface. Fino a Java 8 i metodi di un’interfaccia erano per impostazione predefinita public abstract, anche se non specificato esplicitamente. Questo significa: il metodo deve essere implementato nella classe che implementa l’interfaccia.
Esempio di interfaccia
public interface Movable {
void move(int x, int y);
}
- Qui dichiariamo l’interfaccia Movable (si può rendere come «movibile» o «che sa muoversi»).
- All’interno è dichiarato il metodo move(int x, int y). Non c’è il corpo del metodo — solo la firma. Questo è il «contratto»: «se implementi Movable — allora implementa move».
Caratteristiche della sintassi
- I metodi in un’interfaccia non hanno corpo (fino a Java 8).
- Tutti i metodi di un’interfaccia sono per impostazione predefinita public abstract (si può non scriverlo esplicitamente).
- Un’interfaccia può contenere solo costanti (public static final), non campi ordinari.
Esempio con costante
public interface Constants {
int MAX_SPEED = 100; // public static final per impostazione predefinita
}
3. Differenza tra interfaccia e classe
Un’interfaccia non è una classe! Vediamo qual è la differenza.
| Classe (anche astratta) | Interfaccia |
|---|---|
| Può contenere campi (stato) | Non può contenere campi (solo costanti) |
| Può contenere l’implementazione dei metodi | Fino a Java 8 le interfacce non potevano contenere implementazioni, solo le firme |
| Può essere istanziata con new (se non è astratta) | Non può essere creata direttamente |
| Ereditarietà singola (extends) | Una classe può implementare più interfacce (implements) |
| Usata per «che cos’è» | Usata per «che cosa sa fare» |
Una classe implementa un’interfaccia con implements
public class Robot implements Movable {
@Override
public void move(int x, int y) {
System.out.println("Il robot si muove al punto (" + x + ", " + y + ")");
}
}
- La classe Robot implementa l’interfaccia Movable.
- La parola chiave implements significa «implementa».
- È obbligatorio implementare tutti i metodi dell’interfaccia (altrimenti si avrà un errore di compilazione).
- Non dimenticare l’annotazione @Override — non è obbligatoria, ma aiuta il compilatore e te a non sbagliare.
4. Esempio di utilizzo di un’interfaccia
Scriviamo un esempio semplice per vedere come funziona nella pratica. Immagina di avere l’interfaccia Movable e di voler permettere a diverse classi di «muoversi»: robot, automobile, animale...
Passo 1. Dichiariamo l’interfaccia
public interface Movable {
void move(int x, int y);
}
Passo 2. Implementiamo l’interfaccia in una classe
public class Robot implements Movable {
@Override
public void move(int x, int y) {
System.out.println("Il robot si sposta al punto (" + x + ", " + y + ")");
}
}
Passo 3. Usiamo l’interfaccia
public class Main {
public static void main(String[] args) {
Movable m = new Robot(); // Variabile di tipo interfaccia!
m.move(10, 20); // Stamperà: Il robot si sposta al punto (10, 20)
}
}
Nota bene
- Possiamo dichiarare una variabile di tipo interfaccia (Movable m) e assegnarle un oggetto di una classe che implementa quell’interfaccia (new Robot()).
- Questo permette di scrivere codice universale che lavora con qualsiasi oggetto «movibile» senza sapere quale classe sia realmente.
Errore di compilazione se non si implementa il metodo
Error: Class 'Robot' must either be declared abstract or implement abstract method 'move(int, int)' in 'Movable'
Questa è la forza dell’interfaccia: garantisce che tutte le classi che la implementano avranno i metodi necessari.
5. Interfacce nella libreria standard di Java
Le interfacce non sono solo un argomento «scolastico». Sono usate attivamente in tutta la libreria standard di Java. Ecco alcuni esempi:
- Comparable<T> — interfaccia per confrontare oggetti (ad esempio durante l’ordinamento).
- Runnable — interfaccia per avviare un thread.
- Serializable — interfaccia marker che indica che un oggetto può essere serializzato.
- List, Set, Map — interfacce delle collezioni.
Esempio: Comparable
public class Person implements Comparable<Person> {
String name;
int age;
// Costruttore e altri metodi...
@Override
public int compareTo(Person other) {
return this.age - other.age;
}
}
Ora gli oggetti Person possono essere ordinati, perché implementano l’interfaccia Comparable.
6. Schema visivo: come funziona un’interfaccia
+-------------------+ +-------------------+
| interface | | class |
| Movable |<--------| Robot |
|-------------------| |-------------------|
| +move(int, int) | | +move(int, int) |
+-------------------+ +-------------------+
- La freccia mostra che la classe Robot implementa l’interfaccia Movable.
- L’interfaccia definisce solo «che cosa deve esserci», la classe — «come funziona».
Analogia dalla vita reale
Un’interfaccia in Java è come la patente di guida. Se hai la patente (implementi l’interfaccia «Autista»), significa che sai guidare un’auto. Come lo fai esattamente — sono dettagli: c’è chi guida con prudenza, chi più veloce; l’importante è che ti sei impegnato a saperlo fare.
7. Esempio pratico: proseguiamo la nostra applicazione
public interface Movable {
void move(int x, int y);
}
public class Animal implements Movable {
protected String name;
public Animal(String name) {
this.name = name;
}
@Override
public void move(int x, int y) {
System.out.println(name + " si sposta al punto (" + x + ", " + y + ")");
}
}
public class Robot implements Movable {
private String model;
public Robot(String model) {
this.model = model;
}
@Override
public void move(int x, int y) {
System.out.println("Il robot " + model + " va alle coordinate (" + x + ", " + y + ")");
}
}
public class Main {
public static void main(String[] args) {
Movable[] movables = {
new Animal("Barsik"),
new Robot("R2D2")
};
for (Movable m : movables) {
m.move(5, 10);
}
}
}
Risultato:
Barsik si sposta al punto (5, 10)
Il robot R2D2 va alle coordinate (5, 10)
Abbiamo creato un array di oggetti di tipo Movable. In esso possono esserci oggetti di qualsiasi classe che implementa questa interfaccia! Il codice nel ciclo non sa chi abbia davanti — un animale o un robot — ma sa che ciascuno di essi sa eseguire move.
8. Errori tipici nel lavoro con le interfacce
Errore n. 1: tentativo di creare direttamente un oggetto di un’interfaccia. Un’interfaccia è un contratto, non un oggetto concreto. Non si può scrivere new Movable() — questo genererà un errore di compilazione. Bisogna creare oggetti di classi che implementano l’interfaccia.
Errore n. 2: non sono stati implementati tutti i metodi dell’interfaccia. Se una classe implementa un’interfaccia ma non ne implementa tutti i metodi, il compilatore produrrà un errore: «Class must either be declared abstract or implement abstract method ...». Se non vuoi implementare tutti i metodi, dichiara la classe come abstract.
Errore n. 3: dimenticare i modificatori di accesso. I metodi di un’interfaccia sono sempre public (anche se non scritto esplicitamente). Nella classe che li implementa non si può abbassare il livello di accesso, quindi anche il metodo deve essere public.
Errore n. 4: tentativo di aggiungere campi normali in un’interfaccia. In un’interfaccia si possono dichiarare solo costanti (public static final). Non si possono aggiungere campi (non statici) normali.
GO TO FULL VERSION