Для чего используются функциональные интерфейсы в Java 8?

Я встретил новый термин в Java 8: «функциональный интерфейс». Я мог найти только одно применение при работе с лямбда-выражениями .

Java 8 предоставляет несколько встроенных функциональных интерфейсов, и если мы хотим определить какой-либо функциональный интерфейс, мы можем использовать @FunctionalInterfaceаннотацию. Это позволит нам объявить только один метод в интерфейсе.

Например:

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

Насколько это полезно в Java 8, кроме работы с лямбда-выражениями ?

(Вопрос здесь отличается от того, который я задавал. Он спрашивает, зачем нам нужны функциональные интерфейсы при работе с лямбда-выражениями. Мой вопрос: почему другие применения используются функциональными интерфейсами помимо с лямбда-выражениями?)

@FunctionalInterfaceаннотация полезна для проверки времени компиляции вашего кода. Вы не можете иметь более одного метода , кроме static, defaultи абстрактные методы , которые переопределяют методы в Objectв вашей @FunctionalInterfaceили любой другой интерфейс , используемый в качестве функционального интерфейса.

Но вы можете использовать лямбда-выражения без этой аннотации, а также переопределять методы без @Overrideаннотации.

Из документов

функциональный интерфейс имеет только один абстрактный метод. Поскольку методы по умолчанию имеют реализацию, они не являются абстрактными. Если интерфейс объявляет абстрактный метод, переопределяющий один из открытых методов java.lang.Object, это также не учитывается в счетчике абстрактного метода интерфейса, поскольку любая реализация интерфейса будет иметь реализацию из java.lang.Object или где-либо еще.

Это можно использовать в лямбда-выражении:

public interface Foo {
  public void doSomething();
}

Это нельзя использовать в лямбда-выражении:

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

Но это даст ошибку компиляции :

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

Неверная аннотация @FunctionalInterface; Фу не функциональный интерфейс

Документация делает на самом деле разница между целью

Информативный тип аннотации, используемый, чтобы указать, что объявление типа интерфейса предназначено, чтобы быть функциональным интерфейсом, как определено Спецификацией языка Java.

и вариант использования

Обратите внимание, что экземпляры функциональных интерфейсов могут создаваться с помощью лямбда-выражений, ссылок на методы или ссылок на конструкторы.

чья формулировка не исключает других случаев использования в целом. Поскольку основной целью является указание на функциональный интерфейс , ваш фактический вопрос сводится к «Есть ли другие варианты использования для функциональных интерфейсов, кроме лямбда-выражений и ссылок на метод / конструктор?»

поскольку функциональным интерфейсом является языковой конструкцией Java, определенной в Спецификации языка Java, только эта спецификация может ответить на этот вопрос:

JLS §9.8. Функциональные интерфейсы :

...

В дополнение к обычному процессу создания экземпляра интерфейса путем объявления и создания экземпляра класса (§15.9), экземпляры функциональных интерфейсов могут быть созданы с помощью выражений ссылок на методы и лямбда-выражений (§15.13, §15.27).

Таким образом, спецификация языка Java не говорит иначе, единственный случай использования, упомянутый в этом разделе, - это создание экземпляров интерфейса с помощью выражений ссылок на методы и лямбда-выражений. (Это включает ссылки на конструктор, поскольку они отмечены как одна из форм выражения ссылки на метод в спецификации).

Так что в одном предложении нет, в Java 8 нет другого варианта использования.

Как уже говорили другие, функциональный интерфейс - это интерфейс, который предоставляет один метод. Может иметь более одного метода, но все остальные должны иметь реализацию по умолчанию. Причина, по которой он называется «функциональным интерфейсом», заключается в том, что он эффективно действует как функция. Поскольку вы можете передавать интерфейсы как параметры, это означает, что функции теперь являются «первоклассными гражданами», как в функциональных языках программирования. Это имеет много преимуществ, и вы увидите их довольно часто при использовании Stream API. Конечно, лямбда-выражения являются основным очевидным использованием для них.

Не за что. Лямбда-выражения - это единственная точка этой аннотации.

