函数式接口 与 Lambda表达式

一、函数式接口

1.1 概念

* 函数式接口：有且只有一个抽象方法的接口，称之为函数式接口
  当然接口中可以包含其他的方法（默认方法、静态方法、私有方法）

* 函数式接口，即适用于函数式编程场景的接口。而Java中的函数式编程体现就是Lambda，所以函数式接口就是可以适用于Lambda使用的接口。只有确保接口中有且仅有一个抽象方法，Java中的Lambda才能顺利地进行推导。

* “语法糖”是指使用更加方便，但是原理不变的代码语法。例如在遍历集合时使用的for-each语法，其实底层的实现原理仍然是迭代器，这便是“语法糖”。
   从应用层面来讲，Java中的Lambda可以被当做是匿名内部类的“语法糖”，但是二者在原理上是不同的。

1.2 格式

只要确保接口中有且仅有一个抽象方法即可：

修饰符 interface 接口名称 {
   
	public abstract 返回值类型 方法名称(可选参数信息);
	// 其他非抽象方法内容
}

由于接口当中抽象方法的 public abstract 是可以省略的，所以定义一个函数式接口很简单：

public interface MyFunctionalInterface {
   
	void myMethod();
}

1.3 @FunctionalInterface注解

与@Override 注解的作用类似，Java 8中专门为函数式接口引入了一个新的注解： @FunctionalInterface 。
该注解可用于一个接口的定义上：

@FunctionalInterface
public interface MyFunctionalInterface {
   
	void myMethod();
}

一旦使用该注解来定义接口，编译器将会强制检查该接口是否确实有且仅有一个抽象方法，否则将会报错。需要注意的是，即使不使用该注解，只要满足函数式接口的定义，这仍然是一个函数式接口，使用起来都一样。

* @FunctionalInterface注解
* 作用：可以检测接口是否是一个函数式接口
     是：编译成功
     否：编译失败(接口中没有抽象方法 或 抽象方法的个数多于1个)

/*
    @Override注解
    检查方法是否为重写的方法,
        是：编译成功
        否：编译失败
 */
@FunctionalInterface
public interface MyFunctionalInterface {
   
    //定义一个抽象方法
    public abstract void method();

    /*void method2();*/
}

1.4 自定义函数式接口

对于刚刚定义好的 MyFunctionalInterface 函数式接口，典型使用场景就是作为方法的参数：

public class Demo09FunctionalInterface {
   
	// 使用自定义的函数式接口作为方法参数
	private static void doSomething(MyFunctionalInterface inter) {
   
		inter.myMethod(); // 调用自定义的函数式接口方法
	}
	public static void main(String[] args) {
   
		// 调用使用函数式接口的方法
		doSomething(() ‐> System.out.println("Lambda执行啦！"));
	}
}

函数式接口的使用

语法糖：是指使用更加方便，但是原理不变的代码语法。例如在遍集合时使用的for-each语法，其实底层的实现原理仍然是迭代器，这便是“语法糖”。从应用层面来讲，Java中的Lambda可以呗当作是匿名内部类的“语法糖”，但是二者在原理上是不同的。

/*
    函数式接口的使用：一般可以作为方法的参数和返回值类型
 */
public class Demo {
   
    //定义一个方法，参数使用函数式接口@MyFunctionalInterface
    public static void show(MyFunctionalInterface myInter) {
   
        myInter.method();
    }

    public static void main(String[] args) {
   
        //调用show方法，方法的参数是一个接口，所以可以传递接口的实现类对象
        show(new MyFunctionalInterfaceImpl());

        //调用show方法，方法参数是一个接口，所以我们可以传递接口的匿名内部类
        show(new MyFunctionalInterface() {
   
            @Override
            public void method() {
   
                System.out.println("使用匿名内部类重写接口中的抽象方法");
            }
        });

        //调用show方法，方法参数是一个函数式接口，所以我们可以Lambda表达式
        show(() -> {
   
            System.out.println("使用Lambda表达式重写接口中的抽象方法");
        });

        //简化Lambda表达式
        show(() -> System.out.println("使用Lambda表达式重写接口中的抽象方法"));
    }
}

