【java】Lambda表达式

体验Lambda表达式

package heima.Lambda;

import heima.多线程.other.MyRunnable;

public class FirstFeel {
    public static void main(String[] args) {
        //实现类的方式实现需求
//        MyRunnable my = new MyRunnable();
//        Thread t = new Thread(my);
//        t.start();

        //匿名内部类的方式改进
//        new Thread(new Runnable() {
//            @Override
//            public void run() {
//                System.out.println("多线程程序启动了");
//            }
//        }).start();

        //Lambda表达式的方式改进
        new Thread(()->{
            System.out.println("多线程程序启动了");
        }).start();
    }
}

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

Lambda表达式的标准格式

Lambda表达式的练习

抽象方法无参无返回值

package heima.Lambda.表达式的练习;

public interface Eatable {
    void eat();
}

1
2
3
4
5
6

package heima.Lambda.表达式的练习;

public class EatableImpl implements Eatable{
    @Override
    public void eat() {
        System.out.println("一天一苹果，医生远离我");
    }
}

1
2
3
4
5
6
7
8
9

package heima.Lambda.表达式的练习;

public class EatableDemo {
    public static void main(String[] args) {
        //在主方法中调用useEatable方法 1
        Eatable e = new EatableImpl();
        useEatable(e);

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

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

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

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

输出：

抽象方法带参无返回值

package heima.Lambda.表达式的练习.练习2;

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("风和日丽，晴空万里");
    }
}

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

package heima.Lambda.表达式的练习.练习2;

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

1
2
3
4
5
6

抽象方法带参带返回值

package heima.Lambda.表达式的练习.练习3;

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

1
2
3
4
5
6

package heima.Lambda.表达式的练习.练习3;

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
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

Lambda表达式的省略模式

package heima.Lambda.表达式的省略;

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

1
2
3
4
5
6

package heima.Lambda.表达式的省略;

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

1
2
3
4
5
6

package heima.Lambda.表达式的省略;

public class LambdaDemo {
    public static void main(String[] args) {
        //普通表达式
        useAddable((int x,int y)->{
            return x+y;
        });
        //参数的类型可以省略
        useAddable((x,y)->{
            return x+y;
        });
        //但是有多个参数的情况下，不能只省略一个 err
//        useAddable((x,int y)->{
//            return x+y;
//        });

        useFlyable((String s)->{
            System.out.println(s);
        });
    }
    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
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

Lambda表达式的注意事项

package heima.Lambda.表达式的注意事项;

public interface Inter {
    void show();
}

1
2
3
4
5
6

package heima.Lambda.表达式的注意事项;

public class LambdaDemo {
    public static void main(String[] args) {
        useInter(()->{
            System.out.println("好好学习,天天向上");
        });

        //使用Lambda必须要有接口，并且要求接口中有且仅有一个抽象方法
//        useInter(()-> System.out.println("好好学习天天向上"));

        //必须有上下文环境，才能推导出Lambda对应的接口
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("匿名内部类");
            }
        }).start();

//        Runnable r = ()-> System.out.println("Lambda表达式");
//        new Thread(r).start();
        new Thread(()-> System.out.println("Lambda表达式")).start();
    }
    public static void useInter(Inter i){
        i.show();
    }
}

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

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

• 首先准备好三个不同的类

package heima.Lambda.Lambda表达式和匿名内部类区别;

public interface Inter {
    void show();
}

1
2
3
4
5
6

package heima.Lambda.Lambda表达式和匿名内部类区别;

public class Student {
    public void study(){
        System.out.println("爱生活，爱java");
    }
}

1
2
3
4
5
6
7
8

package heima.Lambda.Lambda表达式和匿名内部类区别;

public abstract class Animal {
    public abstract void method();
}

1
2
3
4
5
6

• 初始版

package heima.Lambda.Lambda表达式和匿名内部类区别;

public class LambdaDemo {
    public static void main(String[] args) {
        //匿名内部类
        useInter(new Inter() {
            @Override
            public void show() {
                System.out.println("接口");
            }
        });

        useAnimal(new Animal() {
            @Override
            public void method() {
                System.out.println("抽象类");
            }
        });

        useStudent(new Student(){
            @Override
            public void study() {
                System.out.println("具体类");
            }
        });

        System.out.println("=====================");

        //Lambda
        useInter(()-> System.out.println("接口"));

    }
    private static void useStudent(Student s){
        s.study();
    }

    private static void useAnimal(Animal a){
        a.method();
    }

    private static void useInter(Inter i){
        i.show();
    }
}

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
37
38
39
40
41
42
43
44
45

• 当接口内部有两个方法时

只有匿名内部类可以使用其中的方法

• 注：两者的构造方法不同

匿名内部类创建时，会另开一个classs文件