3.lambda表达式
一、说明
Lambda表达式是什么
- Lambda 表达式也称为闭包，是Java 8 发布的新特性
- Lambda 允许把函数作为一个方法的参数(函数作为参数传递进方法中)
为什么要使用Lambda表达式
- 避免匿名内部类定义过多，可以让代码简洁紧凑，留下核心的逻辑
二、理解
语法格式
1 (parameters) -> expression[表达式]
2 (parameters) -> statements[语句]
3 (parameters) ->{ statements; }
函数式接口
Functional lnterface(函数式接口)是指任何接口，如果只包含唯一一个抽象方法，那么它就是一个函数式接口，可以通过Lambda表达式创建该接口的对象
1 public interface Runnable {
2 public abstract void run();
3 }
特征
- 可省略类型声明：不需要声明形式参数类型
- 可省略参数括号：一个参数无需定义括号，但多个参数需要定义括号
- 可省略花括号：如果主体只包含了一个语句就不需要使用花括号
- 可省略返回关键字：如果主体只包含了一个返回值语句则会自动返回
三、演示
1.常规方法实现
正常情况下的实现加法函数计算，需要定义接口并实现类，再调用方法，在此基础上不断简化，去深入理解Lambda 表达式是如果做到的
1 public class LambdaDemo {
2
3 public static void main(String[] args) {
4 //3.执行计算
5 MathOperation addition = new Addition();
6 addition.operation(1,2);
7 }
8 }
9 //1.定义一个函数式接口方法
10 interface MathOperation{
11 void operation(int a, int b);
12 }
13 //2.定义实现类
14 class Addition implements MathOperation{
15 @Override
16 public void operation(int a, int b) {
17 System.out.println(a + b);
18 }
19 }
2.静态内部类
进一步改进使得代码更紧凑，实现静态内部类，也就是将实现类放入主类中，会提示我们需要定义静态类
1 public class LambdaDemo {
2 //2.实现静态内部类
3 static class Addition implements MathOperation{
4 @Override
5 public void operation(int a, int b) {
6 System.out.println(a + b);
7 }
8 }
9 public static void main(String[] args) {
10 //3.执行计算
11 MathOperation addition = new Addition();
12 addition.operation(1,2);
13 }
14 }
15 //1.定义一个函数式接口
16 interface MathOperation{
17 void operation(int a, int b);
18 }
3.局部内部类
可是静态内部类还是太繁琐了，如果把它放进方法里面呢？由此引出局部内部类，即在一个方法中定义的内部类，这时就不用定义静态类了
1 public class LambdaDemo {
2 public static void main(String[] args) {
3 //2.实现局部内部类
4 class Addition implements MathOperation{
5 @Override
6 public void operation(int a, int b) {
7 System.out.println(a + b);
8 }
9 }
10 //3.执行计算
11 MathOperation addition = new Addition();
12 addition.operation(1,2);
13 }
14 }
15 //1.定义一个函数式接口
16 interface MathOperation{
17 void operation(int a, int b);
18 }
4.匿名内部类
局部内部类还是感觉代码太多了，如果简化呢？比如把类名隐藏？匿名内部类就是没有名字的内部类，其必须实现接口或抽象父类的所有抽象方法
1 public class LambdaDemo {
2 public static void main(String[] args) {
3 //2.实现匿名内部类，实现接口，直接执行计算
4 new MathOperation(){
5 @Override
6 public void operation(int a, int b) {
7 System.out.println(a + b);
8 }
9 }.operation(1, 2);
10 }
11 }
12 //1.定义一个函数式接口
13 interface MathOperation{
14 void operation(int a, int b);
15 }
1 public class LambdaDemo {
2 public static void main(String[] args) {
3 //2.实现匿名内部类，实现接口
4 MathOperation addition = new MathOperation() {
5 @Override
6 public void operation(int a, int b) {
7 System.out.println(a + b);
8 }
9 };
10 //3.执行计算
11 addition.operation(1,2);
12 }
13 }
14 //1.定义一个函数式接口
15 interface MathOperation{
16 void operation(int a, int b);
17 }
5.Lambda表达式
都已经没有类名了，能否再简化呢？用Lambda试试，因为接口中只有一个方法，方法中只有一块语句，因此可以省略接口和方法，只留下语句实现
1 public class LambdaDemo {
2 public static void main(String[] args) {
3 //2.Lambda简化，只有一块语句，省略接口和方法，只留下语句实现
4 MathOperation addition = (int a , int b) -> {
5 System.out.println(a + b);
6 };
7 //3.执行计算
8 addition.operation(1, 2);
9 }
10 }
11 //1.定义一个函数式接口
12 interface MathOperation{
13 void operation(int a, int b);
14 }
6.Lambda再简化
Lambda 表达式还可以省略参数类型，因为一行语句，因此可以省略花括号
1 public class LambdaDemo {
2 public static void main(String[] args) {
3 //2.Lambda简化，省略参数类型，代码块只有一句，可以省略花括号
4 MathOperation addition = (a , b) -> System.out.println(a + b);
5 //3.执行计算
6 addition.operation(1,2);
7 }
8 }
9 //1.定义一个函数式接口
10 interface MathOperation{
11 void operation(int a, int b);
12 }
参考博客：
https://blog.csdn.net/qq_46207024/article/details/124183519#2_66
