Lambda表达式和函数式接口结合
什么是函数式接口
函数式接口(Functional Interface)就是一个有且仅有一个抽象方法,但是可以有多个非抽象方法的接口。函数式接口可以被隐式转换为 lambda 表达式。
- 函数接口要在接口上增加 @FunctionalInterface 注解。
- java8对接口进行了增强,可以拥有static defult等方法,接口的属性默认为public static final
- 新增的静态方法和默认方法是否会影响其成为一个函数接口呢,并不会,原因是:静态方法和默认方法均为非抽象方法!
- 完整函数式接口例子如下(可以只要一个有且仅有一个抽象方法):
@FunctionalInterface
public interface InterfacePlus {
//public static final
String defultValue = null;
void run();
@Override
boolean equals(Object o);
static Date createDate() {
return new Date();
}
default void sayHello() {
System.out.println("Hello Java8!");
}
}
什么是lambda表达式
Lambda 表达式,也可称为闭包,它是推动 Java 8 发布的最重要新特性。Lambda 允许把函数作为一个方法的参数(函数作为参数传递进方法中。
- 例子
// 1. 不需要参数,返回值为 5
() -> 5
// 2. 接收一个参数(数字类型),返回其2倍的值
x -> 2 * x
// 3. 接受2个参数(数字),并返回他们的差值
(x, y) -> x – y
// 4. 接收2个int型整数,返回他们的和
(int x, int y) -> x + y
// 5. 接受一个 string 对象,并在控制台打印,不返回任何值(看起来像是返回void)
(String s) -> System.out.print(s)
lambda和FunctionalInterface二者结合擦出火花
无参数无返回值函数式接口
/**
* @Description: 无参无返回值函数式接口
* @Author: jianweil
* @date: 2020/12/8 15:19
*/
@FunctionalInterface
public interface InterfaceNoParamNoResult {
void run();
}
无参有返回值函数式接口
/**
* @Description: 无参有返回值函数式接口
* @Author: jianweil
* @date: 2020/12/8 15:19
*/
@FunctionalInterface
public interface InterfaceNoParamWithResult {
String run();
}
有参无返回值函数式接口
/**
* @Description: 有参无返回值函数式接口
* @Author: jianweil
* @date: 2020/12/8 15:19
*/
@FunctionalInterface
public interface InterfaceWithParamNoResult {
void run(String s);
}
有参有返回值函数式接口
/**
* @Description: 有参有返回值函数式接口
* @Author: jianweil
* @date: 2020/12/8 15:19
*/
@FunctionalInterface
public interface InterfaceWithParamWithResult {
String run(Integer integer);
}
测试
/**
* @Description: 包含属性为函数式接口的类
* Lambda表达式和函数式接口结合
* @Author: jianweil
* @date: 2020/12/8 15:20
*/
public class TestLambda {
/**
* 无参数无返回
*/
//匿名内部类
InterfaceNoParamNoResult param1 = new InterfaceNoParamNoResult() {
@Override
public void run() {
System.out.println("通过匿名内部类实现run()");
}
};
//Lambda表达式 空括号表示无参
InterfaceNoParamNoResult param = () -> System.out.println("通过Lambda表达式实现run()") ;
/**
* 有参数无返回
*/
InterfaceWithParamNoResult interfaceWithParamNoResult = new InterfaceWithParamNoResult() {
@Override
public void run(String s) {
System.out.println("通过" + s + "实现run(String)");
}
};
InterfaceWithParamNoResult interfaceWithParamNoResult2 = (String s) -> System.out.println("通过" + s + "实现run(String)");
/**
* 无参数有返回
*/
InterfaceNoParamWithResult interfaceNoParamWithResult = new InterfaceNoParamWithResult() {
@Override
public String run() {
return "Hello World!";
}
};
InterfaceNoParamWithResult interfaceNoParamWithResult2 = () -> "Hello Lambda!";
/**
* 有参数有返回
*/
InterfaceWithParamWithResult interfaceWithParamWithResult = new InterfaceWithParamWithResult() {
@Override
public String run(Integer integer) {
return String.valueOf(integer);
}
};
InterfaceWithParamWithResult interfaceWithParamWithResult2 = (Integer integer) -> String.valueOf(integer);
public static void main(String[] args) {
System.out.println("---------");
new TestLambda().param.run();
new TestLambda().param1.run();
System.out.println("---------");
new TestLambda().interfaceWithParamNoResult.run("匿名类");
new TestLambda().interfaceWithParamNoResult2.run("lambda");
System.out.println("---------");
System.out.println(new TestLambda().interfaceNoParamWithResult.run());
System.out.println(new TestLambda().interfaceNoParamWithResult2.run());
System.out.println("---------");
System.out.println(new TestLambda().interfaceWithParamWithResult.run(1));
System.out.println(new TestLambda().interfaceWithParamWithResult2.run(2));
}
}
运行结果
---------
通过Lambda表达式实现run()
通过匿名内部类实现run()
---------
通过匿名类实现run(String)
通过lambda实现run(String)
---------
Hello World!
Hello Lambda!
---------
1
2