Lambda表达式

1，Lambda表达式

1.1 使用目的

1，避免匿名内部类定义过多
2，代码看起来可以更加简洁
3，去掉一堆无意义的代码，只留下核心逻辑

1.2 函数式接口

1，定义：任何接口，只包含唯一一个抽象方法，则为函数式接口
例如Runnable接口
2，对于函数式接口，我们可以通过Lambda表达式来创建接口对象

public interface Runnable {
    public abstract void run();
}

1.3 发展逻辑

1，定义一个函数式接口：只有一个方法的接口
2，从实现类开始简化
3，静态内部类
4，局部内部类
5，匿名内部类，没有类的名称，必须借助接口或者父类
6，最后到用lambda简化 将 new ILike() 简化为 ()->

package com.huanglk.lambda;

//1，定义一个函数式接口：只有一个方法的接口
interface ILike{
    void test();
}
//2，实现类
class Like implements ILike{
    @Override
    public void test() {
        System.out.println("i like lambda11111");
    }
}

/*
推导lambda表达式
 */
public class TestLambda1 {
    //3,静态内部类
    static class Like2 implements ILike{
        @Override
        public void test() {
            System.out.println("i like lambda2222");
        }
    }
    public static void main(String[] args) {
        // 4，局部内部类
        class Like3 implements ILike{
            @Override
            public void test() {
                System.out.println("i like lambda33333");
            }
        }
        ILike var = new Like();
        var.test();
        ILike var2 = new Like2();
        var2.test();
        ILike var3 = new Like3();
        var3.test();
        //5,匿名内部类，没有类的名称，必须借助接口或者父类
        ILike var4 = new ILike() {
            @Override
            public void test(){
                System.out.println("i like lambda444444");
            };
        };
        var4.test();
        //6,用lambda简化    将 new ILike() 简化为 ()->
        ILike var5 = () ->{
            System.out.println("i like lambda55555");
        };
        var5.test();
    }


}

1.4 继续简化

1，简化1，参数类型
2，简化2，参数括号
3，简化3，花括号（单行一个";"可以简化多行则不可以简化花括号）

package com.huanglk.lambda;

interface ILove{
    String love(int a);
}
class Love implements ILove{
    @Override
    public String love(int a) {
        System.out.println("内部类");
        return String.valueOf(a);
    }
}
public class TestLambda2 {

    static class Love1 implements ILove{
        @Override
        public String love(int a) {
            System.out.println("静态内部类");
            return String.valueOf(a);
        }
    }

    public static void main(String[] args) {
        ILove love1 = new Love1();
        love1.love(100);

        class Love2 implements ILove{
            @Override
            public String love(int a) {
                System.out.println("匿名内部类");
                return String.valueOf(a);
            }
        }
        ILove love2 = new Love2();
        love2.love(200);

        ILove love3 = (int a)->{
            System.out.println("lambda");
            return String.valueOf(a);
        };
        //简化1，参数类型
        ILove love4 = (a)->{
            System.out.println("lambda");
            return String.valueOf(a);
        };
        //简化2，参数括号
        ILove love5 = a->{
            System.out.println("lambda");
            return String.valueOf(a);
        };
        //简化3，花括号
         love1 = a-> String.valueOf(a);
        System.out.println(love3.love(3));
    }
}

1.5

1，lambda表达式只能在一行代码的情况下才能简化成一行省略花括号，有多行则用代码块包裹
2，前提是接口为函数式接口 （只有唯一一个方法的接口）
3，多个参数也可以省略参数类型，要去就全部去掉 ，参数必须加上括号