Lambda表达式

Lambda表达式

接口名 对象名 = (参数传递)->{方法体};

JDK1.8新特性，极大的简化了函数式接口的使用。

函数式接口就是有且仅有只有一个抽象方法实现的接口。

示例代码：

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

比如我们经常使用的线程接口Runnable，它只有一个抽象方法。这种接口就叫做函数式接口。

 

推导Lambda表达式

最早方法

也是最常规，基础阶段接触的最多的方法。

public class TestLambda {
    public static void main(String[] args) {
        //实例化对象
        Doctor doctor = new Doctor();
        //通过对象调用方法
        doctor.say();
    }
}
​
//定义一个函数式接口
interface Person {
    //该接口只有一个抽象方法say
    void say();
}
​
//定义一个类，继承Person接口，并实现say方法
class Doctor implements Person {
    //实现say方法
    @Override
    public void say() {
        System.out.println("我是博士");
    }
}

1. 定义一个实现该函数式接口的类。

2. 通过该类的实例化对象来调用重写的方法。

 

静态内部类

嫌弃写在外面太麻烦的程序员于是乎把实现类写在了类里面，并用static修饰。

public class TestLambda {
    //定义一个静态内部类，继承Person接口，并实现say方法
    static class Doctor implements Person {
        //实现say方法
        @Override
        public void say() {
            System.out.println("我是博士");
        }
    }
​
    public static void main(String[] args) {
        //实例化对象
        Person doctor = new Doctor();
        //通过对象调用方法
        doctor.say();
    }
}
​
//定义一个函数式接口
interface Person {
    //该接口只有一个抽象方法say
    void say();
}

 

局部内部类

嫌弃写static也麻烦的程序员把类写在了方法里。

public class TestLambda {
    public static void main(String[] args) {
        //定义一个局部内部类，继承Person接口，并实现say方法
        class Doctor implements Person {
            //实现say方法
            @Override
            public void say() {
                System.out.println("我是博士");
            }
        }
​
        //实例化对象
        Person doctor = new Doctor();
        //通过对象调用方法
        doctor.say();
    }
}
​
//定义一个函数式接口
interface Person {
    //该接口只有一个抽象方法say
    void say();
}

 

匿名内部类

后来大家觉得写类名都麻烦了，于是有了匿名内部类。

public class TestLambda {
    public static void main(String[] args) {
        //匿名内部类，实现类没有类名，使用的时候实现方法，必须借助接口或父类。
        Person doctor = new Person() {
            @Override
            public void say() {
                System.out.println("我是博士！");
            }
        };
        //调用实现后的方法
        doctor.say();
    }
}
​
//定义一个函数式接口
interface Person {
    //该接口只有一个抽象方法say
    void say();
}

 

Lambda表达式

最后干脆连new的过程也省了。（程序员是真TM懒啊）

public class TestLambda {
    public static void main(String[] args) {
        //Lambda表达式，因为函数式接口只有一个方法，所以直接实现该方法。
        Person doctor = ()->{
            System.out.println("我是博士！");
        };
        //调用实现后的方法
        doctor.say();
    }
}
​
//定义一个函数式接口
interface Person {
    //该接口只有一个抽象方法say
    void say();
}

注意：Lambda表达式的那个（）中间是传参用的！！

 

Lambda表达式的意义

接口名 对象名 = (参数传递)->{方法体};

1. 避免匿名内部类定义过多导致代码臃肿。

2. 去掉一些没有意义的代码，保持代码整洁，只留下最核心的逻辑。

3. 其本质是函数式编程的概念。

 

以上示例代码甚至可以简化成：

public class TestLambda {
    public static void main(String[] args) {
        //Lambda表达式，因为函数式接口只有一个方法，所以直接实现该方法。
        Person doctor = () -> System.out.println("我是博士！");
        //调用实现后的方法
        doctor.say();
    }
}
​
//定义一个函数式接口
interface Person {
    //该接口只有一个抽象方法say
    void say();
}

简化大括号是因为代码只有一行，如果多行就不能简化！！

 

如果有参数传递甚至可以不要括号跟参数类型：

public class TestLambda {
    public static void main(String[] args) {
        //Lambda表达式，因为函数式接口只有一个方法，所以直接实现该方法。
        Person doctor = a -> System.out.println("我是博士！");
        //调用实现后的方法
        doctor.say(521);
    }
}
​
//定义一个函数式接口
interface Person {
    //该接口只有一个抽象方法say
    void say(int a);
}

简化小括号是因为只有一个参数，如果多个参数就不能简化！！

简化大括号是因为代码只有一行，如果多行就不能简化！！