Java中的Lambda表达式

lambda表达式的目的：
让你的代码看起来很简洁，更多的关注核心代码。
关键：函数式接口，即只含有一个方法的接口。

1.不带参数的情况

// 定义一个函数式接口(即只包含唯一一个抽象方法的接口)
interface ILike{
    public void testLam();
}

// 1.通过普通类实现
class Like implements ILike{
    @Override
    public void testLam() {
        System.out.println("1.普通类实现函数式接口");
    }
}


public class TestLambda1 {

    // 2.静态内部类实现函数式接口
    static class Like2 implements ILike{
        @Override
        public void testLam() {
            System.out.println("2.静态内部类实现函数式接口");
        }
    }


    public static void main(String[] args) {

        ILike like = new Like();
        like.testLam();

        like = new Like2();
        like.testLam();


        // 3.局部内部类实现函数式接口
        class Like3 implements ILike{
            @Override
            public void testLam() {
                System.out.println("3.局部内部类实现函数式接口");
            }
        }

        like = new Like3();
        like.testLam();

        // 4.匿名内部类实现函数式接口  匿名内部类：即类没有名称，不是没有对象(变量)
        like = new ILike() {
            @Override
            public void testLam() {
                System.out.println("4.匿名内部类实现函数式接口");
            }
        };

        like.testLam();

        // 5.用lambda表达式简化
        like = ()->{
            System.out.println("5.用lambda表达式实现函数式接口");
        };
        like.testLam();

    }

}

运行结果：

2.带参数的情况

package com.ztm.c04Lambda;

public class TestLambda2 {

    // 2.静态内部类实现函数式接口
    static class Love2 implements ILove{
        @Override
        public void sayLove(int i) {
            System.out.println("i love "+ i);
        }
    }


    public static void main(String[] args) {

        ILove love = new Love();
        love.sayLove(1);

        love = new Love2();
        love.sayLove(2);

        // 局部内部类
        class Love3 implements ILove{

            @Override
            public void sayLove(int i) {
                System.out.println("i love " + i);
            }
        }

        love =new  Love3();
        love.sayLove(3);

        // 匿名内部类
        love = new ILove() {
            @Override
            public void sayLove(int i) {
                System.out.println("i love " + i);
            }
        };

        love.sayLove(4);


        // lambda表达式
        love = (int i)->{System.out.println("i love " + i);};
        love.sayLove(5);

        // 简化1：去掉参数类型
        love = (i)->{System.out.println("i love " + i);};
        love.sayLove(6);

        // 简化2：去掉参数的括号
        love = a->{System.out.println("i love " + a);};
        love.sayLove(7);

        // 简化3：去掉方法的大括号
        love = a-> System.out.println("i love " + a);
        love.sayLove(8);

        /**
         * 总结：
         * lambda表达式只能在一行代码的情况下，可以简化成一行。
         * 如果有多行，那么就用代码块包裹
         * 前提是接口为函数式接口
         * 多个参数，也可以去掉参数类型，但是要么都去掉，要么都不去掉，而且，多个参数必须加括号
         */
    }

}


// 定义一个函数式接口(即只包含唯一一个抽象方法的接口)
interface ILove{
     void sayLove(int i);
}

// 1.通过普通类实现
class Love implements ILove{

    @Override
    public void sayLove(int i) {
        System.out.println("i love "+ i);
    }
}