Lambda表达式

Lambda表达式的作用：最直观的作用就是使得代码变得简洁。由于lambda表达式可以直接赋值给一个变量，我们就可以直接把Lambda作为参数传给函数，而传统的Java必须有明确的接口实现定义，初始化才行。

适用范围：函数式接口（即接口只有一个抽象方法）

// 函数式接口，即只有一个抽象方法
interface A {
    abstract void aa();
}

下面就从正常写法开始，看下是怎么一步一步简化成lambda表达式的。

• 正常写法

// 定义函数式接口
interface A {
    abstract void aa();
}

// 实现函数式接口
public class lambda implements A {

    @Override
    public void aa() {
        System.out.println("定义接口，实现接口");
    }
}

// 对象调用
class Test1 {
    public static void main(String[] args) {
        A lambda = new lambda();
        lambda.aa();//console：定义接口，实现接口
    }
}

• 内部类写法

// 定义函数式接口
interface A {
    abstract void aa();
}

class Test1 {
    // 内部类
    static class lambda implements A {
        @Override
        public void aa() {
            System.out.println("定义接口，内部类实现接口");
        }
    }

    public static void main(String[] args) {
        A lambda = new lambda();
        lambda.aa();//console:定义接口，内部类实现接口
    }
}

• 局部内部类

// 定义函数式接口
interface A {
    abstract void aa();
}

class Test1 {

    public static void main(String[] args) {
        // 局部内部类
        class lambda implements A {
            @Override
            public void aa() {
                System.out.println("局部内部类实现接口");
            }
        }

        A lambda = new lambda();
        lambda.aa();// console:
    }
}

• 匿名内部类

// 定义函数式接口
interface A {
    abstract void aa();
}

class Test1 {
    public static void main(String[] args) {
        // 匿名内部类
        A lambda = new A() {
            @Override
            public void aa() {
                System.out.println("匿名内部类实现接口");
            }
        };
        lambda.aa();// console:匿名内部类实现接口
    }
}

• Lambda写法

// 定义函数式接口
interface A {
    abstract void aa();
}

class Test1 {
    public static void main(String[] args) {
        // lambda表达式
        A lambda = () -> {
            System.out.println("lambda实现接口");
        };
        lambda.aa();// console:lambda实现接口
    }
}

• Lambda写法，带参数

/* lambda表达式，带参数 */
// 定义函数式接口
interface A {
    abstract void aa(int a, String b);
}

class Test1 {
    public static void main(String[] args) {
        // lambda表达式,带参数
        A lambda = (int a, String  b) -> {
            System.out.println("lambda实现接口，带参数");
        };
        lambda.aa(1, "参数");// console:lambda实现接口，带参数
    }
}


/* lambda表达式，带参数，省略参数类型 */
// 定义函数式接口
interface A {
    abstract void aa(int a, String b);
}

class Test1 {
    public static void main(String[] args) {
        // lambda表达式,带参数
        A lambda = (a, b) -> {
            System.out.println("lambda实现接口，带参数，省略参数类型");
        };
        lambda.aa(1, "参数");// console:lambda实现接口，带参数，省略参数类型
    }
}