Java Review (十六、面向对象----Lambda 表达式)

举报
三分恶 发表于 2021/04/30 03:15:37 2021/04/30
【摘要】 文章目录 Lambda表达式入门用匿名内部类实现命令模式Lambda表示式实现命令模式 Lambda 表达式与函数式接口方法引用与构造器引用引用类方法引用特定对象的实例方法引用某类对象的实例方法引用构造器 Lambda 表达式与匿名内部类的联系和区别 Lambda 允许把函数作为一个方法的参数（函数作为参数传递到方法中）。 Lambda...

文章目录


Lambda 允许把函数作为一个方法的参数（函数作为参数传递到方法中）。

Lambda表达式入门

用匿名内部类实现命令模式


Command接口 

public interface Command { //接口里定义的方法相当于处理封装行为
	int progress(int[] target);
}

  
 
    
  
  • 1
    • 
  
  • 2
    • 
  
  • 3
    • 
  
  • 4
    •


ProgressArray.java 

public class ProgressArray {
  public ProgressArray() { } public void progress(int[] target,Command  cmd) { cmd.progress(target);
  }
}

  
 
    
  
  • 1
    • 
  
  • 2
    • 
  
  • 3
    • 
  
  • 4
    • 
  
  • 5
    • 
  
  • 6
    • 
  
  • 7
    • 
  
  • 8
    •


CommandInnerTest.java 

public class CommandInnerTest {
  public CommandInnerTest() {
  } public static void main(String[] args) {
	ProgressArray progressArray=new ProgressArray();
	int[] array= new int[] {3, -4, 6, 4} ;
	//处理数组，具体处理行为取决于匿名内部类
	progressArray.progress(array, new Command() { @Override
		public void progress(int[] target) { int sum=0; int[] a=target; for(int j=0;j<a.length;j++ ) { int temp=a[j]; sum+=temp; } System.out.println("数组元素的总和："+sum);
		}
	});
}
}

  
 
    
  
  • 1
    • 
  
  • 2
    • 
  
  • 3
    • 
  
  • 4
    • 
  
  • 5
    • 
  
  • 6
    • 
  
  • 7
    • 
  
  • 8
    • 
  
  • 9
    • 
  
  • 10
    • 
  
  • 11
    • 
  
  • 12
    • 
  
  • 13
    • 
  
  • 14
    • 
  
  • 15
    • 
  
  • 16
    • 
  
  • 17
    • 
  
  • 18
    • 
  
  • 19
    • 
  
  • 20
    • 
  
  • 21
    • 
  
  • 22
    • 
  
  • 23
    •

Lambda表示式实现命令模式

Lambda 表达式可用于简化创建匿名内部类对象：

CommandLambdaTest.java 

public class CommandLambdaTest {
	public static void main(String[] args) {
		ProgressArray progressArray = new ProgressArray();
		int[] array = { 3, -4, 6, 4 };
		// 处理数组，具体行为取决于匿名内部类
		progressArray.progress(array, (int[] target) -> { int sum = 0; for (int temp : array) { sum += temp; } System.out.println("数组元素总和为" + sum);
		});
	}
}

  
 
    
  
  • 1
    • 
  
  • 2
    • 
  
  • 3
    • 
  
  • 4
    • 
  
  • 5
    • 
  
  • 6
    • 
  
  • 7
    • 
  
  • 8
    • 
  
  • 9
    • 
  
  • 10
    • 
  
  • 11
    • 
  
  • 12
    • 
  
  • 13
    • 
  
  • 14
    •

当使用 Lambda 表达式代替匿名内部类创建对象时， Lambda 表达式的代码
块将会代替实现抽象方法的方法体， Lambda 表达式就相当一个匿名方法。

