Lambda表达式（多线程实现）

推导lambda表达式

• Lambda表达式，避免匿名内部类定义过多，其实质属于函数式编程的概念；
  去掉一些没有意义的代码，只留下核心代码；
  当前接口为函数式接口（任何一个接口，如果只包含唯一一个抽象方法，那么他就是一个函数式接口）,可以通过Lambda表达式来创建该接口的对象；
• 1、实习类：接口+实现类+主线程调用抽象方法
• 2、静态内部类(注意：加static) ：接口+静态内部类实现接口+主线程调用抽象方法
• 3、局部内部类：接口+主线程内实现接口+内部调用抽象方法
• 4、匿名内部类，没有类的名称，必须借助接口或父类：接口+主线程内实现接口（没有创建实现类，而是直接新建一个对象实现接口）+内部调用抽象方法
• 5、Lambda表达式：接口+主线程内实现接口(当前为函数式接口，只有一个抽象方法，直接新建接口对象实现抽象方法)+内部调用抽象方法

package com.zeng.demo01;
/*
推导lambda表达式
*/
public class TextLambda01 {
    //3、静态内部类(注意：加static)【简化一版】
    static class Like2 implements ILike{
        @Override
        public void lambda() {
            System.out.println("i like Lambda2");
        }
    }
    public static void main(String[] args) {
        ILike iLike = new Like();//实例化对象
        iLike.lambda();
        iLike = new Like2();
        iLike.lambda();
        //4、局部内部类【简化二版】
        class Like3 implements ILike{

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

        //5、匿名内部类，没有类的名称，必须借助接口或父类【简化三版】
        iLike=new ILike() {
            @Override
            public void lambda() {
                System.out.println("i like Lambda4");
            }
        };
        iLike.lambda();

        //6、用Lambda简化【简化四版】（对于函数式接口可以用Lambda表达式来创建该接口的对象）
        iLike=()->{
            System.out.println("i like Lambda5");
        };
        iLike.lambda();
    }
}
//1、定义一个函数式接口（只包含唯一一个抽象方法）
interface  ILike{
    void lambda();
}
//2、实现类
class Like implements ILike{


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

练习Lambda表达式

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

package com.zeng.demo01;

public class TestLambda02 {
    //2、静态内部类
//      static class Love implements ILove{
//        @Override
//        public void love(int a) {
//            System.out.println("i love you-->"+a);
//        }
//    }
    public static void main(String[] args) {
        //3、局部内部类（将类放到方法体里面）
//        class Love implements ILove{
//            @Override
//            public void love(int a) {
//                System.out.println("i love you-->"+a);
//            }
//        }
        //前三种需用到此方法
       // ILove love = new Love();


        //4、匿名内部类（没有方法，用接口实现）
//        ILove love=new ILove() {
//            @Override
//            public void love(int a) {
//                System.out.println("I love you--》"+a);
//            }
//        };

        //5、Lambda表达式(方法里有参数)
//       ILove love=(int a)->{
//            System.out.println("I love you-->"+a);
//        };
       //5.1 Lambda表达式(去掉参数返回类型)
//              ILove love=(a)->{
//                   System.out.println("I love you-->"+a);
//                };
        //5.2 Lambda表达式(简化括号)
//        ILove love=a->{
//            System.out.println("I love you-->"+a);
//        };
        //5.3 Lambda表达式（去掉花括号)
        ILove love=a->System.out.println("I love you-->"+a);
        love.love(520);
        //总结
        // lambda表达式当在只有一行代码的情况下才能简化成一行代码，如果有多行代码，那么就用代码块包裹
        //前提是接口为函数式接口
        //多个参数也可以去掉参数类型，要去掉都去掉必须加括号，
    }
}
interface ILove{

    void love(int a);
}
//1、实现类
//class Love implements ILove{
//
//    @Override
//    public void love(int a) {
//        System.out.println("i love you-->"+a);
//    }
//}