Do czego służą interfejsy funkcjonalne w Javie 8?

W Javie 8 natknąłem się na nowy termin: „interfejs funkcjonalny”. Podczas pracy z wyrażeniami lambda mogłem znaleźć tylko jedno jego użycie .

Java 8 zapewnia wbudowane interfejsy funkcjonalne i jeśli chcemy zdefiniować dowolny interfejs funkcjonalny, możemy skorzystać z @FunctionalInterfaceadnotacji. Pozwoli nam to zadeklarować tylko jedną metodę w interfejsie.

Na przykład:

@FunctionalInterface
interface MathOperation {
    int operation(int a, int b);
}

Jak przydatne jest to w Javie 8 poza samą pracą z wyrażeniami lambda ?

(Pytanie tutaj różni się od tego, które zadałem. Chodzi o pytanie, dlaczego potrzebujemy interfejsów funkcjonalnych podczas pracy z wyrażeniami lambda. Moje pytanie brzmi: dlaczego interfejsy funkcjonalne mają inne zastosowania oprócz wyrażeń lambda?)

@FunctionalInterfaceadnotacja jest przydatna do sprawdzania czasu kompilacji kodu. Nie można mieć więcej niż jedną metodę oprócz static, defaulti metody abstrakcyjne, że metody nadpisywania w Objectna swój @FunctionalInterfacelub inny interfejs wykorzystywany jako interfejs funkcjonalnej.

Ale możesz używać lambd bez tej adnotacji, a także możesz przesłonić metody bez @Overrideadnotacji.

Z dokumentów

funkcjonalny interfejs ma dokładnie jedną abstrakcyjną metodę. Ponieważ metody domyślne mają implementację, nie są abstrakcyjne. Jeśli interfejs deklaruje abstrakcyjną metodę przesłaniającą jedną z publicznych metod java.lang.Object, to również nie wlicza się do liczby metod abstrakcyjnych interfejsu, ponieważ każda implementacja interfejsu będzie miała implementację z java.lang.Object lub z innego miejsca.

To mogą być stosowane do ekspresji lambda:

public interface Foo {
  public void doSomething();
}

Nie można tego użyć w wyrażeniu lambda:

public interface Foo {
  public void doSomething();
  public void doSomethingElse();
}

Ale to da błąd kompilacji :

@FunctionalInterface
public interface Foo {
  public void doSomething();
  public void doSomethingElse();
}

Nieprawidłowa adnotacja „@FunctionalInterface”; Foo nie jest funkcjonalnym interfejsem

Dokumentacja sprawia, że rzeczywiście różnicy między celów

Informacyjny typ adnotacji używany do wskazania, że ​​deklaracja typu interfejsu ma być interfejsem funkcjonalnym zdefiniowanym w specyfikacji języka Java.

i przypadek użycia

Należy pamiętać, że wystąpienia funkcjonalnych interfejsów można tworzyć za pomocą wyrażeń lambda, odwołań do metod lub odwołań do konstruktorów.

którego sformułowanie nie wyklucza ogólnie innych przypadków użycia. Ponieważ głównym celem jest wskazanie funkcjonalnego interfejsu , twoje pytanie sprowadza się do „Czy istnieją inne przypadki użycia interfejsów funkcjonalnych inne niż wyrażenia lambda i odwołania do metod / konstruktorów?”

Ponieważ interfejs funkcjonalny jest konstrukcją języka Java zdefiniowaną w specyfikacji języka Java, tylko ta specyfikacja może odpowiedzieć na to pytanie:

JLS §9.8. Funkcjonalne interfejsy :

…

Oprócz zwykłego procesu tworzenia instancji interfejsu przez deklarowanie i tworzenie instancji klasy (§15.9), instancje interfejsów funkcjonalnych można tworzyć za pomocą wyrażeń referencyjnych do metod i wyrażeń lambda (§15.13, §15.27).

Zatem specyfikacja języka Java nie mówi inaczej, jedyny przypadek użycia wspomniany w tej sekcji to tworzenie instancji interfejsu z wyrażeniami odwołań do metod i wyrażeniami lambda. (Obejmuje to odniesienia do konstruktorów, ponieważ są one wymienione jako jedna z form wyrażenia odwołania do metody w specyfikacji).

Więc jednym zdaniem nie, nie ma innego przypadku użycia tego w Javie 8.

Jak powiedzieli inni, interfejs funkcjonalny to interfejs, który ujawnia jedną metodę. Może mieć więcej niż jedną metodę, ale wszystkie inne muszą mieć domyślną implementację. Powodem, dla którego nazywa się go „interfejsem funkcjonalnym”, jest fakt, że skutecznie działa jako funkcja. Ponieważ jako parametry można przekazywać interfejsy, oznacza to, że funkcje są teraz „obywatelami pierwszej klasy”, jak w funkcjonalnych językach programowania. Ma to wiele zalet, a zobaczysz je dość często podczas korzystania z interfejsu Stream API. Oczywiście wyrażenia lambda są ich głównym oczywistym zastosowaniem.

Ani trochę. Wyrażenia lambda są jedynym punktem tej adnotacji.

Wyrażenie lambda można przypisać do typu interfejsu funkcjonalnego, ale także odwołania do metod i klasy anonimowe.

Jedną miłą rzeczą specyficznych interfejsów funkcjonalnych w java.util.functionto, że mogą one składać się stworzyć nowe funkcje (jak Function.andTheni Function.compose, Predicate.anditp) ze względu na poręczne metod domyślnych, które zawierają.

