Lamda表达式

/*
推导Lambda表达式
 */
public class TestLambda {

    // 3.静态内部类
    static class Like2 implements ILike{
        @Override
        public void Lambda() {
            System.out.println("I Like Lambda2");
        }
    }


    public static void main(String[] args) {
        ILike like = new Like();
        like.Lambda();
        like = new Like2();
        like.Lambda();

        // 4.局部内部类
        class Like3 implements ILike{
            @Override
            public void Lambda() {
                System.out.println("I Like Lambda3");
            }
        }
        like = new Like3();
        like.Lambda();

        // 5.匿名内部类 没有类的名称，必须借助接口或者父类
        like = new ILike() {
            @Override
            public void Lambda() {
                System.out.println("I Like Lambda4");
            }
        };
        like.Lambda();

        // 6.用Lambda简化
        like = () -> {
            System.out.println("I Like Lambda5");
        };
        like.Lambda();
    }
}
// 1.定义一个函数式接口
interface ILike{
    void Lambda();
}

// 2.实现类
class Like implements ILike{
    @Override
    public void Lambda() {
        System.out.println("I Like Lambda");
    }
}

public class TestLambda2 {

    static class Love2 implements ILove{
        @Override
        public void Love(int a) {
            System.out.println("I Love You--->"+a);
        }
    }
    public static void main(String[] args) {
        ILove love = new Love();
        love.Love(2);

        love = new Love2();
        love.Love(3);

        class Love3 implements ILove{
            @Override
            public void Love(int a) {
                System.out.println("I Love You--->"+a);
            }
        }
        love = new Love3();
        love.Love(4);

        love = new ILove() {
            @Override
            public void Love(int a) {
                System.out.println("I Love You--->"+a);
            }
        };
        love.Love(5);

        love = (int a) -> {
                System.out.println("I Love You--->"+a);
        };
        love.Love(7);

        // 简化1
        love = (a) -> {
            System.out.println("I Love You--->"+a);
        };
        love.Love(8);

        // 简化2：去掉括号
        love = a -> {
            System.out.println("I Love You--->"+a);
        };
        love.Love(9);

        // 简化3：去掉花括号
        love = a ->
            System.out.println("I Love You--->"+a);

        love.Love(10);

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

interface ILove{
    void Love(int a);
}

class Love implements ILove{
    @Override
    public void Love(int a) {
        System.out.println("I Love You--->"+a);
    }
}