Lambda表达式#代码简化

Lambda表达式也可以称为闭包，Lambda表达式是在Java8新增的一种重要的新特性。
Lambda允许把函数作为一个方法的参数（函数作为参数传递进方法中）。

//格式一般如下
(parameters)->expression;//表达式
//或
(parameters)->{statements;};//语句

//eg:多线程中实现Runnable接口的线程创建。
new Thread(()->System.out.println("这就是Lambda表达式")).start();

Lambda表达式可以避免匿名内部类定义过多，简化了编程，使代码变得更加简洁紧凑。
其实质上属于函数式编程的概念。

Lambda表达式创建的对象需要实现一个函数式接口(Functional Interface)
函数式接口是只包含一个方法的接口,比如Java标准库中的java.lang.Runnable和 java.util.Comparator

//函数式接口：Runnable接口
public interface Runnable{
    public abstract void run();
}

函数式接口的定义：

• 任何接口，如果只包含一个抽象方法，那么他就是一个函数式接口。
• 对于函数式接口，我们可以通过Lambda表达式来创建该接口的对象。

//代码简化，由一般情况到Lambda表达式
public class LambdaTest {
    //1.静态内部类
    static class N1 implements M{
        @Override
        public void lambda() {
            System.out.println("静态内部类!!!");
        }
    }


    public static void main(String[] args) {
        M demon = new N(); //接口创建对象  接口new一个实现类  一般情况
        demon.lambda();


        demon = new N1(); //静态内部类
        demon.lambda();


        //2.局部内部类
        class N2 implements M{
            @Override
            public void lambda() {
                System.out.println("局部内部类!!!");
            }
        }


        demon = new N2();//局部内部类
        demon.lambda();


        //3.匿名内部类   没有名称，借助接口去实现，相当于一个语句后面要加";"
        demon = new M() {
            @Override
            public void lambda() {
                System.out.println("匿名内部类!!!");
            }
        } ;
        demon.lambda();




        //4.lambda表达式  是一行语句
        demon = ()->{
            System.out.println("lambda表达式!!!");
        };
        demon.lambda();


    }
}


//定义一个函数式接口
interface M{
    void lambda();
}
//实现类
class N implements M{
    @Override
    public void lambda() {
        System.out.println("一般情况!!!");
    }
}

Lambda表达式的重要特征：

• 可选类型声明：不需要声明参数类型，编译器可以统一识别参数

public class LambdaTest1 {
    public static void main(String[] args) {
        A a = null;
        //不声明参数        
        a = (x) -> System.out.println("Lambda表达式学习"+x);
        //参数声明
        //a = (int x) -> System.out.println("Lambda表达式学习"+x);
        a.Lambda(8);
    }
}


interface A{
    public void Lambda(int x);
}
class B implements A{
    @Override
    public void Lambda(int x) {
        System.out.println("Lambda表达式学习"+x);
    }
}

• 可选的参数圆括号：一个参数无需定义圆括号，但多个参数需要定义圆括号

public class LambdaTest1 {
    public static void main(String[] args) {
        A a = null;
        a = x -> System.out.println("Lambda表达式学习"+x);
        //多个参数需定义圆括号
        //a = (x,y) -> System.out.println("Lambda表达式学习"+x+"第二参数"+y);
        a.Lambda(8);
    }
}


interface A{
    public void Lambda(int x);
}
class B implements A{
    @Override
    public void Lambda(int x) {
        System.out.println("Lambda表达式学习"+x);
    }
}
//多个参数定义
/*interface A{
    public void Lambda(int x,int y);
}
class B implements A{
    @Override
    public void Lambda(int x,int y) {
         System.out.println("Lambda表达式学习"+x+"第二参数"+y);
    }
}*/

• 可选的大括号：如果主体只包含了一个语句，就不需要使用大括号。

public class LambdaTest1 {
    public static void main(String[] args) {
        A a = null;
        a = ()->System.out.println("Lambda表达式学习");
        //多行语句的话需要大括号
        /*a = ()->{
            System.out.println("Lambda表达式学习");
            System.out.println("多个语句则需要大括号");
        };*/
        a.Lambda();
    }
}


interface A{
    public void Lambda();
}
class B implements A{
    @Override
    public void Lambda() {
        System.out.println("Lambda表达式学习");
        //System.out.println("多个语句则需要大括号");
    }
}

• 可选的返回关键字：如果主体只有一个表达式返回值则编译器会自动返回值，大括号需要指明表达式返回了一个数值。

Lambda表达式中不允许声明一个与局部变量同名的参数或者局部变量。