一、简介

1.1 @FunctionalInterface

在JDK 8中引入了FunctionalInterface接口，其源代码定义如下：

1
2
3
4
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface FunctionalInterface {}

1.2 特征

  • 有且仅有一个抽象方法
  • 允许定义静态方法
  • 允许定义默认方法
  • 允许java.lang.Object中的public方法
  • 该注解不是必须的，如果一个接口符合”函数式接口”定义，那么加不加该注解都没有影响。加上该注解能够更好地让编译器进行检查。如果编写的不是函数式接口，但是加上了@FunctionalInterface，那么编译器会报错
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
@FunctionalInterface
public interface TestInterface {
    // 抽象方法
    public void sub();

    // java.lang.Object中的方法不是抽象方法
    public boolean equals(Object var1);

    // default不是抽象方法
    public default void defaultMethod(){

    }

    // static不是抽象方法
    public static void staticMethod(){

    }
}

二、示例

2.1 定义接口

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
/**多参数无返回*/
@FunctionalInterface
public interface NoReturnMultiParam {
    void method(int a, int b);
}

/**无参无返回值*/
@FunctionalInterface
public interface NoReturnNoParam {
    void method();
}

/**一个参数无返回*/
@FunctionalInterface
public interface NoReturnOneParam {
    void method(int a);
}

/**多个参数有返回值*/
@FunctionalInterface
public interface ReturnMultiParam {
    int method(int a, int b);
}

/*** 无参有返回*/
@FunctionalInterface
public interface ReturnNoParam {
    int method();
}

/**一个参数有返回值*/
@FunctionalInterface
public interface ReturnOneParam {
    int method(int a);
}

2.2 使用示例

语法形式为 () -> {}，其中 () 用来描述参数列表，{} 用来描述方法体，-> 为 lambda运算符 ，读作(goes to)。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
//无参无返回
NoReturnNoParam noReturnNoParam = () -> {
    System.out.println("NoReturnNoParam");
};
noReturnNoParam.method();

//一个参数无返回
NoReturnOneParam noReturnOneParam = (int a) -> {
    System.out.println("NoReturnOneParam param:" + a);
};
noReturnOneParam.method(6);

//多个参数无返回
NoReturnMultiParam noReturnMultiParam = (int a, int b) -> {
    System.out.println("NoReturnMultiParam param:" + "{" + a +"," + + b +"}");
};
noReturnMultiParam.method(6, 8);

//无参有返回值
ReturnNoParam returnNoParam = () -> {
    System.out.print("ReturnNoParam");
    return 1;
};

int res = returnNoParam.method();
System.out.println("return:" + res);

//一个参数有返回值
ReturnOneParam returnOneParam = (int a) -> {
    System.out.println("ReturnOneParam param:" + a);
    return 1;
};

int res2 = returnOneParam.method(6);
System.out.println("return:" + res2);

//多个参数有返回值
ReturnMultiParam returnMultiParam = (int a, int b) -> {
    System.out.println("ReturnMultiParam param:" + "{" + a + "," + b +"}");
    return 1;
};

int res3 = returnMultiParam.method(6, 8);
System.out.println("return:" + res3);

2.3 简化示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
//1.简化参数类型，可以不写参数类型，但是必须所有参数都不写
NoReturnMultiParam lamdba1 = (a, b) -> {
    System.out.println("简化参数类型");
};
lamdba1.method(1, 2);

//2.简化参数小括号，如果只有一个参数则可以省略参数小括号
NoReturnOneParam lambda2 = a -> {
    System.out.println("简化参数小括号");
};
lambda2.method(1);

//3.简化方法体大括号，如果方法条只有一条语句，则可以胜率方法体大括号
NoReturnNoParam lambda3 = () -> System.out.println("简化方法体大括号");
lambda3.method();

//4.如果方法体只有一条语句，并且是 return 语句，则可以省略方法体大括号
ReturnOneParam lambda4 = a -> a+3;
System.out.println(lambda4.method(5));

ReturnMultiParam lambda5 = (a, b) -> a+b;
System.out.println(lambda5.method(1, 1));

2.4 表达式引用方法

有时候我们不是必须要自己重写某个匿名内部类的方法，我们可以可以利用 lambda表达式的接口快速指向一个已经被实现的方法。

语法

方法归属者::方法名 静态方法的归属者为类名，普通方法归属者为对象

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
public class Exe1 {
    public static void main(String[] args) {
        ReturnOneParam lambda1 = a -> doubleNum(a);
        System.out.println(lambda1.method(3));

        //lambda2 引用了已经实现的 doubleNum 方法
        ReturnOneParam lambda2 = Exe1::doubleNum;
        System.out.println(lambda2.method(3));

        Exe1 exe = new Exe1();

        //lambda4 引用了已经实现的 addTwo 方法
        ReturnOneParam lambda4 = exe::addTwo;
        System.out.println(lambda4.method(2));
    }

    /**
     * 要求
     * 1.参数数量和类型要与接口中定义的一致
     * 2.返回值类型要与接口中定义的一致
     */
    public static int doubleNum(int a) {
        return a * 2;
    }

    public int addTwo(int a) {
        return a + 2;
    }
}

2.5 构造方法的引用

一般我们需要声明接口，该接口作为对象的生成器，通过 类名::new 的方式来实例化对象，然后调用方法返回对象。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
interface ItemCreatorBlankConstruct {
    Item getItem();
}
interface ItemCreatorParamContruct {
    Item getItem(int id, String name, double price);
}

public class Exe2 {
    public static void main(String[] args) {
        ItemCreatorBlankConstruct creator = () -> new Item();
        Item item = creator.getItem();

        ItemCreatorBlankConstruct creator2 = Item::new;
        Item item2 = creator2.getItem();

        ItemCreatorParamContruct creator3 = Item::new;
        Item item3 = creator3.getItem(112, "鼠标", 135.99);
    }

三、常用函数式接口

jdk默认的接口定义在java.util.function包中，常用的有：

  • Predicate
1
boolean test(T t);
  • Supplier
1
T get();
  • Consumer
1
void accept(T t);
  • Function
1
R apply(T t);

四、参考

https://www.cnblogs.com/haixiang/p/11029639.html