Lambda表达式----“进化论”

Lambda表达式

• Lambda表达式，也称闭包

• Lambda允许把函数作为一个方法的参数

• 避免匿名内部类定义过多

  new Thread (()-System.out.println("多线程。。。")).start();
  

  a->System.out.println("i like lambda-->" +a)
  

  • 为什么使用lambda表达式
    • 使用 Lambda 表达式可以使代码变的更加简洁紧凑

函数式接口

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

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

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

/推导lambda表达式
// /
public class TestLambda {
//3.静态内部类
    static class Like2 implements ILike{
        @Override
        public void lambda(){
            System.out.println("like lambda 静态内部类");

        }}

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

        like = new Like2();
        like.lambda();
        //局部内部类
         class Like3 implements ILike{
            @Override
            public void lambda(){
                System.out.println("like lambda 局部内部类 ");

            }}
            like = new Like3();
        like.lambda();

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

        };
        like.lambda();
        //用Lambda表示
        like = ()->{
            System.out.println("Lambda表达式");
        };
        like.lambda();
    }
}
//定义一个函数式接口：包含唯一一个抽象方法
interface ILike {
    void lambda();
}
//实现类
class Like implements ILike{
    @Override
    public void lambda(){
        System.out.println("like lambda");

}
}

//lambda表达式

  like = ()->{
            System.out.println("Lambda表达式");
        };
        like.lambda();

//实现类

//实现类
class Like implements ILike{
    @Override
    public void lambda(){
        System.out.println("like lambda");

}
}

//匿名内部类

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

        };
        like.lambda();

//局部内部类

//局部内部类
         class Like3 implements ILike{
            @Override
            public void lambda(){
                System.out.println("like lambda 局部内部类 ");

            }}
            like = new Like3();
        like.lambda();

//静态内部类

//3.静态内部类
    static class Like2 implements ILike{
        @Override
        public void lambda(){
            System.out.println("like lambda 静态内部类");

        }}

///Lamd

public class Lambda2 {

    public static void main(String[] args) {
        ILove love = null;
      /*  ILove love = (int a)->{
            System.out.println("------------"+a);
        };
        //简化参数类型
        love = (a)->{
            System.out.println("------------"+a);
        };
        //简化括号
        love = a->{
            System.out.println("------------"+a);
        };*/
      //取掉花括号
        love = a-> System.out.println("-------"+a);

        love.love(521);

    }
}
interface ILove{
    void love(int a);
}

–Lambda表达式只能有一行代码的情况下才能简化

–若有多行，就需代码块

–前提式函数式接口

*多个参数也可去掉参数类型，必须去掉括号

• 可选类型声明：

  不需要声明参数类型，编译器可以统一识别参数值。

• 可选的参数圆括号：

  一个参数无需定义圆括号，但多个参数需要定义圆括号。

• 可选的大括号：

  如果主体包含了一个语句，就不需要使用大括号。

• 可选的返回关键字：

如果主体只有一个表达式返回值则编译器会自动返回值，大括号需