Interfacce

Cos'è un'interfaccia?

Un'interfaccia è un contratto che definisce COSA deve fare una classe, ma non COME.

Contiene solo dichiarazioni di metodi (senza implementazione) e costanti.

Una classe può implementare multiple interfacce!

Sintassi

// Dichiarazione interfaccia
public interface Volabile {
    // Tutti i metodi sono public abstract (implicito)
    void vola();
    void atterra();
    
    // Costanti (public static final implicito)
    int ALTITUDINE_MASSIMA = 10000;
}

// Implementare l'interfaccia
public class Aereo implements Volabile {
    private String modello;
    private boolean inVolo;
    
    public Aereo(String modello) {
        this.modello = modello;
        this.inVolo = false;
    }
    
    // DEVI implementare TUTTI i metodi dell'interfaccia
    @Override
    public void vola() {
        inVolo = true;
        System.out.println(modello + " sta volando!");
    }
    
    @Override
    public void atterra() {
        inVolo = false;
        System.out.println(modello + " è atterrato.");
    }
}

// Altra classe che implementa la stessa interfaccia
public class Uccello implements Volabile {
    private String specie;
    
    public Uccello(String specie) {
        this.specie = specie;
    }
    
    @Override
    public void vola() {
        System.out.println("L'uccello " + specie + " vola con le ali! 🦅");
    }
    
    @Override
    public void atterra() {
        System.out.println("L'uccello " + specie + " si è posato.");
    }
    
    public void canta() {
        System.out.println("Cip cip! 🎵");
    }
}

Test interfacce

public class TestVolabili {
    public static void main(String[] args) {
        // Array polimorfico di Volabile
        Volabile[] oggetti = new Volabile[3];
        
        oggetti[0] = new Aereo("Boeing 747");
        oggetti[1] = new Uccello("Aquila");
        oggetti[2] = new Aereo("Airbus A380");
        
        // Faccio volare tutti gli oggetti
        System.out.println("=== Decollo ===");
        for (Volabile v : oggetti) {
            v.vola();
        }
        
        System.out.println("\n=== Atterraggio ===");
        for (Volabile v : oggetti) {
            v.atterra();
        }
        
        System.out.println("\nAltitudine massima: " + Volabile.ALTITUDINE_MASSIMA + " m");
    }
}

=== Decollo ===
Boeing 747 sta volando!
L'uccello Aquila vola con le ali! 🦅
Airbus A380 sta volando!

=== Atterraggio ===
Boeing 747 è atterrato.
L'uccello Aquila si è posato.
Airbus A380 è atterrato.

Altitudine massima: 10000 m

Interfacce multiple

Una classe può implementare più interfacce (impossibile con ereditarietà multipla!):

// Interfaccia 1
public interface Nuotabile {
    void nuota();
}

// Interfaccia 2
public interface Volabile {
    void vola();
}

// Classe che implementa ENTRAMBE
public class Anatra implements Volabile, Nuotabile {
    private String nome;
    
    public Anatra(String nome) {
        this.nome = nome;
    }
    
    @Override
    public void vola() {
        System.out.println(nome + " vola!");
    }
    
    @Override
    public void nuota() {
        System.out.println(nome + " nuota! 🦆");
    }
    
    public void faiQuack() {
        System.out.println("Quack quack!");
    }
}

// Test
Anatra paperino = new Anatra("Paperino");
paperino.vola();
paperino.nuota();
paperino.faiQuack();

Interfacce vs classi astratte

Caratteristica	Interfaccia	Classe Astratta
Metodi	Solo abstract (Java 7) Può avere default (Java 8+)	Abstract E concreti
Attributi	Solo costanti (final)	Qualsiasi attributo
Costruttori	No	Sì
Implementazione multipla	Sì	No (solo singola)
Quando usare	Definire comportamenti	Condividere codice
Parola chiave	implements	extends

Interfacce comuni di Java

Comparable - confrontare oggetti.

public class Studente implements Comparable {
    private String nome;
    private double media;

    // ...

    @Override
    public int compareTo(Studente altro) {
        // Confronta per media
        if (this.media > altro.media) return 1;
        if (this.media < altro.media) return -1;
        return 0;
    }
}

// Ora puoi ordinare!
ArrayList studenti = new ArrayList<>();
// ... aggiungi studenti
Collections.sort(studenti);  // Ordina automaticamente!

Esercizi guidati

Esercizi da svolgere

Concetti chiave

• Interfaccia = contratto di comportamento
• Usa implements
• Tutti i metodi sono public abstract
• Multiple interfacce: implements A, B, C
• Perfette per definire capacità (Volabile, Nuotabile, etc.)