前言：
通过创建子线程的例子，来进行分析学习。
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(); } }
具体区别：
