Java jdk1.8中 lambda 表达式

简化步骤：

1. 定义一个函数式接口
2. 实现类
3. 静态内部类
4. 局部内部类
5. 匿名内部类，没有类的名称，必须借助接口或者父类
6. 用lamda简化

version1.0

package com.huiqing.lambda;



interface ILike {
    void lambda();
}


public class TestLambda {

    //2.静态内部类
    static class Like2 implements ILike {

        @Override
        public void lambda() {
            System.out.println("i like lambda2.");
        }
    }


    public static void main(String[] args) {
    	ILike like;//定义的接口类型的变量
        like = new Like1();
        like.lambda();

        like = new Like2();
        like.lambda();
        //3.局部内部类
        class Like3 implements ILike {

            @Override
            public void lambda() {
                System.out.println("i like lambda3.");
            }
        }
        Like3 like3 = new Like3();
        like3.lambda();

        //4.匿名内部类,没有类的名称，必须借助接口或者父类
        like = new ILike() { //匿名没有名字这里是通过接口去实现
            @Override
            public void lambda() {
                System.out.println("i like lambda4.");
            }
        };

        like.lambda();

        //5.用lambda简化,jdk1.8中才能使用
        //简化了，定义一个类，定义方法，只需要组关注以前被继承方法里面  需要做哪些东西
        like = () -> {
            System.out.println("i like lambda5");
        };
        like.lambda();

    }


}

//1.实现类
class Like1 implements ILike {

    @Override
    public void lambda() {
        System.out.println("i like lambda1.");
    }
}

结果：

i like lambda1.
i like lambda2.
i like lambda3.
i like lambda4.
i like lambda5

version 2.0

package com.huiqing.lambda;

public class Testlambda02 {
    public static void main(String[] args) {
        Love love;
        //使用lambda
        love = (int a)-> {
            System.out.println("love " + a);
        };
        love.speakLove(520);

        //简化一 ：去掉参数类型
        love = (a)->{
            System.out.println("love " + a);
        };
        love.speakLove(521);

        //简化二：去掉括号
        love = a->{
            System.out.println("love " + a);
        };
        love.speakLove(522);

        //简化三：去掉花括号   ，，，，这种也就是函数只有一条执行语句才可以，实际中应该用的很少
        love = a-> System.out.println("love " + a);
        love.speakLove(523);
    }

//    总结：
//    lambda表达式只能有一行代码的情况才能简化成一行去花括号，如果有多行，那么就用代码块包裹起来。
//    前提是接口为函数式接口，就是这个接口只能有一个方法 线程中Runnable 这个接口就是函数式接口。
//    多个参数也可以去掉参数类型，要去掉都去掉，必须加上括号，请看 version3.0


}


interface Love{
    void speakLove(int a);
}

结果：
love 520
love 521
love 522
love 523

version 3.0

 //多个参数也可以去掉参数类型，要去掉都去掉，必须加上括号，请看  

package com.huiqing.lambda;

public class Testlambda02 {
    public static void main(String[] args) {
        Love love;
        love = (a,b)->{   // 圆括号要有 ，类型可以省
            System.out.println("love " + a +" " + b);
        };
        love.speakLove(520,521);
    }
}


interface Love{
    void speakLove(int a, int b);  //两个参数
}

结果;
love 520 521

下图中选中部分，它的意义其实是对接口中方法的一个实现，同时也是一个实例对象

看看这个lambda在线程中的应用