1. lambda表达式

函数式思想则尽量忽略面向对象的复杂语法：“强调做什么，而不是以什么形式去做”
lambda表达式是对一种特殊情况下的匿名内部类的简写形式

1.1. 语法

(形参) 箭头 {代码块}

(形参) -> {方法体}

形参：如果有多个参数，参数之间用逗号隔开；如果没有参数，留空即可
方法体：是我们具体要做的事情

1.1.1. 前提

1必须是一个接口不能是类也不能是抽象类
2接口中只有一个抽象方法

1.1.2. 体验

public class Demo01 {
    public static void main(String[] args) {
        start(new Animal() {
            @Override
            public void eat() {
                System.out.println("222");
            }
        });

        // lambda  ()->{}
        start(() -> {
            System.out.println("222");
        });
    }

    public static void start(Animal a) {
        a.eat();
    }
}

interface Animal {
    public void eat();
}

1.2. 有参无返回值练习

1.2.1. 案例

首先存在一个接口（StringHandler）
在该接口中存在一个抽象方法（printMessage），该方法是有参数无返回值
在测试类中存在一个方法（useStringHandler）
方法的的参数是StringHandler类型的
在方法内部调用了StringHandler的printMessage方法

代码

public class StringHandlerDemo {
    public static void main(String[] args) {
        //匿名内部类的形式
        useStringHandler(new StringHandler() {
            @Override
            public void printMessage(String msg) {
                System.out.println(msg);
            }
        });

        //lambda表达式的形式
        useStringHandler((String msg) -> {
            System.out.println(msg);
        });
    }

    public static void useStringHandler(StringHandler stringHandler) {
        stringHandler.printMessage("itheima");
    }
}

//必须是一个接口    不能是类 也不能是抽象类
//接口中只有一个抽象方法
interface StringHandler {
    void printMessage(String msg);
}

省略注意点

1 参数可以省略类型 ,但必须全部参数一起省略
2 当参数只有一个的时候,小括号可以省略
3 当方法体只有一句的时候, 大括号和方法体的分号省略

1.3. 无参有返回值

1.3.1. 需求

首先存在一个接口（NumHandler）
在该接口中存在一个抽象方法（getNumber），该方法是无参数但是有返回值
在测试类中存在一个方法（useRandomNumHandler）
方法的的参数是RandomNumHandler类型的
在方法内部调用了RandomNumHandler的getNumber方法返回一个随机数

代码

package com.heima.test17;

import java.util.Random;

public class Demo01 {
    public static void main(String[] args) {
        useNumHandler(new NumHandler() {
            @Override
            public int getNumber() {
                Random random = new Random();
                //返回一个0-9之间的随机数
                return random.nextInt(10);
            }
        });

        useNumHandler(() -> {
            Random random = new Random();
            //返回一个0-9之间的随机数
            return random.nextInt(10);
        });
        //当方法体 只有一句 并且是返回值的时候 return也可以省略
        useNumHandler(() ->
            //返回一个0-9之间的随机数
            new Random().nextInt(10)
        );
    }

    //使用数字处理器的方法useNumHandler
    //传入接口NumHandler的实现类的对象
    public static void useNumHandler(NumHandler handler) {
        int num = handler.getNumber();
        System.out.println("获取到返回的数据num=" + num);
    }
}
v

//数字处理器
interface NumHandler {
    //方法 有返回值 无参数
    int getNumber();
}

1.4. 有参数有返回值

只有一句代码并且是返回值时可以省略 return 省略分号省略大括号

package com.heima.test18;

public class Demo01 {
    public static void main(String[] args) {
        useMath(new IMath() {
            @Override
            public int sum(int a, int b, int c) {
                return a + b + c;
            }
        });

        useMath((int a, int b, int c) -> {
            return a * b * c;
        });

        useMath((a, b, c) -> a * b * c);

    }

    //使用数学接口的方法
    //传入IMath接口的实现类的对象
    public static void useMath(IMath iMath) {
        int number = iMath.sum(10, 20, 30);
        System.out.println(number);
    }
}

//数学接口
interface IMath {
    //有参数 有返回值
    int sum(int a, int b, int c);
}