Para que são utilizadas as interfaces funcionais no Java 8?

Me deparei com um novo termo no Java 8: "interface funcional". Eu só consegui encontrar um uso dele enquanto trabalhava com expressões lambda .

O Java 8 fornece algumas interfaces funcionais integradas e, se quisermos definir qualquer interface funcional, podemos usar a @FunctionalInterfaceanotação. Isso nos permitirá declarar apenas um único método na interface.

Por exemplo:

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

Quão útil é no Java 8 além de apenas trabalhar com expressões lambda ?

(A pergunta aqui é diferente da que eu perguntei. Está perguntando por que precisamos de interfaces funcionais ao trabalhar com expressões lambda. Minha pergunta é: por que outros usos as interfaces funcionais têm além das expressões lambda?)

@FunctionalInterfaceA anotação é útil para verificar o tempo de compilação do seu código. Você não pode ter mais de um método static, além de defaultmétodos abstratos que substituem os métodos Objectna sua @FunctionalInterfaceou em qualquer outra interface usada como interface funcional.

Mas você pode usar lambdas sem essa anotação, bem como substituir métodos sem @Overrideanotação.

De documentos

uma interface funcional possui exatamente um método abstrato. Como os métodos padrão têm uma implementação, eles não são abstratos. Se uma interface declara um método abstrato substituindo um dos métodos públicos de java.lang.Object, isso também não conta para a contagem de métodos abstratos da interface, pois qualquer implementação da interface terá uma implementação de java.lang.Object ou em outro local

Isso pode ser usado na expressão lambda:

public interface Foo {
  public void doSomething();
}

Isso não pode ser usado na expressão lambda:

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

Mas isso dará erro de compilação :

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

Anotação '@FunctionalInterface' inválida; Foo não é uma interface funcional

A documentação realmente faz a diferença entre o objetivo

Um tipo de anotação informativa usado para indicar que uma declaração de tipo de interface se destina a ser uma interface funcional, conforme definido pela Java Language Specification.

e o caso de uso

Observe que instâncias de interfaces funcionais podem ser criadas com expressões lambda, referências de método ou referências de construtor.

cuja redação não exclui outros casos de uso em geral. Como o objetivo principal é indicar uma interface funcional , sua pergunta real se resume a "Existem outros casos de uso para interfaces funcionais que não sejam expressões lambda e referências de método / construtor?"

Como a interface funcional é uma construção da linguagem Java definida pela Especificação da Linguagem Java, somente essa especificação pode responder a essa pergunta:

JLS §9.8. Interfaces Funcionais :

...

Além do processo usual de criação de uma instância de interface, declarando e instanciando uma classe (§15.9), instâncias de interfaces funcionais podem ser criadas com expressões de referência de método e expressões lambda (§15.13, §15.27).

Portanto, a Java Language Specification não diz o contrário, o único caso de uso mencionado nessa seção é o de criar instâncias de interface com expressões de referência de método e expressões lambda. (Isso inclui referências de construtor, pois elas são anotadas como uma forma de expressão de referência de método na especificação).

Portanto, em uma frase, não, não há outro caso de uso para ele no Java 8.

Como outros já disseram, uma interface funcional é uma interface que expõe um método. Pode ter mais de um método, mas todos os outros devem ter uma implementação padrão. A razão pela qual é chamada de "interface funcional" é porque ela atua efetivamente como uma função. Como você pode transmitir interfaces como parâmetros, isso significa que as funções agora são "cidadãos de primeira classe", como nas linguagens de programação funcionais. Isso tem muitos benefícios, e você os verá bastante ao usar a API de fluxo. Obviamente, as expressões lambda são o principal uso óbvio para elas.

De modo nenhum. As expressões lambda são o único ponto dessa anotação.

Uma expressão lambda pode ser atribuída a um tipo de interface funcional, mas o mesmo pode fazer referências a métodos e classes anônimas.

Uma coisa agradável sobre as interfaces funcionais específicas em java.util.functioné que eles podem ser compostas para criar novas funções (como Function.andThene Function.compose, Predicate.and, etc.) devido aos métodos padrão úteis que eles contêm.

Uma interface com apenas um método abstrato é chamada de Interface Funcional. Não é obrigatório usar o @FunctionalInterface, mas é uma prática recomendada usá-lo com interfaces funcionais para evitar a adição acidental de métodos extras. Se a interface é anotada com a anotação @FunctionalInterface e tentamos ter mais de um método abstrato, ela gera um erro do compilador.

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;
        }
    }

Interface funcional:

• Introduzido em Java 8
• Interface que contém um método "único resumo".

Exemplo 1:

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

Exemplo 2:

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

Exemplo 3:

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

Anotação Java8 - @FunctionalInterface

• Anotação verifique se a interface contém apenas um método abstrato. Caso contrário, aumente o erro.
• Mesmo que o @FunctionalInterface esteja ausente, ainda é a interface funcional (se houver um único método abstrato). A anotação ajuda a evitar erros.
• A interface funcional pode ter métodos estáticos e padrão adicionais.
• por exemplo, Iterável <>, Comparável <>, Comparador <>.

Aplicações da interface funcional:

• Referências de método
• Expressão Lambda
• Referências do construtor

Para aprender interfaces funcionais, aprender os primeiros métodos padrão na interface e depois de aprender a interface funcional, será fácil entender a referência do método e a expressão lambda

Você pode usar o lambda no Java 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");
}

Para mais informações sobre Java Lambdas e FunctionalInterfaces

@FunctionalInterface é uma nova anotação lançada com Java 8 e fornece tipos de destino para expressões lambda e é usada na verificação do tempo de compilação do seu código.

Quando você quiser usá-lo:

1- Sua interface não deve ter mais de um método abstrato, caso contrário, será gerado um erro de compilação.

1- Sua interface deve ser pura, o que significa que a interface funcional deve ser implementada por classes sem estado, por exemplo, pure é Comparatorinterface porque não depende do estado dos implementadores, neste caso Nenhum erro de compilação será fornecido, mas em muitos casos você não será capaz de usar lambda com este tipo de interfaces

O java.util.functionpacote contém várias interfaces funcionais para fins gerais, tais como Predicate, Consumer, Function, eSupplier .

Observe também que você pode usar lambdas sem esta anotação.

Além de outras respostas, acho que o principal motivo para "por que usar a Interface Funcional que não seja diretamente com expressões lambda" pode estar relacionado à natureza da linguagem Java, que é Orientada a Objetos.

Os principais atributos das expressões Lambda são: 1. Eles podem ser passados ​​em torno de 2. e podem ser executados no futuro em tempo específico (várias vezes). Agora, para suportar esse recurso em idiomas, alguns outros idiomas lidam simplesmente com esse assunto.

Por exemplo, em Java Script, uma função (função anônima ou literal de função) pode ser endereçada como um objeto. Assim, você pode criá-los de forma simples e eles também podem ser atribuídos a uma variável e assim por diante. Por exemplo:

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

ou via ES6, você pode usar uma função de seta.

const myFunction = ... => ...

Até agora, os designers de linguagem Java não aceitaram lidar com os recursos mencionados por esse meio (técnicas de programação funcional). Eles acreditam que a linguagem Java é orientada a objetos e, portanto, devem resolver esse problema por meio de técnicas orientadas a objetos. Eles não querem perder a simplicidade e a consistência da linguagem Java.

Portanto, eles usam interfaces, pois quando um objeto de uma interface com apenas um método (quero dizer interface funcional) é necessário, você pode substituí-lo por uma expressão lambda. Tal como:

ActionListener listener = event -> ...;