Una delle principali novità introdotte da Java 8 è sicuramente la possibilità di utilizzare le lambda expressions, associandole ad una functional interface. Prerequisito, quindi, per apprendere il concetto di lambda expression è quello di apprendere cosa è una functional interface.
Iniziamo subito col dire che una functional interface è a tutti gli effetti una normale interfaccia, così come siamo abituati a concepirle fin dalle prime versioni di Java. Quello che rende un’interfaccia una functional interface è una semplice caratteristica: avere un solo metodo astratto. Da qui capiamo quindi che il concetto di functional interface non riguarda la sintassi utilizzata per definire un’interfaccia, ma è semplicemente un nome assegnato alle interfacce con un solo metodo astratto. Il concetto è semplice: se un’interfaccia ha un solo metodo astratto, allora la possiamo definire functional interface.
La seguente interfaccia è quindi una functional interface (ha un solo metodo astratto):
public interface MyInterface {
void myMethod(); // unico metodo astratto
}
La seguente interfaccia non è invece una functional interface (ha due metodi astratti):
public interface MyInterface {
void myMethod1(); // metodo astratto 1
void myMethod2(); // metodo astratto 2
}
Nel conteggio dei metodi che concorrono a rendere o meno un’interfaccia una functional interface, non concorrono i metodi di default e statici (anche i metodi di default e statici sono funzionalità introdotte con la versione 8 di Java, saranno affrontati nel corso Java OCP). La seguente interfaccia è quindi una functional interface:
public interface MyInterface {
void myMethod1(); // unico metodo astratto
default void myMethod2() { } // metodo di default
static void myMethod3() { } // metodo statico
}
Visto che solo le functional interfaces possono essere associate alle lambda expressions, è importante assicurarsi che una interfaccia sia una functional interface: a tale scopo possiamo utilizzare l’annotation @FunctionalInterface, che produce un errore in compilazione se l’interfaccia che segue non è una functional interface
@FunctionalInterface
public interface MyInterface { // functional interface → compilazione ok
void myMethod(); // unico metodo astratto
}
@FunctionalInterface
public interface MyInterface { // errore in compilazione
void myMethod1(); // metodo astratto 1
void myMethod2(); // metodo astratto 2
}
L’annotation @FunctionalInterface ha quindi una duplice utilità:
- Segnalarci con un errore in compilazione che l’interfaccia che segue non è una functional interface, evitando quindi nostri possibili errori di valutazione;
- Evitare che un altro developer aggiunga un secondo metodo astratto alla nostra functional interface non sapendo che abbiamo associato una lambda expression alla nostra interfaccia;
Vi è però un’altra valutazione da fare con riferimento al conteggio dei metodi astratti che concorrono a rendere un’interfaccia una functional interface: i metodi della classe Object non concorrono a questo conteggio. La seguente interfaccia, nonostante abbia 4 metodi astratti, è comunque considerata una functional interface, poiché 3 di questi 4 metodi sono definiti nella classe Object (equals, hashCode, toString)
@FunctionalInterface
public interface MyInterface {
void myMethod1(); // unico metodo astratto non definito in Object
boolean equals(Object obj); // metodo della classe Object
int hashCode(); // metodo della classe Object
String toString(); // metodo della classe Object
}
Catalogo Vega Training
Corsi Correlati:
Consulta il nostro Catalogo Corsi per Tecnologia oppure fai una Ricerca per Vendor o ancora trova uno specifico corso attraverso il motore di ricerca interno: Ricerca Corsi. Contattaci ora al Numero Verde 800-177596, il nostro team saprà supportarti nella scelta del percorso formativo più adatto alla tue esigenze.