java笔记37，Lambda表达式

针对于：有且仅有一个抽象方法的接口
例如说我们的Runnable接口

public class test4 {
    public static void main(String[] args) {
        //***************
        // 匿名内部类
        //***************
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("this is class");
            }
        }).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

需要一个接口，需要一个方法
在方法使用到“接口”类型的参数的时候
可直接在（）中重写方法
useFunction（interface f1）

public class test4 {
    public static void main(String[] args) {
        useFunction(new f1() {
            @Override
            public void function() {
                System.out.println("这就是lambda表达式，感觉好复杂，不好用");
            }
        });
        useFunction(()->{
            System.out.println("简化");
        });
    }
    public static void useFunction(f1 f1)
    {
        f1.function();
    }
}
interface f1
{
     void function();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

如果参数只有一个，可以省略小括号
如果代码块语句只有一条，可以省略大括号和分号。如果是return语句，return也得省略

也可以使用抽象类或者具体类来实现”匿名内部类“
也就是说use方法中，可以是接口，抽象类，具体类
.
.

而lambda必须是接口

public class test4 {
    public static void main(String[] args) {
        use(new c1() {
            @Override
            void function() {
                System.out.println("抽象类也可实现相同效果");
            }
        });
    }
    public static void use(c1 c1)
    {
        c1.function();
    }

}
abstract class  c1
{
    abstract void function();
}


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

总结：lambda表达式必须要接口，且唯一抽象方法
而匿名内部类没有这么多要求
匿名内部类会自动生成一个类
而lambda是在运行时候动态生成，如果lamdbda表达式过多会导致代码体系庞大，不利于后续的维护的修改

接口默认方法

public class test4 {
    public static void main(String[] args) {
        f1 f=new f1() {
            @Override
            public void function() {
                System.out.println("这里将其重写");
            }
        };
        f.function();
    }
}
 interface f1
{
    public default void function() {
        System.out.println("这是默认方法");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

接口静态方法

同类中的静态方法

public class test4 {
    public static void main(String[] args) {
        f1.function();
    }
}
 interface f1
{
    public static void function() {
        System.out.println("这是静态方法");
    }
}
1
2
3
4
5
6
7
8
9
10
11

接口私有方法

要求8.0以上