Java基础00-Lamda表达式30

1. Lambda表达式

Java8新特征之Lambda表达式

1.1 函数式编程思想概述

 　　

1.2 体验Lambda表达式

　　
代码示例：

方式一就不演示了，可以去看Java基础24

方式2：
匿名内部类的方式改进

public class LambdaDemo {
    public static void main(String[] args) {
        // 匿名内部类的方式改进
        new Thread(new Runnable() {

            @Override
            public void run() {
                System.out.println("多线程启动了！");
            }
        }).start();
    }
}

运行结果：

　　

方式3：
Lambda表达式的方式改进

public class LambdaDemo {
    public static void main(String[] args) {
        // Lambda表达式的方式改进
        new Thread(() -> {
            System.out.println("多线程启动了！");
        }).start();
    }
}

运行结果：

　　
1.3 Lambda表达式的标准格式

　　

两个方式做的是相同的事情，只不过Lambda表达式更加的简洁只做了我们要做的事情。

　　

使用该方式更加关注的是要做的事情。

1.4 Lambda表达式的练习

　　

1.4.1 练习1（ 抽象方法无参）

　　
代码示例：

这里采用的是Lambda表达式接口的方式，还可以使用常规的方式实现接口中的方法，也可以使用匿名内部类，但是这是三种方式Lambda表达式是最简洁的。

定义接口：

//1:定义一个接口(Eatable)，里面定义一个抽象方法: void eat();
public interface Eatable {
    void eat();
}

创建实现类：

//2:定义一一个测试类(EatableDemo),在测试类中提供两个方法
public class EatableDemo {
    // 一个方法是主方法，在主方法中调用useEatable方法
    public static void main(String[] args) {
        // 调用useEatable方法
        // 使用Lambda表达式
        useEatable(() -> {
            System.out.println("一天一苹果，医生远离我");
        });
    }

    // 一个方法是: useEatable(Eatable e)
    public static void useEatable(Eatable e) {
        e.eat();
    }
}

运行结果：

　　
1.4.2 练习2（抽象方法有参）

 　　

代码示例：

定义接口：

//1:定义一个接口(Flyable)，里面定义一个抽象方法: void fly(String s);
public interface Flyable {
    void fly(String s);
}

创建实现类：
使用了匿名内部类和Lambda方式，两个方法。

//2:定义一个测试类(FLyableDemo)，在测试类中提供两个方法
//一个方法是: useFlyable(Flyable f)
//一个方法是主方法，在主方法中调用useFlyable方法
public class FlyableDemo {
    public static void useFlyable(Flyable f) {
        f.fly("风和日丽，晴空万里");
    }

    private static void main(String[] args) {
        // 匿名内部类
        useFlyable(new Flyable() {

            @Override
            public void fly(String s) {    //这里的s是useFlyable方法定义的
                System.out.println(s);
                System.out.println("飞机自驾游");
            }
        });
        System.out.println("-------------------");
        // Lambda表达式
        useFlyable((String s) -> {
            System.out.println(s);
            System.out.println("飞机自驾游");
        });
    }
}

1.4.3 练习3（抽象方法有参有返回值）

　　
代码示例：

定义接口：

//1:定义一个接口(Addable)，里面定义一个抽象方法: int add(int x, int y);
public interface Addable {
    int add(int x, int y);
}

创建测试类：

//2:定义一个测试类(AddableDemo)，在测试类中提供两个方法
//    一个方法是: useAddable(Addable a)
//    一个方法是主方法，在主方法中调用useAddable方法
public class AddableDemo {

    public static void main(String[] args) {
        useAddable((int x, int y) -> {
            return x + y;
        });
    }

    private static void useAddable(Addable a) {
        int add = a.add(10, 20);
        System.out.println(add);
    }
}

运行结果：

　　
1.5 Lambda表达式的省略模式

　　

代码示例：

Addable接口，int类型有参有返回值

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

Flyable接口，String类型有参无返回值

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

测试类：

public class LambdaDemo {
    public static void main(String[] args) {
        // 在这里只使用Lambda方式

        // useAddable(Addable a)方法
        // 常规方式
        useAddable((int x, int y) -> {
            return x + y;
        });
        // 参数的类型可以省略，但是有多个参数的情况下不能就省略一个
        useAddable((x, y) -> {
            return x + y;
        });
        System.out.println("----------------------");
        // useFlyable(Flyable f)方法
        // 常规方法
        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 i = a.add(10, 20);
        System.out.println(i);
    }
}

运行结果：
方法都可以正常运行

　　
1.6 Lambda表达式的注意事项

　　 　　

public class LambdaDemo01 {
    public static void main(String[] args) {

        // 这样写是会报错的，因为没有上下文环境
//        () -> System.out.println("Lambda表达式");

        // 必须有上下文环境，才能推导出Lambda对应的接口
        // 根据局部变量的赋值得知L ambda对应的接口:
        Runnable r = () -> System.out.println("Lambda表达式");
        // 根据调用方法的参数得知L ambda对应的接口:
        new Thread(() -> System.out.println("Lambda表达式")).start();
    }
}

1.7 Lambda表达式和匿名内部类的区别

Lambda表达式：只能是接口