多线程---Lamba表达式

Lambda表达式

参考视频：多线程10：Lamda表达式哔哩哔哩bilibili

 

 

理解函数式接口是学习java8 lambda表达式的关键所在

函数式接口的定义：

• 任何接口，如果只包含唯一一个抽象方法，那么它就是一个函数式接口；

• 对于任何函数式接口，我们可以通过lambda表达式来创建该接口的对象；

package com.mokuiran.thread;
​
public class LambdaDemo {
​
    //3.静态内部类
    static class Like2 implements ILike{
​
        @Override
        public void lambda() {
            System.out.println("l 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("l 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("l like lambda");
    }
}
​

案例二

package com.mokuiran.thread;
​
public class LambdaDemo2 {
​
    //静态内部类
    static class Love2 implements ILove{
        @Override
        public void love(int a) {
            System.out.println("I love you2——>"+a);
        }
    }
​
    public static void main(String[] args) {
​
        //局部内部类
        class Love3 implements ILove{
​
            @Override
            public void love(int a) {
                System.out.println("I love you3——>"+a);
            }
        }
​
        //匿名内部类（通过接口实现）
        ILove love4 = new ILove(){
​
            @Override
            public void love(int a) {
                System.out.println("I love you4——>"+a);
            }
        };
​
​
        ILove love = new Love1();
        love.love(1);//实现类
        love = new Love2();
        love.love(2);//静态内部类
        love = new Love3();
        love.love(3);//局部内部类
        love4.love(4);//匿名内部类
​
        //通过lambda
        love =(int a)->{
            System.out.println("I love you5——>"+a);
        };
        love.love(5);//lambda表达式
    }
}
​
interface ILove{
    void love(int a);
}
​
//实现类
class Love1 implements ILove{
    @Override
    public void love(int a) {
        System.out.println("I love you1--->"+a);
    }
}

案例三

package com.mokuiran.thread;
​
public class LambdaDemo2 {
​
    public static void main(String[] args) {
​
        ILove love = new Love1();
​
        //通过lambda表达式
        love =(int a)->{
            System.out.println("I love you5——>"+a);
        };
        love.love(5);//lambda表达式
​
        //使用lambda进行再简化
        //简化1.参数类型
        love = (a) ->{
            System.out.println("I love you6——>"+a);
        };
        love.love(6);
​
        //简化2.简化括号
        love = a ->{
            System.out.println("I love you7——>"+a);
        };
        love.love(7);
​
        //假话3.简化化括号
        love = (a) ->System.out.println("I love you8——>"+a);
        love.love(8);
    }
​
    //总结：
    /*
    1.lambda表达式只能有一行diamante的情况下才能简化成一行，如果有多，那么就用代码块包裹。
    2.前提条件：接口必须是函数式接口
    3.多个参数也可以去掉参数类型，要去掉就那都去掉，必须加上括号
     */
}
​
interface ILove{
    void love(int a);
}