文章目录
1. 函数式编程思想概述
- 在数学中,函数就是有输入量、输出量的一套计算方案,也就是 “拿数据做操作”
- 面向对象思想强调 “必须通过对象的形式来做事情”
- 函数式思想则尽量忽略面向对象的复杂语法,“强调做什么,而不是以什么形式去做”
- 而我们要学习的 Lambda 表达式就是函数式思想的体现
2. 体验 Lambda 表达式
需求:启动一个线程,在控制台输出一句话 “多线程程序启动了”。
方式一
-
定义一个类 MyThread 实现 Runnable 接口,重写 run() 方法
public class MyThread implements Runnable { @Override public void run() { System.out.println("多线程程序启动了"); } }
-
创建 Thread 类的对象,把 MyThread 的对象作为构造参数传递,启动线程
public class Test1 { public static void main(String[] args) { MyThread myThread = new MyThread(); Thread thread = new Thread(myThread); thread.start(); } }
方式二
匿名内部类的方式改进
public class Test2 {
public static void main(String[] args) {
new Thread(new Runnable() {
@Override
public void run() {
System.out.println("多线程程序启动了");
}
}).start();
}
}
方式三
Lambda 表达式的方式改进
public class Test3 {
public static void main(String[] args) {
new Thread(() -> {
System.out.println("多线程程序启动了");
}).start();
}
}
3. Lambda 表达式的标准格式
new Thread(new Runnable() {
@Override
public void run() {
System.out.println("多线程程序启动了");
}
}).start();
匿名内部类中重写 run() 方法的代码分析:
- 方法形式参数为空,说明调用方法时不需要传递参数
- 方法返回值类型为 void,说明方法执行没有结果返回
- 方法体中的内容,是我们具体要做的事情
new Thread(() -> {
System.out.println("多线程程序启动了");
}).start();
Lambda 表达式的代码分析:
- ():里面没有内容,可以看成是方法形式参数为空
- ->:用箭头指向后面要做的事情
- { }:包含一段代码,我们称之为代码块,可以看成是方法体中的内容
Lambda 表达式的格式:
- 格式:(形式参数) -> {代码块}
- 形式参数:如果有多个参数,参数之间用逗号隔开;如果没有参数,留空即可
- ->:由英文中画线和大于符号组成,固定写法。代表指向动作
- 代码块:是我们具体要做的事情,也就是以前我们写的方法体内容
4. Lambda 表达式的练习
Lambda 表达式的使用前提:
- 有一个接口
- 接口中有且仅有一个抽象方法
4.1 练习一(抽象方法无参无返回值)
需求:
- 定义一个接口(Eatable),里面定义一个抽象方法:void eat();
- 定义一个测试类(EatableDemo),在测试类中提供两个方法
- 一个方法是:useEatable(Eatable e)
- 一个方法是主方法,在主方法中调用 useEatable 方法
实现:
-
Eatable 接口
public interface Eatable { void eat(); }
-
测试类
public class EatableDemo { private static void useEatable(Eatable e) { e.eat(); } public static void main(String[] args) { useEatable(() -> { System.out.println("I eat an apple"); }); } }
-
运行结果
I eat an apple
4.2 练习二(抽象方法带参无返回值)
需求:
- 定义一个接口(Flyable),里面定义一个抽象方法:void fly(String s);
- 定义一个测试类(FlyableDemo),在测试类中提供两个方法
- 一个方法是:useFlyable(Flyable f)
- 一个方法是主方法,在主方法中调用 useFlyable 方法
实现:
-
Flyable 接口
public interface Flyable { void fly(String s); }
-
测试类
public class FlyableDemo { private static void useFlyable(Flyable f) { f.fly("I can fly"); } public static void main(String[] args) { useFlyable((String s) -> { System.out.println(s); System.out.println("I am flying"); }); } }
-
运行结果
I can fly I am flying
4.3 练习三(抽象方法带参带返回值)
需求:
- 定义一个接口(Addable),里面定义一个抽象方法:int add(int x,int y);
- 定义一个测试类(AddableDemo),在测试类中提供两个方法
- 一个方法是:useAddable(Addable a)
- 一个方法是主方法,在主方法中调用 useAddable 方法
实现:
-
Addable 接口
public interface Addable { int add(int x, int y); }
-
测试类
public class AddableDemo { private static void useAddable(Addable a) { int sum = a.add(10, 20); System.out.println(sum); } public static void main(String[] args) { useAddable((int a, int b) -> { return a + b; }); } }
-
运行结果
30
5. Lambda 表达式的省略模式
省略规则:
- 参数类型可以省略。但是有多个参数的情况下,不能只省略一个
- 如果参数有且仅有一个,那么小括号可以省略
- 如果代码块的语句只有一条,可以省略大括号和分号,甚至是 return
实例:
-
Flyable 接口
public interface Flyable { void fly(String s); }
-
Addable 接口
public interface Addable { int add(int x, int y); }
-
测试类
public class LambdaDemo { private static void useAddable(Addable a) { int sum = a.add(10, 20); System.out.println(sum); } private static void useFlyable(Flyable f) { f.fly("I can fly"); } public static void main(String[] args) { // 参数类型可以省略(一个参数时) useFlyable((s) -> { System.out.println(s); }); // 参数类型可以省略(多个参数时) useAddable((x, y) -> { return x + y; }); System.out.println("-------------"); // 如果参数有且仅有一个,那么小括号可以省略 useFlyable(s -> { System.out.println(s); }); System.out.println("-------------"); // 如果代码块的语句只有一条,可以省略大括号和分号 useFlyable(s -> System.out.println(s)); // 如果代码块的语句只有一条,可以省略大括号和分号,如果有 return 也要省略掉 useAddable((x, y) -> x + y); } }
-
运行结果
I can fly 30 ------------- I can fly ------------- I can fly 30
6. Lambda 表达式的注意事项
注意事项:
-
使用 Lambda 必须要有接口,并且要求接口中有且仅有一个抽象方法
-
必须有上下文环境,才能推导出 Lambda 对应的接口
-
根据局部变量的赋值得知 Lambda 对应的接口:
Runnable r = () -> System.out.println("Lambda表达式");
-
根据调用方法的参数得知 Lambda 对应的接口:
new Thread(() -> System.out.println("Lambda表达式")).start();
-
7. Lambda 表达式和匿名内部类的区别
所需类型不同
- 匿名内部类:可以是接口,也可以是抽象类,还可以是具体类
- Lambda 表达式:只能是接口
使用限制不同
- 如果接口中有且仅有一个抽象方法,可以使用 Lambda 表达式,也可以使用匿名内部类
- 如果接口中多于一个抽象方法,只能使用匿名内部类,而不能使用 Lambda 表达式
实现原理不同
- 匿名内部类:编译之后,产生一个单独的 .class 字节码文件
- Lambda 表达式:编译之后,没有一个单独的 .class 字节码文件。对应的字节码会在运行的时候动态生成