lambda表达式

作用：对函数式接口实现类的简化（最终剩下参数及方法体）（函数式接口：有且只有一个抽象方法）

建立步骤：

package com.gl.day1;

interface LambdaTest {                           /*1.定义函数式接口*/
    void lambda(int a);
}
public class main {
    public static void main(String[] args) {
        LambdaTest lt;                           /*2.以接口名为类型声明对象*/
        lt = (a)->{                              /*3.接口实现类的lambda表达式并实例化对象lt*/
            System.out.println("this is a lambda expression");
            System.out.println("the input is "+a);
        };
        lt.lambda(1);                            /*4.lambda表达式的方法调用*/
        /*如果方法体只有一行，可进一步简化*/
        lt = a-> System.out.println("the input is "+a); 
        lt.lambda(2); 
    }
}

输出

this is a lambda expression
the input is 1
the input is 2

lambda表达式的诞生（接口实现类->静态内部类->具备内部类->匿名内部类->lambda表达式）

interface LambdaTest {                                   /*定义一个函数式接口*/
    void lambda(int a);
}

class T1 implements LambdaTest{                          /*定义函数式接口的实现类*/
    public void lambda(int a){
        System.out.println("this is a implements class");
        System.out.println("the input is "+a);
    }
}

public class main {
    static class T2 implements LambdaTest{               /* 简化1 将实现类简化为静态内部类*/
        public void lambda(int a){
            System.out.println("this is a static inner class");
            System.out.println("the input is "+a);
        }
    }
    public static void main(String[] args) {
        LambdaTest lt;
        class T3 implements LambdaTest{                 /*简化2 将静态内部类简化为局部内部类*/
            public void lambda(int a){
                System.out.println("this is a  local inner classes");
                System.out.println("the input is "+a);
            }
        }

        lt = new T1();  /*实现类的方法调用*/
        lt.lambda(1);
        lt = new T2();  /* 静态内部类的方法调用*/
        lt.lambda(2);
        lt = new T3(); /*局部内部类的方法调用*/
        lt.lambda(3);
        lt = new LambdaTest() {                         /*简化3 将局部内部类简化为匿名内部类，匿名内部类需借助接口及父类*/
            @Override
            public void lambda(int a) {
                System.out.println("this is a  Anonymous inner class");
                System.out.println("the input is "+a);
            }
        };
        lt.lambda(4); /*匿名内部类的方法调用*/
        lt = (a)->{                                     /*终极简化 将匿名内部类简化为lambda表达式*/
            System.out.println("this is a lambda expression");
            System.out.println("the input is "+a);
        };
        lt.lambda(5); /*lambda表达式的方法调用*/
    }
}

输出为

this is a implements class
the input is 1
this is a static inner class
the input is 2
this is a  local inner classes
the input is 3
this is a  Anonymous inner class
the input is 4
this is a lambda expression
the input is 5

均可正常输出，简化有效！