从上面语法格式可以看出， Lambda 表达式的主要作用就是代替匿名内部类的烦琐语法。它分三部分组成。

  • 形参列表 。形参列表允许省略形参类型 。如果形参列表中只有一个参数，甚至连形参列表的圆括号也可以省略。
  • 箭头 —>。必须通过英文中画线和大于符号组成。
  • 代码块。如果代码块只包含一条语句， Lambda 表达式允许省略代码块的花括号，那么这条语句就不要用花括号表示语句结束。 Lambda 码块只有一条 return语句，甚至可以省略return关键字， Lambda 表达式会自动返回这条语句的值。


Lambda语法简单实例 

public class LambdaTest { public static void main(String[] args) {
		LambdaTest tester=new LambdaTest();
		// 类型声明
		MathOperation addition = (int a, int b) -> a + b; // 不用类型声明
		MathOperation subtraction = (a, b) -> a - b; // 大括号中的返回语句
		MathOperation multiplication = (int a, int b) -> { return a * b;
		}; // 没有大括号及返回语句
		MathOperation division = (int a, int b) -> a / b; System.out.println("10 + 5 = " + tester.operate(10, 5, addition));
		System.out.println("10 - 5 = " + tester.operate(10, 5, subtraction));
		System.out.println("10 x 5 = " + tester.operate(10, 5, multiplication));
		System.out.println("10 / 5 = " + tester.operate(10, 5, division)); // 不用括号
		GreetingService greetService1 = message -> System.out.println("Hello " + message); // 用括号
		GreetingService greetService2 = (message) -> System.out.println("Hello " + message); greetService1.sayMessage("Runoob");
		greetService2.sayMessage("Google");
	}

	interface MathOperation {
		int operation(int a, int b);
	}

	interface GreetingService {
		void sayMessage(String message);
	}

	private int operate(int a, int b, MathOperation mathOperation) {
		return mathOperation.operation(a, b);
	}

}

  
 
    
  
  • 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
    • 
  
  • 45
    • 
  
  • 46
    • 
  
  • 47
    •

Lambda 表达式与函数式接口

Lambda 表达式的类型，也被称为"目标类型( target type) ", Lambda 表达式的目标类型必须是"函数式接口( functional interface ) "。 函数式接口代表只包含一个抽象方法的接口 。 函数式接口可以包含多个默认方法、类方法，但只能声明一个抽象方法 。

如果采用匿名内部类语法来创建函数式接口的实例，则只需要实现一个抽象方法，在这种情况下即可采用 Lambda 表达式来创建对象，该表达式创建出来的对象的目标类型就是这个函数式接口 。 查询 Java 8的 API 文档，可以发现大量的函数式接口，例如: Runnable、 ActionListener 等接口都是函数式接口 。

Java 8专门为函数式接口提供了 @FunctionalInterface 注解，该注解通常放在接口定义前面，该注解对程序功能没有任何作用，它用于告诉编译器执行更严格检查一一检查该接口必须是函数式接口 ，否则编译器就会报错。

由于 Lambda 表达式的结果就是被当成对象 ， 因此程序中完全可以使用 Lambda 表达式进行赋值，

例如如下代码 ：

// Runnable 接口中只包含一个无参数的方法
// Lambda 表达式代表的匿名方法实现了 Runnable 接口中唯一的、无参数的方法
// 因此下面的 Lambda 表达式创建了 一个 Runnable 对象
Runnable r = () -> { for(int i = 0 ; i < 100 ; i ++){ System.out.println() ;
 }
 
} 

  
 
    
  
  • 1
    • 
  
  • 2
    • 
  
  • 3
    • 
  
  • 4
    • 
  
  • 5
    • 
  
  • 6
    • 
  
  • 7
    • 
  
  • 8
    • 
  
  • 9
    •

Lambda 表达式实现的是匿名方法，因此它只能实现特定函数式接口中的唯一方法 。 这意味着 Lambda 表达式有如下两个限制 ：

  • Lambda 表达式的目标类型必须是明确的函数式接口 。
  • Lambda 表达式只能为函数式接口创建对象 。 Lambda 表达式只能实现一个方法 ， 因此它只能为只有一个抽象方法的接口(函数式接口)创建对象 。

