前言：
通过创建子线程的例子，来进行分析学习。
public class LambdaDemo {
public static void main(String[] args) {
// Thread thread = new Thread(new MyRunnable());
// thread.start();
//匿名内部类的方式改进
// new Thread(new Runnable() {
// @Override
// public void run() {
// System.out.println("多线程启动");
// }
// }).start();
//Lambda表达式
new Thread(()->{
System.out.println("多线程启动");
}).start();
}
}
1.分析匿名内部类重写run()方法的代码
- 方法形式参数为空，说明调用方法时，不需要传递参数
- 方法返回值类型为void，说明方法执行没有结果返回
- 方法体中的内容，是我们要做的事情
2.Lambda表达式的代码分析
- () ：里面没有内容，可以看成是方法形式参数为空
- ->：用箭头指向后面要做的事情
- {}：包含一段代码，我们称之为代码块，可以看成是方法体中的内容
总结：组成Lambda表达式的三要素：形式参数，箭头，代码块
正文：
Lambda表达式的格式：
- 格式：(形式参数)->{代码块}
- 形式参数：如果有多个参数，参数之间用逗号隔开，如果没有参数，留空即可
- ->:由英文中画线和大于符号组成，固定写法。代表指向动作
- 代码块：是我们具体要做的事情，也就是以前我们写的方法体内容
一、使用Lambda表达式练习1
/**
* 1.定义一个接口(Eatable),里面定义了一个抽象方法：void eat()
* 2.定义一个测试类(EatableDemo),在测试类中提供了两个方法，一个方法是useEatable(Eatable)
* 一个是主方法，在主方法中调用useEatable()方法
*/
public class EatableDemo {
public static void main(String[] args) {
//EatableImple是Eatable接口的实现类，重写了eat()方法
// useEatable(new EatableImple());
//使用匿名内部类
useEatable(new Eatable() {
@Override
public void eat() {
System.out.println("hello,world!");
}
});
//使用Lambda表达式
useEatable(() -> {
System.out.println("hello,world!");
});
}
private static void useEatable(Eatable eatable) {
eatable.eat();
}
}
输出结果：
hello,world!
hello,world!
二、使用Lambda表达式练习2
/**
* 1.定义一个接口(Flyable),里面定义了一个抽象方法：void fly(String s);
* 2.定义一个测试类(FlyableDemo),在测试类中提供了两个方法，
* 一个方法是fly(Flyable flyable)
* 一个是主方法，在主方法中调用fly()方法
*/
public class FlyableDemo {
public static void main(String[] args) {
//使用匿名内部类
fly(new Flyable() {
@Override
public void fly(String s) {
System.out.println(s);
}
});
System.out.println("----------");
//使用Lambda表达式
fly((String s) -> {
System.out.println(s);
});
}
private static void fly(Flyable flyable) {
flyable.fly("Java语言");
}
}
输出结果：
Java语言
----------
Java语言
三、使用Lambda表达式练习3
/**
* 1.定义一个接口(Addable),里面定义了一个抽象方法：int add(int x,int y);
* 2.定义一个测试类(AddableDemo),在测试类中提供了两个方法，
* 一个方法是：useAddable(Addable a)
* 一个是主方法，在主方法中调用useAddable方法
*/
public class AddableDemo {
public static void main(String[] args) {
//使用匿名内部类实现
useAddable(new Addable() {
@Override
public int add(int x, int y) {
return x + y;
}
});
//使用Lambda表达式
useAddable((int x, int y) -> {
return x + y;
});
}
private static void useAddable(Addable a) {
int sum = a.add(2, 6);
System.out.println(sum);
}
}
输出结果：
8
8
四、Lambda表达式的省略模式
省略规则：
- 参数类型可以省略。但是有多个参数的情况下，不能只省略一个。
- 如果参数有且仅有一个，那么小括号可以省略。
- 如果代码块的语句只有一条，则可以省略大括号和分号，甚至是return。
演示如下：
public class LambdaDemo {
public static void main(String[] args) {
// useAddable((int x, int y) -> {
// return x + y;
// });
//参数的类型可以省略
useAddable((x, y) -> {
return x + y;
});
//但有多个参数的情况下,不能只省略一个,编译不通过
// useAddable((x, int y) -> {
// return x + y;
// });
// useFlyable((String s)->{
// System.out.println(s);
// });
// useFlyable(s -> {
// System.out.println(s);
// });
//如果代码块的语句只有一条，可以省略大括号和分号
useFlyable(s -> System.out.println(s));
//如果代码块的语句只有一条，可以省略大括号和分号。如果有return,return也要省略掉
useAddable((x, y) -> x + y);
}
private static void useFlyable(Flyable flyable) {
flyable.fly("风和日丽,晴空万里");
}
private static void useAddable(Addable addable) {
int add = addable.add(10, 20);
System.out.println(add);
}
}
五、Lambda表达式的省略模式
注意事项：
- 使用Lambda表达式必须要有接口，并且要求接口中有且仅有一个抽象方法。
- 必须有上下文环境，才能推导出Lambda对应的接口
根据局部变量的赋值得知Lambda对应的接口：Runnable r = () -> System.out.println(“匿名内部类”);
根据调用方法的参数得知Lambda对应的接口：new Thread(() -> System.out.println(“Lambda表达式”)).start();
演示代码如下：
public class IterDemo {
public static void main(String[] args) {
useInter(() -> {
System.out.println("好好学习，天天向上！");
});
//使用Lambda表达式必须要有接口，并且要求接口中有且仅有一个抽象方法
useInter(() -> System.out.println("好好学习，天天向上！"));
//必须有上下文环境，才能推导出Lambda对应的接口
new Thread(new Runnable() {
@Override
public void run() {
System.out.println("匿名内部类");
}
}).start();
Runnable r = () -> System.out.println("Lambda表达式");
new Thread(r).start();
new Thread(() -> System.out.println("Lambda表达式")).start();
}
private static void useInter(Inter inter) {
inter.show();
}
}
输出结果：
好好学习，天天向上！
好好学习，天天向上！
匿名内部类
Lambda表达式
Lambda表达式
六、Lambda表达式和匿名内部类的区别
代码演示：
1、创建一个接口名为：Inter
public interface Inter {
void show();
// void show2();
}
2、创建一个抽象类：Animal
public abstract class Animal {
public abstract void method();
}
3、创建一个具体类：Student
public class Student {
public void study(){
System.out.println("爱生活，爱java");
}
}
4、创建一个测试类：Lambda
public class Lambda {
public static void main(String[] args) {
//匿名内部类
useInter(new Inter() {
@Override
public void show() {
System.out.println("接口");
}
});
//
// useAnimal(new Animal() {
// @Override
// public void method() {
// System.out.println("抽象类 ");
// }
// });
//
// useStudent(new Student() {
// @Override
// public void study() {
// System.out.println("爱学习！");
// }
// });
//使用Lambda表达式
// useInter(()-> System.out.println("接口"));
//下面这两个编译错误，使用Lambda表达式必须要有接口，并且要求接口中有且仅有一个抽象方法。
// useAnimal(()->{
// System.out.println("抽象类");
// });
// useStudent(()-> System.out.println("具体类"));
// useInter(new Inter() {
// @Override
// public void show() {
// System.out.println("show");
// }
//
// @Override
// public void show2() {
// System.out.println("show2");
// }
// });
}
private static void useStudent(Student s) {
s.study();
}
private static void useInter(Inter inter) {
inter.show();
}
private static void useAnimal(Animal animal) {
animal.method();
}
}
具体区别：
