1. Información general
La interfaz funcional se refiere a una interfaz que tiene solo un método abstracto, pero que puede tener varios métodos no abstractos. El propósito de su uso es proporcionar un mejor soporte para el uso de expresiones Lambda, lograr aún más el objetivo de la programación funcional y mejorar la eficiencia del desarrollo.
2 Características de la interfaz funcional
- Solo hay un método abstracto, pero puede haber miembros, métodos estáticos y predeterminados
- Use la anotación @FunctionalInterface para verificar si una interfaz es una interfaz funcional (el número de métodos abstractos es uno)
- Si la interfaz es una interfaz funcional, puede agregar @FunctionalInterface o no
- Si una interfaz contiene más de un método abstracto, después de agregar @FunctionalInterface, se informará un error
Función de devolución de llamada : en pocas palabras, el parámetro pasado en un método (A) también es un método (B), y el método B se llama en el método A.
3 Utilice Lambda para implementar interfaces funcionales
(1) El método abstracto de la interfaz no tiene parámetros
Primero defina una interfaz funcional
/**
* 只有一个抽象方法，符合函数式接口的规定
*/
@FunctionalInterface
public interface FuntionInterface_ {
public void laugh();
}
lograr:
/**
* 1.8新写法实现接口
*/
public class FunctionalInterface_03 {
public static void main(String[] args) {
call (() -> System.out.println("Lambda表达式实现接口"))
}
public static void call(FuntionInterface_ func){
func.laugh();
}
}
(2) El método abstracto de la interfaz tiene parámetros
Defina la interfaz:
@FunctionalInterface
interface MyFunctionInter2 {
void printMessage(String str);
}
lograr:
public class FunctionalInterface{
public static void main(String[] args) {
String str = "有参函数式接口调用";
// 使用 lambda 实现有参函数式接口调用
// str 是字符串，s 是参数，str 给到 s ，打印 s
call ( s -> System.out.println(s), str);
}
//定义调用接口的回调函数
public static void call(MyFunctionInter2 func,String str) {
func.printMessage(str);
}
}
4 interfaz funcional propia de JDK
(1) Proveedor: representa al proveedor, tiene un valor de retorno, puede obtener los datos y utilizar el método get () para obtener los datos.
public class JdkOwn_01 {
public static void main(String[] args) {
String result = getResult(new Supplier<String>() {
result = getResult( ()-> "哈哈" );
System.out.println(result);//哈哈
// 创建Supplier容器
// 此时不会调用构造方法创建对象
Supplier<JdkOwn_01> sup = JdkOwn_01::new;
// 创建对象并返回
JdkOwn_01 jo1 = sup.get();
JdkOwn_01 jo2 = sup.get();
System.out.println(jo1);
System.out.println(jo2);
}
//定义获取方法，传入供应商接口对象，由返回值
public static String getResult(Supplier<String> function) {
//固定写法，通过get() 获取内容
//具体获取什么需要自己实现
return function.get();
}
}
(2) Consumidor: Representa la interfaz del consumidor, no se requiere valor de retorno, aceptar (T t): Se usa para realizar operaciones de consumidor.
public class JdkOwn_02 {
public static void main(String[] args) {
String message = "我爱花钱";
//lambda 实现接口
//message是参数
//因为该消费接口是需要参数的，需要定义 x ，接受 message
//然后打印 x
consumeResult(x -> System.out.println(x), message);
}
//定义消费方法，传入消费接口对象和消费的内容
public static void consumeResult(Consumer<String> function, String message) {
function.accept(message);
}
}
(3) Función <T, R>: Recibe un parámetro y produce un resultado. T es el parámetro, R es el resultado y el método R aplicar (T t) produce el resultado.
public class JdkOwn_03 {
public static void main(String[] args) {
int num = convertType(x->Integer.parseInt(x), "123");
System.out.println(num);
}
/**
* 接受一个字符串，将其转换为数字，数字是返回值
* @param function 自定义接口
* @param str 字符串，参数
* @return 数字，返回值
*/
public static int convertType(Function<String, Integer> function, String str) {
int num = function.apply(str);
return num;
}
}
(4) Predicado: interfaz de afirmación, utilizada para hacer algunos juicios, prueba booean (T): utilizada para verificar y comparar operaciones.
public class JdkOwn_04 {
public static boolean call(Predicate<String> predicate, String message) {
return predicate.test(message);
}
public static void main(String[] args) {
String message = "ok";
boolean result = call ( x -> {
return x.equals("ok");}, message);
System.out.println(result);
}
}