为了保证 Lambda 表达式的目标类型是一个明确的函数式接口，可以有如下三种常见方式 。

  • 将 Lambda 表达式赋值给函数式接口类型的变量 。
  • 将 Lambda 表达式作为函数式接口类型的参数传给某个方法 。
  • 使用函数式接口对 Lambda 表达式进行强制类型转换。
Object obj1 = (Runnable) () - > {
  for(int i = 0 ; i < 100 ; i ++{ System.out.println(i);
  } 
  
 
    
  
  • 1
    • 
  
  • 2
    • 
  
  • 3
    • 
  
  • 4
    •

方法引用与构造器引用

如果 Lambda 表达式的代码块只有一条代码，程序就可以省略Lambda 表达式中
代码块的花括号 。 不仅如此，如果 Lambda 表达式的代码块只有一条代码，还可以在代码块中使用方法引用和构造器引用 。

方法引用和构造器引用可以让 Lambda 表达式的代码块更加简洁 。 方法引用和构造器引用都需要使用两个英文冒号。


Lambda 表达式支持的方法引用和构造器引用

在这里插入图片描述

引用类方法

//函数式接口
@FunctionalInterface
interface Converter{
//将 String 参数转换为Integer
  Integer convert(String from);
}

  
 
    
  
  • 1
    • 
  
  • 2
    • 
  
  • 3
    • 
  
  • 4
    • 
  
  • 5
    • 
  
  • 6
    • 
 
// 下面代码使用 Larnbda 表达式创建 Converter 对象
Converter converterl = from -> Integer.valueOf(from);

  
 
    
  
  • 1
    • 
  
  • 2
    • 
 
//调用 converterl 对象的 convertO方法将字符串转换为整数
Integer val = converterl.convert( " 99 " );
System.out.println (val); // 输出整数 99

  
 
    
  
  • 1
    • 
  
  • 2
    • 
  
  • 3
    •

可以如下替换：

//方法引用代替 Larnbda 表达式:引用类方法
//函数式接口中被实现方法的全部参数传给该类方法作为参数
Converter converterl = Integer::valueOf;

  
 
    
  
  • 1
    • 
  
  • 2
    • 
  
  • 3
    •

引用特定对象的实例方法

// 下面代码使用 Larnbda 表达式创建 Converter 对象
Converter converter2 = from - > " fkit.org ".indexOf (from) ;

  
 
    
  
  • 1
    • 
  
  • 2
    • 
 
//调用 converterl 对象的 convertO方法将字符串转换为整数
Integer value = converter2.convert( "it "};
System.out.println(value} ;   //输出 2

  
 
    
  
  • 1
    • 
  
  • 2
    • 
  
  • 3
    •

可以如下替换：

// 方法引用代替 Lambda 表达式 : 引用特定对象 的实例方法
// 函数式接口中被实现方法的全部参数传给该方法作为参数
Converter converter2 = "fkit.org": :indexOf ;

  
 
    
  
  • 1
    • 
  
  • 2
    • 
  
  • 3
    •

引用某类对象的实例方法

//定义函数式接口
@Functionallnterface
interface MyTest{
  //根据 String 、 int 、 int 三个参数生成一个 String返回值
  String test(String a , int b , int c);
}  

  
 
    
  
  • 1
    • 
  
  • 2
    • 
  
  • 3
    • 
  
  • 4
    • 
  
  • 5
    • 
  
  • 6
    • 
 
// 下面代码使用 Lambda 表达式创建 MyTest 对象
MyTest mt = (a , b , c) - > a.substring(b , c};

  
 
    
  
  • 1
    • 
  
  • 2
    • 
 
//调用mt的test()方法
String str = mt.test( "Java 1 Love you" , 2 , 9) ;
System.out.println(str} ; // 输出 : va 1 Lo

  
 
    
  
  • 1
    • 
  
  • 2
    • 
  
  • 3
    •

可以如下替换：

// 方法引用代替 Lambda 表达式: 引 用某类对象 的实例方法
// 函数式接口中被实现方法的第一个参数作为调用者
// 后面的参数全部传给该方法作为参数
MyTest mt = String ::substring;

  
 
    
  
  • 1
    • 
  
  • 2
    • 
  
  • 3
    • 
  
  • 4
    •

引用构造器

@Funct ionallnterface
interface YourTest{
//根据 String 参数生成一个 JFrame 返回值
 JFrame win(String title);

  
 
    
  
  • 1
    • 
  
  • 2
    • 
  
  • 3
    • 
  
  • 4
    • 
 
// 下面代码使用 Lambda 表达式创建 YourTest 对象
YourTest yt = (String a) - > new JFrame(a);

  
 
    
  
  • 1
    • 
  
  • 2
    • 
 
JFrame jf = yt.win( "我的窗口 ") ;
System.out.println(jf) ;

  
 
    
  
  • 1
    • 
  
  • 2
    •

可以如下替换：

// 构造器引用代替 Lambda 表达式
//函数式接口中被实现方法的全部参数传给该构造器作为参数
YourTest yt = JFrame ::new;

  
 
    
  
  • 1
    • 
  
  • 2
    • 
  
  • 3
    •

Lambda 表达式与匿名内部类的联系和区别

从前面介绍可以看出， Lambda 表达式是匿名内部类的一种简化 ， 因此它可以部分取代匿名内部类的作用。

Lambda 表达式与匿名内部类存在如下相同点 :

  • Lambda 表达式与匿名内部类一样，都可以直接访问 “effectively final” 的局部变量，以及外部类的成员变量(包括实例变量和类变量〉 。
  • Lambda 表达式创建的对象与匿名内部类生成的对象一样，都可以直接调用从接口中继承的默认方法 。

Lambda 表达式与匿名内部类主要存在如下区别:

  • 匿名内部类可以为任意接口创建实例一一不管接口包含多少个抽象方法，只要匿名内部类实现所有的抽象方法即可;但 Lambda 表达式只能为函数式接口创建实例。
  • 匿名内部类可以为抽象类甚至普通类创建实例 ; 但 Lambda 表达式只能为函数式接口创建实例 。
  • 匿名内部类实现的抽象方法的方法体允许调用接口中定义的默认方法 ; 但 Lambda 表达式的代码块不允许调用接口中定义的默认方法。



Java Review系列目录

⇐⇐Java Review (十五、面向对象----内部类)   Java Review (十七、面向对象----枚举类)⇒⇒


参考：

【1】：《疯狂Java讲义》
【2】：https://www.jb51.net/article/171183.htm
【3】：https://www.runoob.com/java/java8-lambda-expressions.html
【4】：《Java核心技术 卷一》

文章来源: blog.csdn.net，作者：三分恶，版权归原作者所有，如需转载，请联系作者。

原文链接：blog.csdn.net/sinat_40770656/article/details/102845219

【版权声明】本文为华为云社区用户转载文章，如果您发现本社区中有涉嫌抄袭的内容，欢迎发送邮件进行举报，并提供相关证据，一经查实，本社区将立刻删除涉嫌侵权内容，举报邮箱： cloudbbs@huaweicloud.com
Java 面向对象编程
  • 点赞
  • 收藏
  • 关注作者

评论（0）

0/1000
抱歉，系统识别当前为高风险访问，暂不支持该操作

全部回复

上滑加载中

设置昵称

在此一键设置昵称，即可参与社区互动！

*长度不超过10个汉字或20个英文字符，设置后3个月内不可修改。

*长度不超过10个汉字或20个英文字符，设置后3个月内不可修改。

确认 取消

加入云驻计划，成为创作者

  • 华为云周边好礼
  • 免费体验产品
  • 特殊身份标识
  • 线下官方门票
  • 内部专家零距离
  • 与10000+优质创作者共同成长
立即加入