Lambda表达式

重点：
避免匿名内部类定义过多
其实质属于函数式编程的概念
(params)->expresion[表达式]
(params)->statement[语句]
(params)->

例：
a->System.out.println("i like lambda-->"+a);
new Thread(()->System.out.println("多线程学习。。。")).start();

函数式接口的定义：

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

public interface Runnable{
     public abstract void run();
}

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

Lambda演变过程：

package com.xiaoxianshuo.lambda;
/**
 * 无传参
 */

//推导lambda表达式
public class TestLambda1 {
    //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");
    }
}

package com.xiaoxianshuo.lambda;

/**
 * 有参数
 */
public class TestLambda2 {
      //3.将外部实现类放到内部
//    static class Love implements ILove{
//        @Override
//        public void love(int a) {
//            System.out.println("i love you--->"+a);
//        }
//    }
    public static void main(String[] args) {
        ILove ilove = null;
                //4.将内部类放在局部内部类
//        class Love implements ILove{
//            @Override
//            public void love(int a) {
//                System.out.println("i love you--->"+a);
//            }
//        }

        //5.将局部内部类改为匿名内部类
//        ILove ilove = new ILove() {
//            @Override
//            public void love(int a) {
//                System.out.println("i love you--->"+a);
//            }
//        };
        //6.将匿名内部类改为Lambda表达式
//        ilove = (int a) ->{
//             System.out.println("i love you--->"+a);
//        };
        //简化1.简化参数类型
//        ilove = (a)->{
//            System.out.println("i love you--->"+a);
//        };
        //简化2.简化括号
//        ilove = a -> {
//            System.out.println("i love you--->"+a);
//        };
        //简化3.去掉花括号
        ilove = a-> System.out.println("i love you--->"+a);
        ilove.love(520);
    }
}
//1.定义接口
interface ILove{
    void love(int a);
}
  //2.接口实现类
//class Love implements ILove{
//    @Override
//    public void love(int a) {
//        System.out.println("i love you--->"+a);
//    }
//}

//多个参数加括号
public class TestLambda2 {
    public static void main(String[] args) {
        ILove ilove = null;
        ilove = (a,b)-> System.out.println("i love you--->"+a+" "+b);
        ilove.love(520,1314);
    }
}
//1.定义接口
interface ILove{
    void love(int a,int b);
}

总结

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