lambda表达式的简化历程

百度百科：Lambda 表达式（lambda expression）是一个匿名函数，Lambda表达式基于数学中的λ演算得名，直接对应于其中的lambda抽象（lambda abstraction），是一个匿名函数，即没有函数名的函数。Lambda表达式可以表示闭包（注意和数学传统意义上的不同）。

函数式 -->静态内部类 -->局部内部类 -->匿名内部类 -->lambda;

特征：

• 可选类型声明：不需要声明参数类型，编译器可以统一识别参数值。
• 可选的参数圆括号：一个参数无需定义圆括号，但多个参数需要定义圆括号。
• 可选的大括号：如果主体包含了一个语句，就不需要使用大括号。
• 可选的返回关键字：如果主体只有一个表达式返回值则编译器会自动返回值，大括号需要指定表达式返回了一个数值。

• Lambda 表达式主要用来定义行内执行的方法类型接口，例如，一个简单方法接口。
• Lambda 表达式免去了使用匿名方法的麻烦，并且给予Java简单但是强大的函数化的编程能力。

无参：

package com.jian.lamda;
//new Thread (()->System.out.println("")).start();
public class Demo {
    //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(); // i like lambda  实现类

        like=new Like2();
        like.lambda(); // i like lambda2  静态内部类

        //4.局部内部类
        class Like3 implements Ilike{
            @Override
            public void lambda() {
                System.out.println(" i like lambda3"); // i like lambda3  局部内部类
            }
        }
        like=new Like3();
        like.lambda();

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

        //6.lambda简化
        like=()-> {
            System.out.println(" i like lambda5"); // i like lambda5  lambda
        };
        like.lambda();
    }
}

//1.定义一个函数式接口
interface  Ilike{
    void lambda();
}

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

一个参数：

package com.jian.lamda;

public class Demo2 {
    //静态内部类
    static class love2 implements Ilove{

        @Override
        public void love(String name) {
            System.out.println(" i love you2 "+name);
        }
    }

    public static void main(String[] args) {
        Ilove love = new love();
        love.love("song");  //i love you1 song  实现类

        love=new love2();
        love.love("songsong");//i love you2 songsong  静态内部类

        //局部内部类
        class love3 implements Ilove{
            @Override
            public void love(String name) {
                System.out.println(" i love you3 "+name);
            }
        }

        love=new love3();
        love.love("songsongsong");// i love you3 songsongsong  局部内部类

        //匿名内部类
        Ilove love4=new Ilove() {
            @Override
            public void love(String name) {
                System.out.println(" i love you4 "+name);
            }
        };
        love4.love("songsongsongsong");// i love you4 songsongsongsong  匿名内部类

        //lambda
    /*    Ilove love5=(String name) -> {
                System.out.println(" i love you5 "+name);
        };*/
        //简化1 去掉参数类型
       /* Ilove love5=(name) -> {
            System.out.println(" i love you5 "+name);
        };*/
        //简化2 简化括号
       /* Ilove love5=name -> {
            System.out.println(" i love you5 "+name);
        };*/
        //简化3 去掉花括号
        Ilove love5=name -> System.out.println(" i love you5 "+name);
        //1.lambda表达式只能有一行代码的情况  只能简化为一行  如果有多行 就用代码块包围
        //2.前提是接口为函数式接口
        //3.多个参数也能去掉参数类型  （要去都去，逗号分隔，但必须加括号）
        love5.love("songsongsongsongsong");// i love you5 songsongsongsongsong  lambda
    }
}

//接口
interface Ilove{
    void love(String name);
}

//实现类
class love implements Ilove{

    @Override
    public void love(String name) {
        System.out.println(" i love you1 "+name);
    }
}