二、函数式编程

在兼顾面向对象特性的基础上，Java语言通过Lambda表达式与方法引用等，为开发者打开了函数式编程的大门。
下面我们做一个初探。

2.1 Lambda的延迟执行

有些场景的代码执行后，结果不一定会被使用，从而造成性能浪费。而Lambda表达式是延迟执行的，这正好可以
作为解决方案，提升性能。

性能浪费的日志案例

* 日志案例:
	我们发现以下代码存在一些性能浪费的问题
	调用showLog方法，传递的第二个参数是一个拼接后的字符串
	先把字符串拼接好，然后再调用showLog方法
	showLog方法中如果传递的日志等级不是1级
	那么就不会是如此拼接后的字符串
	所以感觉字符串就白拼接了，存在了浪费

public class Demo01Logger {
   
    //定义一个根据日志的级别，显示日志信息的方法
    public static void showLog(int level, String message) {
   
        //对日志的等级信息进行判断，如果是1级别，那么输出日志信息
        if (level == 1) {
   
            System.out.println(message); //HelloWorldJava
        }
    }

    public static void main(String[] args) {
   
        //定义三个日志信息
        String msg1 = "Hello";
        String msg2 = "World";
        String msg3 = "Java";

        //调用showLog方法，传递日志级别和日志信息
        showLog(1,msg1+msg2+msg3);

    }
}

这段代码存在问题：无论级别是否满足要求，作为 log 方法的第二个参数，三个字符串一定会首先被拼接并传入方法内，然后才会进行级别判断。如果级别不符合要求，那么字符串的拼接操作就白做了，存在性能浪费。

2.2 使用Lambda优化日志案例

/*
    使用Lambda优化日志案例
    Lambda的特点：延迟加载
    Lambda使用前提：必须存在函数式接口
 */
public class Demo02Lambda {
   
    //定义一个显示日志的方法，方法的参数传递日志的等级和MessageBuilder接口
    public static void showLog(int level, MessageBuilder mb) {
   
        //对日志的等级进行判断，如果是1级，则调用MessageBuilder接口中的builderMessage方法
        if (level == 1) {
   
            System.out.println(mb.builderMessage());
        }
    }

    public static void main(String[] args) {
   
        //定义三个日志信息
        String msg1 = "Hello";
        String msg2 = "World";
        String msg3 = "Java";

        //调用showLog方法，参数MessageBuilder是一个函数式接口，所以可以传递一个Lambda表达式
        /*showLog(1, () -> {
            //返回一个拼接好的字符串
            return msg1 + msg2 + msg3;
        });*/
        /*
            使用Lambda表达式作为参数传递，仅仅是把参数传递到showLog方法中
            只有满足条件，日志的等级是1级
                才会调用接口MessageBuilder中的方法builderMessage
                才会进行字符串的拼接
           如果条件不满足，日志的等级不是1级
                那么MessageBuilder中的方法builderMessage也不会执行
                所以拼接字符串的代码也不会执行
           所以不会存在性能的浪费
         */
        showLog(2, () -> {
   
            System.out.println("不满足条件不执行");
            //返回一个拼接好的字符串
            return msg1 + msg2 + msg3;
        });
    }
}

2.3 使用Lambda作为参数

/*
    例如java.lang.Runnable接口就是一个函数式接口，
    假设有一个statThread方法使用该接口作为参数，那么就可以使用Lambda进行传参。
    这种情况其实和Thread类的构造方法参数为Runnable没有本质区别
 */
public class Demo01Runnable {
   
    //定义一个方法startThread,方法的参数使用函数式接口Runnable
    public static void startThread(Runnable run){
   
        //开启多线程
        new Thread(run).start();
    }

    public