Interfejs z tylko jedną abstrakcyjną metodą nazywany jest interfejsem funkcjonalnym. Korzystanie z @FunctionalInterface nie jest obowiązkowe, ale najlepiej jest używać go z interfejsami funkcjonalnymi, aby uniknąć przypadkowego dodania dodatkowych metod. Jeśli interfejs jest oznaczony adnotacją @FunctionalInterface i próbujemy mieć więcej niż jedną metodę abstrakcyjną, zgłasza błąd kompilatora.

package com.akhi;
    @FunctionalInterface
    public interface FucnctionalDemo {

      void letsDoSomething();
      //void letsGo();      //invalid because another abstract method does not allow
      public String toString();    // valid because toString from Object 
      public boolean equals(Object o); //valid

      public static int sum(int a,int b)   // valid because method static
        {   
            return a+b;
        }
        public default int sub(int a,int b)   //valid because method default
        {
            return a-b;
        }
    }

Interfejs funkcjonalny:

• Wprowadzony w Javie 8
• Interfejs zawierający metodę „pojedynczej abstrakcji”.

Przykład 1:

   interface CalcArea {   // --functional interface
        double calcArea(double rad);
    }           

Przykład 2:

interface CalcGeometry { // --functional interface
    double calcArea(double rad);
    default double calcPeri(double rad) {
        return 0.0;
    }
}       

Przykład 3:

interface CalcGeometry {  // -- not functional interface
    double calcArea(double rad);
    double calcPeri(double rad);
}   

Adnotacja Java8 - @FunctionalInterface

• Sprawdź adnotacje, czy interfejs zawiera tylko jedną abstrakcyjną metodę. Jeśli nie, zgłoś błąd.
• Mimo że brakuje @FunctionalInterface, nadal jest to funkcjonalny interfejs (jeśli ma jedną metodę abstrakcyjną). Adnotacja pomaga uniknąć błędów.
• Funkcjonalny interfejs może mieć dodatkowe metody statyczne i domyślne.
• np. Iterowalny <>, Porównywalny <>, Komparator <>.

Zastosowania interfejsu funkcjonalnego:

• Odniesienia do metod
• Wyrażenie lambda
• Referencje konstruktora

Aby nauczyć się interfejsów funkcjonalnych, nauczyć się pierwszych metod domyślnych w interfejsie, a po nauczeniu się interfejsu funkcjonalnego będzie Ci łatwo zrozumieć odniesienie do metody i wyrażenie lambda

Możesz użyć lambdy w Javie 8

public static void main(String[] args) {
    tentimes(inputPrm - > System.out.println(inputPrm));
    //tentimes(System.out::println);  // You can also replace lambda with static method reference
}

public static void tentimes(Consumer myFunction) {
    for (int i = 0; i < 10; i++)
        myFunction.accept("hello");
}

Więcej informacji na temat Java Lambdas i FunctionalInterfaces

@FunctionalInterface to nowa adnotacja, która została wydana wraz z Javą 8 i zawiera typy docelowe dla wyrażeń lambda i jest używana do sprawdzania czasu kompilacji kodu.

Kiedy chcesz go użyć:

1- Twój interfejs nie może mieć więcej niż jednej metody abstrakcyjnej, w przeciwnym razie zostanie podany błąd kompilacji.

1- Twój interfejs Powinien być czysty, co oznacza, że ​​interfejs funkcjonalny ma być implementowany przez klasy bezstanowe, na przykład czysty to Comparatorinterfejs, ponieważ nie zależy od stanu implementującego, w tym przypadku nie zostanie podany żaden błąd kompilacji, ale w wielu przypadkach nie będzie w stanie używać lambdy z tego rodzaju interfejsami

java.util.functionPakiet zawiera różne funkcjonalne interfejsy ogólnego zastosowania, takie jak Predicate, Consumer, Function, i Supplier.

Pamiętaj również, że możesz używać lambd bez tej adnotacji.

Oprócz innych odpowiedzi, myślę, że głównym powodem, dla którego „dlaczego używanie interfejsu funkcjonalnego innego niż bezpośrednio z wyrażeniami lambda” może być związane z naturą języka Java, który jest zorientowany obiektowo.

Główne atrybuty wyrażeń Lambda to: 1. Można je przekazywać 2. i wykonywać w przyszłości w określonym czasie (kilka razy). Aby obsługiwać tę funkcję w językach, niektóre inne języki po prostu zajmują się tą sprawą.

Na przykład w Java Script funkcja (funkcja anonimowa lub literały funkcyjne) może być adresowana jako obiekt. Możesz więc je łatwo utworzyć, a także przypisać je do zmiennej i tak dalej. Na przykład:

var myFunction = function (...) {
    ...;
}
alert(myFunction(...));

lub przez ES6, możesz użyć funkcji strzałki.

const myFunction = ... => ...

Do tej pory projektanci języka Java nie akceptowali obsługi wspomnianych funkcji w ten sposób (techniki programowania funkcjonalnego). Uważają, że język Java jest zorientowany obiektowo i dlatego powinni rozwiązać ten problem za pomocą technik zorientowanych obiektowo. Nie chcą przegapić prostoty i spójności języka Java.

Dlatego używają interfejsów, ponieważ gdy obiekt interfejsu z tylko jedną metodą (mam na myśli interfejs funkcjonalny) jest potrzebny, można go zastąpić wyrażeniem lambda. Jak na przykład:

ActionListener listener = event -> ...;