JAVA Lambda 表达式

Lambda表达式

1.1 体验Lambda表达式【理解】

• 代码演示

?

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

/* 游泳接口 */ interface Swimming {     void swim(); } public class TestSwimming {         public static void main(String[] args) {         // 通过匿名内部类实现         goSwimming(new Swimming() {             @Override             public void swim() {             System.out.println("铁汁, 我们去游泳吧");             }         });     /* 通过Lambda表达式实现     理解: 对于Lambda表达式, 对匿名内部类进行了优化     */           goSwimming(() ‐> System.out.println("铁汁, 我们去游泳吧"));         } /** * 使用接口的方法 */ public static void goSwimming(Swimming swimming) {         swimming.swim();     } }

• 函数式编程思想概述

　　在数学中，函数就是有输入量、输出量的一套计算方案，也就是“拿数据做操作” 面向对象思想强调“必须通过对象的形式来做事情”

　　函数式思想则尽量忽略面向对象的复杂语法：“强调做什么，而不是以什么形式去做” 而我们要学习的Lambda表达式就是函数式思想的体现

1.2 Lambda表达式的标准格式【理解】

• 格式：

　　(形式参数) -> {代码块}

　　1.形式参数：如果有多个参数，参数之间用逗号隔开；如果没有参数，留空即可

　　2. ->：由英文中画线和大于符号组成，固定写法。代表指向动作

　　3.代码块：是我们具体要做的事情，也就是以前我们写的方法体内容

• 组成Lambda表达式的三要素：

　　形式参数，箭头，代码块

1.3 Lambda表达式练习1【应用】

• Lambda表达式的使用前提

　　1.有一个接口

　　2.接口中有且仅有一个抽象方法

• 练习描述

　　无参无返回值抽象方法的练习

• 操作步骤

　　1.定义一个接口(Eatable)，里面定义一个抽象方法：void eat();

　　2.定义一个测试类(EatableDemo)，在测试类中提供两个方法一个方法是：useEatable(Eatable e)

　　3.一个方法是主方法，在主方法中调用useEatable方法

• 示例代码

?

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

//接口 public interface Eatable { 　　void eat(); } //实现类 public class EatableImpl implements Eatable { 　　@Override 　　public void eat() { 　　　　System.out.println("一天一苹果，医生远离我"); 　　　　} 　　} //测试类 public class EatableDemo { 　　public static void main(String[] args) {<br> 　　//在主方法中调用useEatable方法<br>　　Eatable e = new EatableImpl(); 　　useEatable(e);<br> 　　//匿名内部类 　　useEatable(new Eatable() { 　　@Override 　　public void eat() { 　　　　　System.out.println("一天一苹果，医生远离我"); 　　} 　　});<br> 　　//Lambda表达式 　　useEatable(() ‐> { 　　　　System.out.println("一天一苹果，医生远离我"); 　　}); 　　} private static void useEatable(Eatable e) { 　　　　e.eat(); 　　} }

1.4 Lambda表达式练习2【应用】

• 练习描述

　　有参无返回值抽象方法的练习

• 操作步骤

　　定义一个接口(Flyable)，里面定义一个抽象方法：void fly(String s);

　　定义一个测试类(FlyableDemo)，在测试类中提供两个方法

　　　　一个方法是：useFlyable(Flyable f)

　　　　一个方法是主方法，在主方法中调用useFlyable方法

示例代码

?

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

public interface Flyable { 　　void fly(String s); }<br> public class FlyableDemo { 　　public static void main(String[] args) { 　　//在主方法中调用useFlyable方法<br> 　　//匿名内部类 　　useFlyable(new Flyable() { 　　　　@Override 　　　　public void fly(String s) { 　　　　System.out.println(s); 　　　　System.out.println("飞机自驾游"); 　　　　} 　　}); 　　System.out.println("‐‐‐‐‐‐‐‐"); <br>　　//Lambda 　　useFlyable((String s) ‐> { 　　　　System.out.println(s); 　　　　System.out.println("飞机自驾游"); 　　}); } private static void useFlyable(Flyable f) { 　　　　f.fly("风和日丽，晴空万里"); }

1.5 Lambda表达式练习3【应用】

• 练习描述

　　有参有返回值抽象方法的练习

• 操作步骤

　　定义一个接口(Addable)，里面定义一个抽象方法：int add(int x,int y);

　　定义一个测试类(AddableDemo)，在测试类中提供两个方法

　　　　一个方法是：useAddable(Addable a)

　　　　一个方法是主方法，在主方法中调用useAddable方法

示例代码

?

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

public interface Addable { 　　int add(int x,int y); } public class AddableDemo { 　　public static void main(String[] args) { 　　//在主方法中调用useAddable方法 　　useAddable((int x,int y) ‐> { 　　　　return x + y; 　　　　}); 　　} private static void useAddable(Addable a) { 　　int sum = a.add(10, 20); 　　System.out.println(sum); 　　} }

1.6 Lambda表达式的省略模式【应用】

• 省略的规则

　　参数类型可以省略。但是有多个参数的情况下，不能只省略一个

　　如果参数有且仅有一个，那么小括号可以省略

　　如果代码块的语句只有一条，可以省略大括号和分号，和return关键字

• 代码演示

?

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

public interface Addable { 　　int add(int x, int y); } public interface Flyable { 　　void fly(String s); }   public class LambdaDemo { 　　public static void main(String[] args) { 　　　　// useAddable((int x,int y) ‐> { 　　　　// return x + y; 　　　　// }); 　　　　//参数的类型可以省略 　　useAddable((x, 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 f) { 　　　　f.fly("风和日丽，晴空万里"); } private static void useAddable(Addable a) { 　　　　int sum = a.add(10, 20); 　　　　System.out.println(sum); 　　} }

　　

1.7 Lambda表达式的使用前提【理解】

• 使用Lambda必须要有接口
• 并且要求接口中有且仅有一个抽象方法

1.8 Lambda表达式和匿名内部类的区别【理解】

• 所需类型不同

　　　　1.匿名内部类：可以是接口，也可以是抽象类，还可以是具体类

　　　　2.Lambda表达式：只能是接口

• 使用限制不同

　　　　1.如果接口中有且仅有一个抽象方法，可以使用Lambda表达式，也可以使用匿名内部类

　　　　2.如果接口中多于一个抽象方法，只能使用匿名内部类，而不能使用Lambda表达式

• 实现原理不同

　　　　1.匿名内部类：编译之后，产生一个单独的.class字节码文件

　　　　2.Lambda表达式：编译之后，没有一个单独的.class字节码文件。对应的字节码会在运行的时候动态生成