Java a rămas pentru totdeauna un limbaj de programare orientată pe obiecte. Prin limbajul de programare orientat pe obiecte, putem declara că tot ceea ce este prezent în limbajul de programare Java se rotește prin Obiecte, cu excepția unora dintre tipurile de date primitive și metodele primitive pentru integritate și simplitate. Nu există numai funcții prezente într-un limbaj de programare numit Java. Funcțiile din limbajul de programare Java fac parte dintr-o clasă, iar dacă cineva dorește să le folosească, trebuie să folosească clasa sau obiectul clasei pentru a apela orice funcție.
Interfețe funcționale Java
A interfata functionala este o interfață care conține o singură metodă abstractă. Ele pot avea o singură funcționalitate de prezentat. De la Java 8 încolo, expresii lambda poate fi folosit pentru a reprezenta instanța unei interfețe funcționale. O interfață funcțională poate avea orice număr de metode implicite. Rugabil , ActionListener , și Comparabil sunt câteva dintre exemplele de interfețe funcționale.
cum se sortează o matrice în java
Interfața funcțională este în plus recunoscută ca Interfețe cu o singură metodă abstractă . Pe scurt, sunt cunoscuți și ca interfețe SAM . Interfețele funcționale în Java sunt noua caracteristică care oferă utilizatorilor abordarea programării fundamentale.
Interfețele funcționale sunt incluse în Java SE 8 cu expresii Lambda și referințe la metode pentru a face codul mai lizibil, mai curat și mai simplu. Interfețele funcționale sunt interfețe care asigură faptul că includ doar o singură metodă abstractă. Interfețele funcționale sunt utilizate și executate prin reprezentarea interfeței cu un adnotare numită @FunctionalInterface . După cum s-a descris mai devreme, interfețele funcționale pot conține o singură metodă abstractă. Cu toate acestea, ele pot include orice cantitate de metode implicite și statice.
În interfețele funcționale, nu este nevoie să folosiți cuvântul cheie abstract, deoarece este opțional să folosiți cuvântul cheie abstract deoarece, implicit, metoda definită în interiorul interfeței este doar abstractă. De asemenea, putem numi expresii Lambda ca instanță a interfeței funcționale.
Exemplu de interfețe funcționale Java
Exemplul 1:
Înainte de Java 8, a trebuit să creăm obiecte anonime de clasă interioară sau să implementăm aceste interfețe.
Java
// 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();> >}> }> |
>
>Ieșire
New thread created>
Exemplul 2:
Java 8 în continuare, putem aloca expresie lambda la obiectul său de interfață funcțională astfel:
Java
// 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();> >}> }> |
>
>Ieșire
New thread created>
@FunctionalInterface Adnotare
Adnotarea @FunctionalInterface este utilizată pentru a se asigura că interfața funcțională nu poate avea mai mult de o metodă abstractă. În cazul în care sunt prezente mai multe metode abstracte, compilatorul semnalează un mesaj „Adnotare @FunctionalInterface neașteptată”. Cu toate acestea, nu este obligatoriu să folosiți această adnotare.
Mai jos este implementarea subiectului de mai sus:
Java
// 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);> >}> }> |
>
>Ieșire
25>
Câteva interfețe funcționale Java încorporate
Începând cu Java SE 1.8, există multe interfețe care sunt convertite în interfețe funcționale. Toate aceste interfețe sunt adnotate cu @FunctionalInterface. Aceste interfețe sunt după cum urmează -
- Runnable –> Această interfață conține doar metoda run(). Comparabil –> Această interfață conține doar metoda compareTo(). ActionListener –> Această interfață conține doar metoda actionPerformed(). Callable –> Această interfață conține doar metoda call().
Java SE 8 a inclus patru tipuri principale de interfețe funcționale care poate fi aplicat în mai multe situații, după cum se menționează mai jos:
- Furnizor de funcții de predicat de consum
În mijlocul celor patru interfețe anterioare, primele trei interfețe, adică Consumer, Predicat și Function, au, de asemenea, adăugiri care sunt furnizate mai jos -
- Consumator -> Bi-Consumer
- Predicat -> Bi-Predicat
- Funcție -> Bi-Funcție, Operator unar, Operator binar
1. Consumatorul
Interfața consumer a interfeței funcționale este cea care acceptă un singur argument sau un argument gentrificat. Interfața de consum nu are valoare de returnare. Nu returnează nimic. Există, de asemenea, variante funcționale ale Consumerului - DoubleConsumer, IntConsumer și LongConsumer. Aceste variante acceptă valori primitive ca argumente.
În afară de aceste variante, există și o altă variantă a interfeței Consumer cunoscută sub numele de Bi-Consumer.
Bi-consumator - Bi-Consumer este cea mai interesantă variantă a interfeței Consumer. Interfața consumer acceptă doar un argument, dar pe de altă parte, interfața Bi-Consumer acceptă două argumente. Ambele, Consumer și Bi-Consumer nu au valoare de returnare. De asemenea, nu returnează nimic la fel ca interfața Consumer. Este folosit la iterarea prin intrările hărții.
Sintaxă / Prototip de interfață funcțională pentru consumator –
Consumer consumer = (value) ->System.out.println(valoare);>
Această implementare a interfeței funcționale Java Consumer tipărește valoarea transmisă ca parametru instrucțiunii print. Această implementare folosește funcția Lambda din Java.
2. Predicat
În logica științifică, o funcție care acceptă un argument și, în schimb, generează o valoare booleană ca răspuns este cunoscută ca predicat. În mod similar, în limbajul de programare Java, o interfață funcțională predicată a Java este un tip de funcție care acceptă o singură valoare sau argument și face un fel de procesare pe acesta și returnează un răspuns boolean (Adevărat/Fal). Implementarea interfeței funcționale Predicate încapsulează, de asemenea, logica de filtrare (un proces care este utilizat pentru a filtra componentele fluxului pe baza unui predicat furnizat) în Java.
La fel ca interfața funcțională Consumer, interfața funcțională Predicate are și câteva extensii. Acestea sunt IntPredicate, DoublePredicate și LongPredicate. Aceste tipuri de interfețe funcționale predicate acceptă doar tipuri de date sau valori primitive ca argumente.
Bi-predicat - Bi-Predicate este, de asemenea, o extensie a interfeței funcționale Predicate, care, în loc de unul, ia două argumente, efectuează unele procesări și returnează valoarea booleană.
Sintaxa interfeței funcționale predicate –
public interface Predicate { boolean test(T t); }> Interfața funcțională a predicatului poate fi implementată și folosind o clasă. Sintaxa pentru implementarea interfeței funcționale predicate folosind o clasă este dată mai jos -
public class CheckForNull implements Predicate { @Override public boolean test(Object o) { return o != null; } }> Interfața funcțională a predicatului Java poate fi implementată și folosind expresii Lambda. Un exemplu de implementare a interfeței funcționale Predicate este dat mai jos -
Predicate predicate = (value) ->valoare != null;>
Această implementare a interfețelor funcționale în Java folosind expresii Java Lambda este mai gestionabilă și mai eficientă decât cea implementată folosind o clasă, deoarece ambele implementări fac aceeași muncă, adică returnează aceeași ieșire.
3. Funcția
O funcție este un tip de interfață funcțională în Java care primește doar un singur argument și returnează o valoare după procesarea necesară. Există multe versiuni de interfețe Function, deoarece un tip primitiv nu poate implica un argument de tip general, așa că avem nevoie de aceste versiuni de interfețe de funcție. Multe versiuni diferite ale interfețelor de funcții sunt instrumentale și sunt utilizate în mod obișnuit în tipurile primitive precum double, int, long. Secvențele diferite ale acestor tipuri primitive sunt de asemenea folosite în argument.
Aceste versiuni sunt:
Bi-funcție
Bi-funcția este în mod substanțial legată de o funcție. În plus, este nevoie de două argumente, în timp ce Function acceptă un argument.
Prototipul și sintaxa Bi-Function sunt prezentate mai jos -
@FunctionalInterface public interface BiFunction { R apply(T t, U u); ....... }> În codul de mai sus al interfeței, T și U sunt intrările și există o singură ieșire care este R.
Operator unar și operator binar
Există, de asemenea, alte două interfețe funcționale care sunt numite Operator unar și Operator binar. Ambele extind funcția și, respectiv, bi-funcția. Cu cuvinte simple, Operatorul Unar extinde Funcția, iar Operatorul Binar extinde Bi-Funcția.
Prototipul operatorului unar și al operatorului binar este menționat mai jos:
i. Operator unar
@FunctionalInterface public interface UnaryOperator extends Function { ……... }> ii . Operator binar
@FunctionalInterface public interface BinaryOperator extends BiFunction { ……... }> În exemplul de mai sus putem înțelege că Operatorul Unar acceptă un singur argument și returnează doar un singur argument. Totuși, în Operatorul Unar, ambele valori de intrare și de ieșire trebuie să fie identice și de același tip.
Pe de altă parte, Binary Operator ia două valori și returnează o valoare comparabilă cu Bi-Function, dar similar cu un Operator Unar, tipurile de valori de intrare și de ieșire trebuie să fie identice și de același tip.
4. Furnizor
Interfața funcțională a furnizorului este, de asemenea, un tip de interfață funcțională care nu primește nicio intrare sau argument și totuși returnează o singură ieșire. Acest tip de interfață funcțională este utilizat în general în generarea leneșă de valori. Interfețele funcționale ale furnizorului sunt, de asemenea, utilizate pentru definirea logicii pentru generarea oricărei secvențe. De exemplu – Logica din spatele Serii Fibonacci poate fi generată cu ajutorul Stream. generare, care este implementată de interfața funcțională a furnizorului.
Diferitele extensii ale interfeței funcționale Supplier dețin multe alte funcții ale furnizorilor, cum ar fi BooleanSupplier, DoubleSupplier, LongSupplier și IntSupplier. Tipul de returnare al tuturor acestor specializări ulterioare este doar primitivele corespunzătoare.
Sintaxa/Prototipul interfeței funcționale furnizorului este –
@FunctionalInterface public interface Supplier{ // gets a result …………. // returns the specific result ………… T.get(); }> Mai jos este implementarea subiectului de mai sus:
Java
// 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);> >}> >}> }> |
>
>Ieșire
Geek GeeksQuiz Geek2>
Puncte importante/Observație ns:
Iată câteva puncte semnificative referitoare la interfețele funcționale în Java:
- În interfețele funcționale, există o singură metodă abstractă acceptată. Dacă adnotarea unei interfețe funcționale, adică @FunctionalInterface nu este implementată sau scrisă cu o interfață funcțională, în interiorul acesteia pot fi declarate mai multe metode abstracte. Cu toate acestea, în această situație cu mai multe funcții, acea interfață nu va fi numită interfață funcțională. Se numește interfață nefuncțională.
- Nu există o astfel de nevoie pentru adnotarea @FunctionalInterface, deoarece este doar voluntară. Acesta este scris pentru că ajută la verificarea nivelului compilatorului. Pe langa asta, este optional.
- Un număr infinit de metode (fie statice sau implicite) pot fi adăugate la interfața funcțională. Cu cuvinte simple, nu există nicio limită pentru o interfață funcțională care conține metode statice și implicite.
- Metodele de suprascrie din clasa părinte nu încalcă regulile unei interfețe funcționale în Java.
- The java.util.function pachetul conține multe interfețe funcționale încorporate în Java 8.