Лямбда-выражение может быть назначено функциональному типу интерфейса, но также могут быть ссылки на методы и анонимные классы.

Хорошая особенность конкретных функциональных интерфейсов в java.util.functionтом, что они могут быть созданы для создания новых функций (например, Function.andThenи Function.compose, Predicate.andи т. Д.) Благодаря удобным методам по умолчанию, которые они содержат.

Интерфейс только с одним абстрактным методом называется функциональным интерфейсом. Использование @FunctionalInterface не обязательно, но рекомендуется использовать его с функциональными интерфейсами, чтобы избежать случайного добавления дополнительных методов. Если интерфейс аннотирован аннотацией @FunctionalInterface, и мы пытаемся использовать более одного абстрактного метода, он выдает ошибку компилятора.

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

Функциональный интерфейс:

• Введено в Java 8
• Интерфейс, который содержит «единственный абстрактный» метод.

Пример 1:

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

Пример 2:

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

Пример 3:

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

Java8 аннотация - @FunctionalInterface

• Проверка аннотации, что интерфейс содержит только один абстрактный метод. Если нет, поднять ошибку.
• Даже если @FunctionalInterface отсутствует, это все же функциональный интерфейс (если используется один абстрактный метод). Аннотация помогает избежать ошибок.
• Функциональный интерфейс может иметь дополнительные статические методы и методы по умолчанию.
• например, Iterable <>, Comparable <>, Comparator <>.

Приложения функционального интерфейса:

• Ссылки на метод
• Лямбда-выражение
• Ссылки на конструктор

Чтобы изучить функциональные интерфейсы, изучить первые стандартные методы в интерфейсе, а после изучения функционального интерфейса вам будет легко понять ссылку на метод и лямбда-выражение

Вы можете использовать лямбду в 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");
}

Для получения дополнительной информации о Java Lambdas и FunctionalInterfaces

@FunctionalInterface Это новая аннотация, выпущенная с Java 8 и предоставляющая целевые типы для лямбда-выражений, и она используется при проверке времени компиляции вашего кода.

Когда вы хотите использовать это:

1- Ваш интерфейс не должен иметь более одного абстрактного метода, в противном случае будет выдана ошибка компиляции.

1- Ваш интерфейс должен быть чистым, что означает, что функциональный интерфейс предназначен для реализации классами без сохранения состояния, примером чистого является Comparatorинтерфейс, потому что он не зависит от состояния разработчиков, в данном случае Нет ошибку компиляции будет дана, но во многих случаях не сможет использовать лямбда с такими интерфейсами

java.util.functionПакет содержит различные функциональные интерфейсы общего назначения , такие как Predicate, Consumer, Function, иSupplier .

Также обратите внимание, что вы можете использовать лямбды без этой аннотации.

Помимо других ответов, я думаю, что основная причина «почему использование функционального интерфейса, отличного от непосредственно лямбда-выражений» может быть связана с природой языка Java, который является объектно-ориентированным.

Основные атрибуты лямбда-выражений: 1. Они могут передаваться через 2. и могут выполняться в будущем через определенное время (несколько раз). Теперь, чтобы поддержать эту функцию в языках, некоторые другие языки решают эту проблему просто.

Например, в Java Script, функция (анонимная функция или литералы функций) может быть адресована как объект. Таким образом, вы можете создавать их просто, а также они могут быть назначены на переменную и так далее. Например:

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

или через ES6, вы можете использовать функцию стрелки.

const myFunction = ... => ...

До настоящего времени разработчики языка Java не соглашались обрабатывать упомянутые функции таким образом (методы функционального программирования). Они считают, что язык Java является объектно-ориентированным, и поэтому они должны решить эту проблему с помощью объектно-ориентированных методов. Они не хотят упускать простоту и последовательность языка Java.

Поэтому они используют интерфейсы, так как, когда нужен объект интерфейса только с одним методом (я имею в виду функциональный интерфейс), вы можете заменить его лямбда-выражением. Такие как:

ActionListener listener = event -> ...;