首页 > 其他分享 >7.lambda表达式

7.lambda表达式

时间:2022-10-16 18:55:53浏览次数:55  
标签:int void MathOperation 接口 operation public 表达式 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 }

 

标签:int,void,MathOperation,接口,operation,public,表达式,lambda
From: https://www.cnblogs.com/midiyu/p/16796782.html

相关文章