秃头星人进化记（Lambda表达式学习总结）

使用背景

原因：
（1）：避免匿名内部类定义过多
（2）：简化代码量
（3）：去杂留核
其实质属于函数式编程。
函数式接口：任何接口，如果接口中只含有一个抽象方法，那么他就是一个函数式接口。可以通过lambda表达式来创建接口的对象
例如： 线程中的Runnable接口：

 public interface Runnable {
	//只有一个抽象方法
    public abstract void run();
}

引出Lambda表达式

1：必须存在一个函数式接口
2：起初使用成员内部类
3：简化->静态内部类
4：简化->局部内部类
5：简化->匿名内部类
6：简化->Lambda表达式：相比于匿名内部类，由于接口名和方法名唯一不变就将其省略：…new Ilike() {
@Override
public void lambda… 省略这些后加上一个”->“即可。

总代码如下（示例）：

public class LambdaTest {

    //3:简化->静态内部类
    static class like2 implements Ilike{
        @Override
        public void lambda() {
            System.out.println("i like lambda2");
        }
    }

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

        new like2().lambda();

        //4:简化->局部内部类
        class like3 implements Ilike{
            @Override
            public void lambda() {
                System.out.println("i like lambda3");
            }
        }
        new like3().lambda();

        //5:简化->匿名内部类，没有名字，但是必须借助接口或者父类
        Ilike like4 = new Ilike() {
            @Override
            public void lambda() {
                System.out.println("i like lambda4");
            }
        };
        like4.lambda();

        //6:简化->lambda表达式  相当于省去了
        Ilike like5 = () -> {
            System.out.println("i like lambda5!!!!!!!");
        };
        like5.lambda();
    }


}

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

}

//2：定义接口实现类
class like implements Ilike{
    @Override
    public void lambda() {
        System.out.println("i like lambda!!!");
    }
}

再次简化Lambda表达式

1：之前通过内部类一步步简化到初始形态的Lambda表达式可以根据情况再次简化
2：这次尝试带参数的抽象方法
3：还是得先定义函数式接口
4：初始形态
5：一级简化：参数前面类型可省略，多个参数不同类型也可以省略，用逗号隔开即可
6：二级简化：参数两边的小括号亦可省略，但是多个参数的话就不能省略了

//String name ,int age类型可以省略，括号不能去！！！
ilove=(name，age) -> {
            System.out.println("I LOVE you"+age+name);
        };

7：三级简化：代码行两边的大括号也可省略，但是多行代码的话就不能省略了

ilove=name -> {
            System.out.println("I LOVE you"+name);
            System.out.println("I LOVE you"+name);
            System.out.println("I LOVE you"+name);
            //这样大括号就不能省略了！！！
        };

总代码如下（示例）：

//尝试带参数的抽象方法 并一步一步简化
public class LambdaTest2 {
    public static void main(String[] args) {
        Ilove ilove=null;
        //初始lambda
        ilove=(String name)->{
            System.out.println("I Love you"+name);
        };
        ilove.mylove("zhao you");

        //一级简化  如果是多个参数 不管类型是否相同 都可以省掉类型
        ilove=(name) -> {
            System.out.println("I LOVE you"+name);
        };
        ilove.mylove("gao lan ling");

        //二级简化 如果是多个参数 则不能去掉括号
        ilove=name -> {
            System.out.println("I LOVE you"+name);
        };
        ilove.mylove("lan ling");

        //三级简化 如果式多行代码命令 则不能去掉大括号
        ilove=name -> System.out.println("I LOVE you"+name);
        ilove.mylove("ling");
    }

}



//定义函数式接口
interface Ilove{
    void mylove(String name);
}

总结

之前一直不知道Lambda表达式是啥，通过一次线程的学习意外学到了lambda的基本使用，若有错误，烦请大佬指教。