Lambda表达式
1、 Lambda表达式的方式启动一个线程
public class MyRunnable implements Runnable{
@Override
public void run() {
System.out.println("线程启动了!");
}
}
//Lambda基本使用
public class LambdaDemo1 {
public static void main(String[] args) {
//第一种方式:启动一个线程
MyRunnable mr = new MyRunnable();
Thread t = new Thread(mr);
t.start();
//第二种方式:匿名内部类启动一个线程
new Thread(new MyRunnable(){
@Override
public void run() {
System.out.println("匿名内部类启动一个线程!");
}
}).start();
//第三种方式:lambda表达式启动一个线程
new Thread(() ->{
System.out.println("Lambda表达式的方式启动一个线程!");
}).start();
}
}
2、Lambda表达式的三要素:形式参数、箭头、表达式
3、Lambda表达式练习1
Lamabda使用前提:有一个接口,有且仅有一个抽象方法
/*练习:
1.定义一个接口(Eatable),里面定义一个抽象方法:void eat();
2.定义一个测试类(EatableDemo),在测试类中提供两个方法
一个方法是:useEatable(Eatable e)
一个方法是主方法,在主方法中调用useEatable方法
* */
public class EatableDemo1 {
public static void main(String[] args) {
//第一种:在主方法中调用useEatable方法
Eatable e = new EatableImpl();
useEatable(e);
//第二种:匿名内部类
useEatable(new Eatable() {
@Override
public void eat() {
System.out.println("这是一个接口实现类2!");
}
});
//第三种:Lambda表达式
useEatable(()->{
System.out.println("这是一个接口实现类3!");
});
}
//定义一个方法,把接口作为参数进行传递
private static void useEatable(Eatable e){
e.eat();
}
}
//接口实现类
public class EatableImpl implements Eatable {
@Override
public void eat() {
System.out.println("这是一个接口实现类1!");
}
}
//接口
public interface Eatable {
void eat();
}
4、Lambda表达式练习2
/*测试类
* 练习2:
1、定义一个接口(Flyable),里面定义一个抽象方法:void fly(String s);
2、定义一个测试类(FlyableDemo),在测试类中提供两个方法
一个方法是:useFlyable(Flyable)
一个方法是主方法,在主方法中调用useFlyable方法*/
public class FlyableDemo1 {
public static void main(String[] args) {
//匿名内部类
useFlyable(new Flyable() {
@Override
public void fly(String s) {
System.out.println(s);
System.out.println("匿名内部类自己的方法");
}
});
//Labbda方法
useFlyable((String s)->{
System.out.println(s);
System.out.println("这是Lambda的方法");
});
}
private static void useFlyable(Flyable f){
f.fly("这是调用接口中的抽象方法!");
}
}
//接口
public interface Flyable {
void fly(String s);
}
5、Lambda表达式练习3
/*练习3:
1、定义一个接口(Addable),里面定义一个抽象方法:int add(int x,int y);
2、定义一个测试类(AddableDemo),在测试类中提供两个方法
一个方法是:useAddable(Addable a)
一个方法是主方法,在主方法中调用useAddable方法
*/
public class AddableDemo1 {
public static void main(String[] args) {
//Lambda表达式方式
useAddable((int x,int y)->{
return x+y;
//return x-y;
});
}
private static void useAddable(Addable a){
int sum = a.add(10, 20);
System.out.println(sum);
}
}
//接口
public interface Addable {
int add(int x,int y);
}
6、Lambda表达式省略模式
/*练习3:
1、如果代码块的语句只有一条,可以省略大括号和分号,如果有return,也可以把return省略
2、有多个参数时,参数类型可以省略不写,但必须全部都不写
*/
public class AddableDemo1 {
public static void main(String[] args) {
//Lambda表达式方式:有多个参数时,类型可以省略不写,但必须全部都不写
useAddable((x,y)->{
return x+y;
//return x-y;
});
//Lambda省略模式式:如果代码块的语句只有一条,可以省略大括号和分号,如果有return,也可以把return省略
useAddable((x,y)->x+y);
//Labbda省略模式1:只有一个参数的情况下,小括号和类型都可以省略
//useFlyable((String s)->{对比下面一句
useFlyable((String s)->{
System.out.println(s);
System.out.println("这是Lambda的方法");
});
//Lambda省略模式2:如果代码块的语句只有一条,可以省略大括号和分号
useFlyable(s->System.out.println(s));
}
private static void useAddable(Addable a){
int sum = a.add(10, 20);
System.out.println(sum);
}
}
//接口
public interface Flyable {
void fly(String s);
}
//接口
public interface Addable {
int add(int x,int y);
}
7、Lambda表达注意事项
1. 使用Lambda表达式必须要有接口,并且要求接口中有且仅有一个抽象方法
2. 必须有上下文环境,才能推导出Lambda对应的接口
A. 根据局部变量的赋值得知Lambda对应的接口:Runnabler = () -> System.out.println(“Lambda表达式”);
B. 根据调用方法的参数得知Lambda对应的接口:Rubbabler = () -> System.out.println(“Lambda表达式”).start();
//接口
public interface Inter {
void show();
}
public class LambdaDemo1 {
public static void main(String[] args) {
//第一种:使用Lambda表达式必须要有接口,并且要求接口中有且仅有一个抽象方法
useInter(() -> System.out.println("好好学习,天天向上!"));
//第二种:根据调用方法的参数得知Lambda对应的接口
Runnable r = () -> System.out.println("Lambda表达式1");
new Thread(r).start();
//重点第三种:根据调用方法的参数得知Lambda对应的接口
new Thread(() -> System.out.println("Lambda表达式2")).start();
}
private static void useInter(Inter i){
i.show();
}
}