Java è rimasto per sempre un linguaggio di programmazione orientato agli oggetti. Con il linguaggio di programmazione orientato agli oggetti, possiamo dichiarare che tutto ciò che è presente nel linguaggio di programmazione Java ruota attraverso gli Oggetti, ad eccezione di alcuni tipi di dati primitivi e metodi primitivi per integrità e semplicità. Non ci sono esclusivamente funzioni presenti in un linguaggio di programmazione chiamato Java. Le funzioni nel linguaggio di programmazione Java fanno parte di una classe e se qualcuno vuole usarle, deve usare la classe o l'oggetto della classe per chiamare qualsiasi funzione.
Interfacce funzionali Java
UN interfaccia funzionale è un'interfaccia che contiene un solo metodo astratto. Possono avere una sola funzionalità da esibire. Da Java 8 in poi, espressioni lambda può essere utilizzato per rappresentare l'istanza di un'interfaccia funzionale. Un'interfaccia funzionale può avere un numero qualsiasi di metodi predefiniti. Percorribile , ActionListener , E Paragonabile sono alcuni degli esempi di interfacce funzionali.
L'interfaccia funzionale è inoltre riconosciuta come Interfacce di metodi astratti singoli . In breve, sono anche conosciuti come Interfacce SAM . Le interfacce funzionali in Java sono la nuova funzionalità che fornisce agli utenti l'approccio della programmazione fondamentale.
Le interfacce funzionali sono incluse in Java SE 8 con espressioni Lambda e riferimenti ai metodi per rendere il codice più leggibile, pulito e diretto. Le interfacce funzionali sono interfacce che garantiscono di includere esattamente un solo metodo astratto. Le interfacce funzionali vengono utilizzate ed eseguite rappresentando l'interfaccia con un annotazione chiamata @FunctionalInterface . Come descritto in precedenza, le interfacce funzionali possono contenere solo un metodo astratto. Tuttavia, possono includere qualsiasi quantità di metodi predefiniti e statici.
Nelle interfacce funzionali, non è necessario utilizzare la parola chiave abstract poiché è facoltativo utilizzare la parola chiave abstract poiché, per impostazione predefinita, il metodo definito all'interno dell'interfaccia è solo astratto. Possiamo anche chiamare espressioni Lambda come istanza dell'interfaccia funzionale.
attore shweta tiwari
Esempio di interfacce funzionali Java
Esempio 1:
Prima di Java 8, dovevamo creare oggetti di classe interna anonimi o implementare queste interfacce.
Giava
// Java program to demonstrate functional interface> class> Test {> >public> static> void> main(String args[])> >{> >// create anonymous inner class object> >new> Thread(>new> Runnable() {> >@Override> public> void> run()> >{> >System.out.println(>'New thread created'>);> >}> >}).start();> >}> }> |
>
>Produzione
New thread created>
Esempio 2:
Java 8 in poi, possiamo assegnare espressione lambda al suo oggetto interfaccia funzionale in questo modo:
Giava
// Java program to demonstrate Implementation of> // functional interface using lambda expressions> class> Test {> >public> static> void> main(String args[])> >{> >// lambda expression to create the object> >new> Thread(() ->{> >System.out.println(>'New thread created'>);> >}).start();> >}> }> |
jquery al clic
>
>Produzione
New thread created>
Annotazione @FunctionalInterface
L'annotazione @FunctionalInterface viene utilizzata per garantire che l'interfaccia funzionale non possa avere più di un metodo astratto. Nel caso in cui siano presenti più metodi astratti, il compilatore segnala un messaggio di 'Annotazione @FunctionalInterface inaspettata'. Tuttavia, non è obbligatorio utilizzare questa annotazione.
Di seguito è riportata l'implementazione dell'argomento precedente:
Giava
// Java program to demonstrate lambda expressions to> // implement a user defined functional interface.> @FunctionalInterface> interface> Square {> >int> calculate(>int> x);> }> class> Test {> >public> static> void> main(String args[])> >{> >int> a =>5>;> >// lambda expression to define the calculate method> >Square s = (>int> x) ->x*x;> >// parameter passed and return type must be> >// same as defined in the prototype> >int> ans = s.calculate(a);> >System.out.println(ans);> >}> }> |
>
>Produzione
25>
Alcune interfacce funzionali Java integrate
A partire da Java SE 1.8, sono presenti molte interfacce convertite in interfacce funzionali. Tutte queste interfacce sono annotate con @FunctionalInterface. Queste interfacce sono le seguenti:
- Eseguibile –> Questa interfaccia contiene solo il metodo run(). Comparable –> Questa interfaccia contiene solo il metodo compareTo(). ActionListener –> Questa interfaccia contiene solo il metodo actionPerformed(). Callable –> Questa interfaccia contiene solo il metodo call().
Java SE 8 includeva quattro tipi principali di interfacce funzionali che può essere applicato in molteplici situazioni come indicato di seguito:
- Consumatore Funzione Predicato Fornitore
Tra le quattro interfacce precedenti, anche le prime tre interfacce, ovvero Consumatore, Predicato e Funzione, hanno le aggiunte fornite di seguito:
- Consumatore -> Bi-consumatore
- Predicato -> Bi-predicato
- Funzione -> Bifunzione, Operatore unario, Operatore binario
1. Consumatore
L'interfaccia consumatore dell'interfaccia funzionale è quella che accetta solo un argomento o un argomento gentrificato. L'interfaccia del consumatore non ha alcun valore di ritorno. Non restituisce nulla. Esistono anche varianti funzionali del Consumer: DoubleConsumer, IntConsumer e LongConsumer. Queste varianti accettano valori primitivi come argomenti.
Oltre a queste varianti, esiste anche un'altra variante dell'interfaccia Consumer nota come Bi-Consumer.
Bi-consumo – Bi-Consumer è la variante più interessante dell'interfaccia Consumer. L'interfaccia consumer accetta solo un argomento, ma d'altro canto l'interfaccia Bi-Consumer accetta due argomenti. Sia Consumer che Bi-Consumer non hanno alcun valore di ritorno. Inoltre, non restituisce nulla proprio come l'interfaccia Consumer. Viene utilizzato per scorrere le voci della mappa.
gestore attività linux
Sintassi/Prototipo dell’Interfaccia Funzionale del Consumatore –
Consumer consumer = (value) ->System.out.println(valore);>
Questa implementazione dell'interfaccia funzionale Java Consumer stampa il valore passato come parametro all'istruzione print. Questa implementazione utilizza la funzione Lambda di Java.
2. Predicato
Nella logica scientifica, una funzione che accetta un argomento e, in cambio, genera un valore booleano come risposta è detta predicato. Allo stesso modo, nel linguaggio di programmazione Java, un'interfaccia funzionale predicata di Java è un tipo di funzione che accetta un singolo valore o argomento ed esegue una sorta di elaborazione su di esso e restituisce una risposta booleana (Vero/Falso). L'implementazione dell'interfaccia funzionale Predicate incapsula anche la logica del filtering (un processo utilizzato per filtrare i componenti del flusso sulla base di un predicato fornito) in Java.
Proprio come l'interfaccia funzionale del consumatore, anche l'interfaccia funzionale del predicato ha alcune estensioni. Questi sono IntPredicate, DoublePredicate e LongPredicate. Questi tipi di interfacce funzionali predicate accettano solo tipi di dati o valori primitivi come argomenti.
Bi-predicato – Bi-Predicate è anche un'estensione dell'interfaccia funzionale Predicate, che, invece di uno, accetta due argomenti, esegue alcune elaborazioni e restituisce il valore booleano.
Sintassi dell'interfaccia funzionale del predicato –
public interface Predicate { boolean test(T t); }> L'interfaccia funzionale del predicato può essere implementata anche utilizzando una classe. Di seguito è riportata la sintassi per l'implementazione dell'interfaccia funzionale del predicato utilizzando una classe:
public class CheckForNull implements Predicate { @Override public boolean test(Object o) { return o != null; } }> L'interfaccia funzionale del predicato Java può essere implementata anche utilizzando espressioni Lambda. Di seguito è riportato un esempio dell'implementazione dell'interfaccia funzionale Predicato:
Predicate predicate = (value) ->valore != null;>
Questa implementazione di interfacce funzionali in Java utilizzando le espressioni Java Lambda è più gestibile ed efficace di quella implementata utilizzando una classe poiché entrambe le implementazioni svolgono lo stesso lavoro, ovvero restituiscono lo stesso output.
3. Funzione
Una funzione è un tipo di interfaccia funzionale in Java che riceve solo un singolo argomento e restituisce un valore dopo l'elaborazione richiesta. Esistono molte versioni delle interfacce di funzione perché un tipo primitivo non può implicare un argomento di tipo generale, quindi abbiamo bisogno di queste versioni delle interfacce di funzione. Molte versioni diverse delle interfacce delle funzioni sono strumentali e vengono comunemente utilizzate nei tipi primitivi come double, int, long. Nell'argomento vengono utilizzate anche le diverse sequenze di questi tipi primitivi.
Queste versioni sono:
Bifunzione
La Bi-Funzione è sostanzialmente correlata ad una Funzione. Inoltre, accetta due argomenti, mentre Funzione accetta un argomento.
Il prototipo e la sintassi di Bi-Function sono riportati di seguito:
@FunctionalInterface public interface BiFunction { R apply(T t, U u); ....... }> Nel codice di interfaccia sopra, T e U sono gli input e c'è solo un output che è R.
Operatore unario e operatore binario
Esistono anche altre due interfacce funzionali denominate Operatore unario e Operatore binario. Entrambi estendono rispettivamente la Funzione e la Bi-Funzione. In parole semplici, l'operatore unario estende la funzione e l'operatore binario estende la bi-funzione.
stampa da Java
Il prototipo dell'operatore unario e dell'operatore binario è menzionato di seguito:
io. Operatore unario
@FunctionalInterface public interface UnaryOperator extends Function { ……... }> ii . Operatore binario
@FunctionalInterface public interface BinaryOperator extends BiFunction { ……... }> Possiamo capire dall'esempio precedente che l'operatore unario accetta solo un argomento e restituisce solo un singolo argomento. Tuttavia, nell'operatore unario sia i valori di input che quelli di output devono essere identici e dello stesso tipo.
D'altro canto, l'operatore binario accetta due valori e restituisce un valore paragonabile alla bifunzione ma simile a un operatore unario, i tipi di valore di input e di output devono essere identici e dello stesso tipo.
4. Fornitore
L'interfaccia funzionale Fornitore è anche un tipo di interfaccia funzionale che non accetta alcun input o argomento e tuttavia restituisce un singolo output. Questo tipo di interfaccia funzionale viene generalmente utilizzata nella generazione pigra di valori. Le interfacce funzionali del fornitore vengono utilizzate anche per definire la logica per la generazione di qualsiasi sequenza. Ad esempio: la logica alla base della serie Fibonacci può essere generata con l'aiuto dello Stream. generate, che viene implementato dall'interfaccia funzionale del fornitore.
Le diverse estensioni dell'interfaccia funzionale del fornitore contengono molte altre funzioni del fornitore come BooleanSupplier, DoubleSupplier, LongSupplier e IntSupplier. Il tipo restituito di tutte queste ulteriori specializzazioni sono solo le primitive corrispondenti.
La sintassi/prototipo dell'interfaccia funzionale del fornitore è:
@FunctionalInterface public interface Supplier{ // gets a result …………. // returns the specific result ………… T.get(); }> Di seguito è riportata l'implementazione dell'argomento precedente:
Giava
// A simple program to demonstrate the use> // of predicate interface> import> java.util.*;> import> java.util.function.Predicate;> class> Test {> >public> static> void> main(String args[])> >{> >// create a list of strings> >List names = Arrays.asList(> >'Geek'>,>'GeeksQuiz'>,>'g1'>,>'QA'>,>'Geek2'>);> >// declare the predicate type as string and use> >// lambda expression to create object> >Predicate p = (s) ->s.startsWith(>'G'>);> >// Iterate through the list> >for> (String st : names) {> >// call the test method> >if> (p.test(st))> >System.out.println(st);> >}> >}> }> |
>
>Produzione
Geek GeeksQuiz Geek2>
Punti importanti/Osservazione ns:
Ecco alcuni punti significativi riguardanti le interfacce funzionali in Java:
- Nelle interfacce funzionali è supportato un solo metodo astratto. Se l'annotazione di un'interfaccia funzionale, ad esempio @FunctionalInterface, non è implementata o scritta con un'interfaccia funzionale, al suo interno è possibile dichiarare più di un metodo astratto. Tuttavia, in questa situazione con più di una funzione, quell'interfaccia non verrà chiamata interfaccia funzionale. Si chiama interfaccia non funzionale.
- Non è necessaria l'annotazione @FunctionalInterface poiché è solo volontaria. Questo è scritto perché aiuta a controllare il livello del compilatore. Oltre a questo, è facoltativo.
- È possibile aggiungere un numero infinito di metodi (sia statici che predefiniti) all'interfaccia funzionale. In parole semplici, non c'è limite a un'interfaccia funzionale contenente metodi statici e predefiniti.
- I metodi di override della classe genitore non violano le regole di un'interfaccia funzionale in Java.
- IL java.util.function Il pacchetto contiene molte interfacce funzionali integrate in Java 8.