Java Lambda 表达式

一、函数式编程

在数学中，函数就是有输入量输出量的一计方案，也就是” 数据做操作"

面响对象思想强调“必须通过对象的形式来做事情”

函数式思想则尽量忽略面向对象的复杂语法:“强调做什么，不以什么形式去做”

而我们要学习的L ambda表达式就函数式魂想的体现

二、体验Lambda

/**
 * @description:
 * @author: Liu Tao
 **/

public class FlyableDemo {
    public static void main(String[] args) {
        //调用useFlyable
        //最传统的方式,需要先写一个类实现flyable接口的fly方法
        FlyableImpl fi = new FlyableImpl();
        useFlyable(fi);
        System.out.println("--------");

        //在主方法中调用useFlyable方法
        //匿名内部类
        useFlyable(new Flyable() {
            @Override
            public void fly(String s) {
                System.out.println(s);
                System.out.println("匿名内部类飞");
            }
        });
        System.out.println("--------");

        //Lambda
        useFlyable((String s) -> {
            System.out.println(s);
            System.out.println("lambda飞");
        });

    }

    private static void useFlyable(Flyable f) {
        f.fly("风和日丽，晴空万里");
    }
}

flyable接口：
public interface Flyable {
    void fly(String s);
}

FlyableImpl实现类：
/**
 * @description:
 * @author: Liu Tao
 **/
public class FlyableImpl implements Flyable{
    @Override
    public void fly(String s) {
        System.out.println(s);
        System.out.println("传统方式飞");
    }
}

输出：

风和日丽，晴空万里
传统方式飞
--------
风和日丽，晴空万里
匿名内部类飞
--------
风和日丽，晴空万里
lambda飞

三、lambda表达式的标准格式

四、Lambda表达式练习

4.1 练习1

Lambda表达式的使用前提 * 有一个接口 * 接口中有且仅有一个抽象方法练习描述 * 无参无返回值抽象方法的练习操作步骤 * 定义一个接口(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("一天一苹果，医生远离我");
    }
}
//测试类
public class EatableDemo {
    public static void main(String[] args) {
        //在主方法中调用useEatable方法
        Eatable e = new EatableImpl();
        useEatable(e);

        //匿名内部类
        useEatable(new Eatable() {
            @Override
            public void eat() {
                System.out.println("一天一苹果，医生远离我");
            }
        });

        //Lambda表达式
        useEatable(() -> {
            System.out.println("一天一苹果，医生远离我");
        });
    }

    private static void useEatable(Eatable e) {
        e.eat();
    }
}

4.2 练习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方法
        //匿名内部类
        useFlyable(new Flyable() {
            @Override
            public void fly(String s) {
                System.out.println(s);
                System.out.println("飞机自驾游");
            }
        });
        System.out.println("--------");

        //Lambda
        useFlyable((String s) -> {
            System.out.println(s);
            System.out.println("飞机自驾游");
        });

    }

    private static void useFlyable(Flyable f) {
        f.fly("风和日丽，晴空万里");
    }
}

4.3 练习3

练习描述 * 有参有返回值抽象方法的练习操作步骤 * 定义一个接口(Addable)，里面定义一个抽象方法：int add(int x,int y); * 定义一个测试类(AddableDemo)，在测试类中提供两个方法 * 一个方法是：useAddable(Addable a) * 一个方法是主方法，在主方法中调用useAddable方法示例代码

ublic 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);
    }
}