Last Updated on 2 anni | Published: 18/04/2024
Interfacce Java
Le interfacce sono un concetto fondamentale nella Programmazione Orientata agli Oggetti (OOP) in Java che permette di definire un contratto o un’interfaccia comune per un insieme di classi, promuovendo la modularità, l’estensibilità e la manutenibilità del codice.
Un‘ interfaccia in Java è una collezione di metodi astratti e costanti (variabili statiche final) che definisce un contratto o un’interfaccia comune per un insieme di classi.
Le interfacce permettono di specificare quali metodi devono essere implementati dalle classi che implementano l’interfaccia, senza fornire una implementazione concreta dei metodi stessi, infatti una interfaccia non può essere istanziata direttamente, ma una classe può implementare più interfacce.
Nel contesto della programmazione OOP, le interfacce sono utilizzate per definire un’interfaccia comune per un insieme di classi non correlate ma che condividono un comportamento o una funzionalità simile, promuovendo la modularità e il riutilizzo del codice.
Creare ed Implementare un' interfaccia
Per definire un’ interfaccia in Java, si utilizza la parola chiave interface seguita dal nome dell’interfaccia e dalla lista dei metodi non implementati e delle costanti. Ecco un esempio semplice di come potrebbe apparire un’interfaccia:
void accelera();
// Metodo astratto per frenare
void frena();
// Costante per la velocità massima
int VELOCITA_MASSIMA = 200;
}
Per implementare un’interfaccia in una classe, si utilizza la parola chiave implements seguita dal nome dell’interfaccia. La classe deve fornire un’implementazione concreta dei metodi astratti definiti nell’interfaccia. Ecco un esempio di come potrebbe apparire una classe che implementa l’interfaccia Veicolo:
public void accelera() {
System.out.println(“L’auto accelera.“);
}
@Override
public void frena() {
System.out.println(“L’auto frena.“);
}
}
Iniezione delle Dipendenze
L’ iniezione delle dipendenze attraverso interfacce è una tecnica utilizzata per implementare il principio dell’inversione delle dipendenze (Dependency Inversion) nel design del software, che è uno dei principi fondamentali della programmazione orientata agli oggetti (OOP) e del design pattern.
L’ iniezione delle dipendenze attraverso interfacce permette di ridurre l’accoppiamento tra le classi e di promuovere la modularità, la flessibilità e la manutenibilità del codice, permettendo di sostituire facilmente le implementazioni concrete delle dipendenze senza modificare il codice esistente.
Un esempio molto semplice è quello di creare una interfaccia di IServizi ed una classe concreta Servizi che implementa i metodi:
void esegui();
}
// Implementazione del Servizio
public class Servizi implements IServizi {
@Override
public void esegui() {
System.out.println(“Esegui ….“);
}
}
ed una classe Clienti che dipende dai Servizi:
// Variabile di istanza di tipo Interfaccia
private IServizi iservizi;
// Costruttore con iniezione delle dipendenze
public Clienti(IServizi iservizi) {
this.iservizi= iservizi;
}
// Metodo che utilizza il servizio
public void usaServizio() {
iservizi.esegui();
}
}
Possiamo quindi attraverso una classe di Test implementare il metodo main() per utilizzare il servizio:
// Metodo main per testare l’iniezione delle dipendenze attraverso interfacce
public class Test {
public static void main(String[] args) {
// Creazione di un oggetto Servizi
IServizi servizio= new Servizi();
// Creazione di un oggetto Client con iniezione delle dipendenze
Clienti cliente = new Clienti(servizio);
// Utilizzo del servizio attraverso il client
cliente.eseguiServizio();
}
}
Nel prossimo Articolo parleremo del principio dell’ ereditarietà in Java, principio fondamentale della OOP, che consente di creare nuove classi da quelle esistenti ………
LABORATORIO
Come ben sappiamo le interfacce contengono le firme dei metodi da implementare ma esse stesse non si possono istanziare, quindi le classi concrete implementano le interfacce, una o più, per poi implementare le firme importate. Un semplice esempio per Eclipse prospettiva SE:
-
interfacce.zip
(zip, 5KB)
-
Questo esercizio, da importare in Eclipse prosepettiva SE, utilizza una interfaccia alcuni array primitivi e classi di sistema, implementa una logica per il lancio dei dadi, ovvero due concorrenti che lanciano i dadi cinque volte ciascuno, chi totalizza di più vince.
-
lanciodadi.zip
(zip, 7KB)
-