Lambda表达式

函数式编程思想概述

面向对象思想强调“必须通过对象的形式做事”
在函数式思想中尽量忽略面向对象的复杂语法：“强调做什么，而不是什么形式做”

Lambda表达式的标准格式

• （）里面为空，可以看成是方法的形参为空
• -> 用箭头指向后面要做的事
• {} 包含一段代码，称为代码块，可以看成是方法体中的内容
  三要素：形式参数、箭头、代码块
  （形式参数）->{代码块}

Lambda表达式练习

Lambda表达式使用的前提条件

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

练习1

• 定义一个接口（Eatable）,里面定义一个抽象方法： void eat（）
• 定义一个测试类（EatableDemo），在测试类中提供两个方法
  • 一个 方法是：useEatable(Eatable e)
  • 一个方法是主方法，在主方法中调用useEatable方法

创建接口

public interface Eatable {
    void eat();
}

创建实现类

public class EatableImpl implements Eatable{
    @Override
    public void eat(){
        System.out.println("CC吃我的屎！");
    }
}

创建测试类

public class EatableDemo {
    public static void main(String[] args){
    	//实现类
        Eatable e=new EatableImpl();
        useEatable(e);

		//匿名内部类
		useEatable(new Eatable() {
            @Override
            public void eat() {
                System.out.println("CC吃我的屁！");
            }
        });
        //Lambda表达式
        useEatable(()->{
            System.out.println("CC吃我的大便！");
        });
    }
    private static void useEatable(Eatable e){
        e.eat();
    }
}

练习2

• 定义一个接口（Flyable）,里面定义一个抽象方法： void fly(String s)
• 定义一个测试类（FlyableDemo）,在测试类中提供两个方法
  • 一个是useFlyable(Flyable f)
  • 一个是主方法调用useFlyable方法
    定义接口

public interface Flyable {
    void fly(String s);
}

测试类

public class FlyableDemo {
    public static void main(String[] args){
        //匿名内部类
        useFlyable(new Flyable() {
            @Override
            public void fly(String s) {
                System.out.println(s);
                System.out.println("把CC屁股打烂！");
            }
        });
        //Lambda
        useFlyable((String s)->{
            System.out.println(s);
            System.out.println("把CC活打死！");
        });
    }
    private static void useFlyable(Flyable f){
        f.fly("飞飞飞");
    }
}

练习3

• 定义一个Addable接口，里面定义一个抽象方法：int add(int x,int y)
• 定义一个AddableDemo测试类包含
  • useAddable(Addable a)
  • 主方法调用useAddable

创建接口

public interface Addable {
    int add(int x,int y);
}

测试类

public class AddableDemo {
    public static void main(String[] args) {
        useAddable((int x,int y)->{
            return x+y;
        });
    }
    private static void useAddable(Addable a){
        int res=a.add(10,20);
        System.out.println(res);
    }
}

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;
        });
        //如果参数有且仅有一个，小括号可以省略
        useFlyable(s->{
            System.out.println(s);
            System.out.println("把CC活打死！");
        });
        //如果代码块只有一行，可以省略大括号和分号（有return也需要省略）
        useFlyable(s-> System.out.println(s));
    }
    public static void useFlyable(Flyable f){
        f.fly("飞飞飞");
    }
    private static void useAddable(Addable a){
        int res=a.add(10,20);
        System.out.println(res);
    }
}

Lambda表达式的注意事项

• 必须要有接口，并且接口中有且只有一个抽象接口
• 必须有上下文环境，才能推导出Lambda接口
  • 根据局部变量的赋值得知lambda对应的接口：Runnable r=()->System.out.println(“Lambda表达式”);
  • 根据调用方法的参数得知lambda对应的接口：new Thread(()->System.out.println(“Lambda表达式”)).start();

Lambda表达式与接口的区别

所需类型不同

• 匿名内部类：可以是接口也可以是抽象类，还可以是具体类
• Lambda表达式：只能是接口
  使用限制不同
• 如果接口中有且只有一个抽象方法，可以使用Lambda表达式，也可以使用匿名内部类
• 如果接口中多于一个抽象方法，只能用匿名内部类，不能用Lambda表达式
  实现原理不同
• 匿名内部类编译后，产生一个单独的.class字节码文件
• Lambda编译之后没有单独的.class字节码文件。对用的字节码会在运行的时候动态生成