Le interfacce in Java

Gran parte del codice Java che si sviluppa per un'applicazione Android, prende in considerazione un concetto fondamentale della programmazione ad oggetti, ossia quello di interfaccia. In questo tutorial, vedremo cosa sono e come si definiscono.

Quando si progetta un software o parti di esso, sia che sia un'app, sia che sia un software gestionale sia che sia un siti web, il programmatore Java e quindi anche il programmatore di app android, si trova spesso difronte alla creazione di tante classi.

Questo, per applicazioni complesse, può portare presto alla perdita del controllo dell'intera applicazione, in quanto entrano in gioco diverse relazioni tra i diversi componenti, che necessitano di essere uniformate a livello di comunicazione. E' un pò quello che succederebbe all'interno di un'aula, se tutti gli alunni fossero di diversa nazionalità: oguno parlerebbe ma senza che gli altri siano in grado di comprenderne il significato, con il risultato presto immaginabile: non si riescirebbe a fare alcuna lezione.

Nella programmazione ad oggetti, affinchè tutte le classi e gli oggetti di uno stesso gruppo, "parlino la stessa lingua", si deve concordare, con una specie di "contratto", così come avviene tra due soci di un'azienda, come i doversi componenti software debbano interagire tra di loro. Questo è uno dei passi fondamentali, quando più gruppi di programmatori, lavorando allo stesso progetto, debbano produrre migliaia di righe di codice, che rimangano indipendenti, ma che riescano a colloquiare tra di loro senza che questo dialogo degeneri in una babele di frasi senza senso.

Per cercare di avvicinarsi alla realtà, e facendo il classico e noioso esempio delle automobili, possiamo dire che, tutte queste, hanno le stesse funzionalità di base: sterzano e frenano. Anche i camion e le moto, esattamente come le automobili, sono in grado di eseguire queste azioni, sterzare e frenare, sebbene siano completamente diversi tra di loro.

Nel mondo Java, queste funzionalità comuni vengono chiamate interfacce.

In questa sezione, inizeremo a capire come si definisce un'interfaccia a livello di sintassi, e in che situazioni sia possibile servircene.

Introduzione alle interfacce

Per capire come si debbano usare le interfacce in Java, partiamo già dalla fine, ossia vediamo come si definiscono nel codice Java:

public interface FunzioniMacchina {
int LEFT = 1;
int RIGHT = 2;
void cambioDirezione(int direzione);
void freccia(int direzione);
}

Il codice qui sopra, dovrà essere definito come un file java a sè, e iniziare con una regola di visibilità, la parola chiave "interface" e poi a seguire il nome dell'interfaccia. Come puoi osservare, possiamo dichiarare solo costanti o metodi all'interno dell'interfaccia. Ogni variabile che inseriremo all'interno dell'interfaccia, sarà automaticamente una costante public static final, e ogni metodo sarà public e abstract. Possiamo trasformare questi metodi in statici, aggiungendo la parola static al metodo.

La cosa interessante da osservare è che non è necessario provvedere all'implementazione dei diversi metodi. Questo fa parte del contratto, che viene stipulato tra le parti, ossia tra tutti coloro che avranno accesso a questi metodi (le classi), e che stabilisce che ogni classe potrà implementarli come preferisce.

E invece di far firmare un documento tra le parti interessate, come avviene per i classici contratti nel mondo reale, dovremo semplicemente creare una classe che implementi l'interfaccia, usando la seguente notazione:

public class MacchinaFormula1 implements FunzioniMacchina {
...
@Override
public void cambioDirezione(int direzione) {
...
}
@Override
public void freccia(int direzione) {
...
}
}

Quando implementiamo una classe in questo modo, è come se il contratto fosse definitivamente ufficializzato, potendo così implementare i metodi definiti all'interno dell'interfaccia. Come puoi vedere, dobbiamo solo aggiungere la parola "implements", all'interno della definizione della classe. Abbiamo inoltre aggiunto il corpo di tutti i metodi definiti a livello di nomi, proprio nell'interfaccia.

Altra cosa interessante da osservare, è la presenza della parola @Override che accompagna la definizione di ogni metodo. Questa notazione la troverai molto spesso in tutti i metodi che si creano in automatico grazie ad Android Studio, durante la definizione di un nuovo progetto. In termi tecnici, questa notazione si chiama "sovrascrittura" di un metodo, e ci serve per segnalare al compilatore che stiamo implementando un metodo definito nell'interfaccia con la nostra logica personale.

Le interfacce anche come Tipi di Dati

Sempre sfruttando la metafora del contratto, possiamo a tutti gli effetti, utilizzare l'interfaccia come un riferimento di tipo, sebbene non sia possibile creare nuove istanze di un'interfaccia. La ragione per cui non possiamo usare una notazione del tipo:

FunzioniMacchina ff = new FunzioniMacchina()

dipende dal fatto che abbiamo bisogno di una classe per implementare il legame con l'interfaccia FunzioniMacchina. La classe MacchinaFormula1 invece ne è un esempio in quanto posso definire il corpo dei metodi interni all'interfaccia.

Supponiamo inoltre di avere un'altra classe:

public class Camion implements FunzioniMacchina {

}

Possiamo usare le interfacce come tipo, ma prima dobbiamo procedere all'inizializzazione di queste verso una classe che implementa l'interfaccia.

FunzioniMacchina macchina1 = new MacchinaFormula1();
FunzioniMacchina macchina2 = new Camion();

In questo caso non faccio altro che dichiarare due variabili di tipo FunzioniMacchina e inzializzarle a due diversi oggetti, uno istanza della classe MacchinaFormula1 e l'altro Camion. Java agisce in modo tale che, se una variabile ha il tipo di un'interfaccia, questa deve essere settata con l'istanza di una classe che implementa quella specifica interfaccia.Glu unici metodi che possiamo richiamare da questi oggetti, saranno quelli definiti nell'interfaccia.

macchina1.freccia(FunzioniMacchina.RIGHT);
macchina1.cambioDirezione(FunzioniMacchina.RIGHT);
macchina2.freccia(FunzioniMacchina.LEFT);
macchina2.cambioDirezione(FunzioniMacchina.LEFT);

2024-11-21 Tipo/Autore: Davide Copelli {ing} Pubblicato da: CorsoAndroid.it