Java Lambda表达式详解

Lambda表达式详解

什么情况下使用：

我们以前写一些类，写完发现只使用一次,这时候我们会把类从外部类拉到内部类，再进一步的是提升为匿名内部类，然后Java为了更加的简高效，所以有了Lambda表达式

作用及其本质：

（1）作用：避免匿名内部类定义过多
（2) 本质：属于函数式编程的概念，去掉没有意义的代码，只留下核心的逻辑

预备知识

Function Interface（函数式接口）：任何接口，如果只包含一个抽象方法，那它就是函数式接口
例如`：

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

演化代码：

package com.heima.Multithreading;

public class TestLambda {
    //3.静态内部类 02
    static class Like2 implements Ilike{

        @Override
        public void lambda() {
            System.out.println("i like lambda 02");
        }
    }

    public static void main(String[] args) {
        //01 创建对象，接口去new上一个实现类
        Ilike like = new Like();
        like.lambda();

        //02 调用静态内部类
        like = new Like2();//这里还是用了上面的like
        like.lambda();

        //4.局部内部类 03
        class Like3 implements Ilike{

            @Override
            public void lambda() {
                System.out.println("i like lambda 03");
            }
        }

        //03 调用局部内部类
        like = new Like3();//这里还是用了上面的like
        like.lambda();

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

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



    }
}

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

//2.外部实现类 01
class Like implements Ilike{

    @Override
    public void lambda() {
        System.out.println("i like lambda 01");
    }
}

重点解释：

lambda表达式，可以理解为只要了匿名内部类的这一部分核心代码，把其他无所谓的去掉了（多加了个箭头）

练习2:带参数

外部类

package com.heima.Multithreading;

public class TestLambda2 {
    public static void main(String[] args) {
        Ilove love = new Love();
        love.love(250);
    }
}
interface Ilove{
    void love(int a);
}
class Love implements Ilove{

    @Override
    public void love(int a) {
        System.out.println("i love you--->"+a);
    }
}

静态内部类：

package com.heima.Multithreading;

public class TestLambda2 {

    static class Love implements Ilove{

        @Override
        public void love(int a) {
            System.out.println("i love you--->"+a);
        }
    }

    public static void main(String[] args) {
        Ilove love = new Love();
        love.love(251);
    }
}
interface Ilove{
    void love(int a);
}

匿名内部类

package com.heima.Multithreading;

public class TestLambda2 {
   
    public static void main(String[] args) {
        Ilove love = new Ilove() {
            @Override
            public void love(int a) {
                System.out.println("i love you--->"+a);
            }
        };
        love.love(251);
    }
}
interface Ilove{
    void love(int a);
}

Lambda表达式

package com.heima.Multithreading;

public class TestLambda2 {


    public static void main(String[] args) {


        //lambda表达式
        Ilove love = (int a)->{
                System.out.println("i love you--->"+a);
            };

        //lambda表示是简化1:去掉参数类型,有多个参数时,要去掉都去掉
         love = (a)->{
            System.out.println("i love you--->"+a);
        };
         //Lambda表达式简化2:去掉括号,当只有一个参数时
        love = a->{
            System.out.println("i love you--->"+a);
        };

        //lambda表达式简化3:去掉花括号
        //当只有一行代码时
        love = a-> System.out.println("i love you--->"+a);
        
        
        love.love(253);


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

Lambda表达式简化总结:

简化最好只简化参数类型 , 其他很少用到