【重难点】函数式接口、函数式编程、匿名内部类、Lambda表达式、语法糖

一、函数式接口

1、概念

仅有一个抽象方法的接口

适用于函数式编程（Lambda表达式）

 常见：Runnable、Comparator<>、生产型接口Producer的get方法、消费型接口Consumer的accept方法、Predict接口的test方法

2、格式

加FunctionalInterface注解进行检测

如果不是函数式接口则编译失败

3、使用

编写实现类，对抽象类中的方法进行实现

在另一个类中定义方法，参数为函数式接口的引用（如Runnable runnable），函数体内调用了函数式接口的抽象方法，即runnable.run()

参数传递实现类的对象

如：show(new MyFunInterfaceImpl());

二、函数式编程

1、概念

一种新的编程范式，区别于过程式编程，如sum(a,b,c)

函数式编程会写为：sum(sum(a,b),c)，即把运算过程定义为不同的函数

优点：可以实现延迟执行（第二个参数在第一个参数判断之后），避免性能浪费

2、常见的使用

函数式接口作为参数

函数式接口作为返回值

package com.liujinhui.Day1207FunInterface.ThreadTest;
import java.util.Arrays;
import java.util.Comparator;
/*
    ，如果一个方法的返回值类型是一个函数式接口，
    那么就可以直接返回一个Lambda表达式。
    当需要通过一 个方法来获取一个 java.util.Comparator 接口类型的对象作为排序器时,就可以调该方法获取。
* */
public class Demo02Comparator {
    //定义一个方法，方法的返回值类型使用函数式接口Comparator
    public static Comparator<String> getComparator(){
        //方法的返回值类型是一个接口，那么可以返回这个接口的匿名内部类
        /*
            return new Comparator<String>() {
                @Override
                public int compare(String o1,String o2){
                    //按照字符串的降序排序
                    return o2.length()-o1.length();
                }
            };
        */
        //方法的返回值是一个函数式接口，可以返回一个Lambda表达式
       /**/ /*return (String o1,String o2)->{
            //按照字符串的降序排序
            return o2.length()-o1.length();
        };*/
        //继续优化Lambda表达式
        return (o1,o2)->o2.length()-o1.length();
    }
    public static void main(String[] args) {
        //主方法调用：创建一个字符串数组
        String[] arr={"aaa","b","cccc","dddddddddddddd"};
        //输出排序前的数组[aaa, b, cccc, dddddddddddddd]
        System.out.println(Arrays.toString(arr));
        //调用Arrays中的sort方法，对字符串数组进行排序
        Arrays.sort(arr,getComparator());
        //输出排序后的数组[dddddddddddddd, cccc, aaa, b]
        System.out.println(Arrays.toString(arr));
    }
}

3、实现方式

• 匿名内部类：Anonymous classes enable you to declare and instantiate a class at the same time. Use them if you need to use a local class only once.
  • 如：int a = new Scanner(System.in).nextInt();
  • 允许任意类使用
Lambda表达式：是一个匿名函数，是jdk8的新特性，允许把函数作为一个方法的参数进行传递，即：方法名(()->{});
• 只允许函数式接口使用
• 自动根据上下文推断，可以进行简化，即：方法名(()->);--无return、参数类型、括号，要省全省
• Lambda表达式≈匿名内部类的语法糖（方便但原理不变，如for-each是Iterator的语法糖）
• 本质：定义new 接口，内部重写接口的抽象方法
• Lambda的实例方法引用：如list.stream()..filter(Objects::nonNull).forEach(System.out::println);（本质是System类中PrintStream类型的静态类对象out的println方法，即对元素进行打印输出）

  //使用com.google.guava包创建集合
    List<String> list =Lists.newArrayList("a","b","c","d");
    //1、正常遍历
    list.forEach(item->System.out.println(item));
    //2、根据条件遍历
    list.forEach(item->{
        if("b".equals(item)){
            System.out.println(item);
        }

逐步优化　　

package com.liujinhui.Day1207FunInterface.ThreadTest;
/*
     java.lang.Runnable 接口就是一个函数式接口，
     假设有一个 startThread 方法使用该接口作为参数，
     可以使用Lambda进行传参。这种情况其实和 Thread 类的构造方法参数为 Runnable 没有本质区别。
* */
public class Demo01Runnable {
    //定义一个方法stratThread，方法的参数使用函数式接口Runnable
    public static void startThread(Runnable run){
        //开启多线程
        new Thread(run).start();
    }
    public static void main(String[] args) {
        //调用startThread方法，方法的参数是一个接口，可以传递接口的匿名内部类
        startThread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"-->"+"线程启动了");
            }
        });
        //使用Lambda表达式优化函数式接口，参数传递Lambda表达式
        startThread(()->{
            System.out.println(Thread.currentThread().getName()+"-->"+"线程启动了");
        });
        //lambda的优化
        startThread(()->System.out.println(Thread.currentThread().getName()+"-->"+"线程启动了"));
    }
}

4、相同点与不同点

• 相同点：
  • 都属于函数式编程的内容（逐步实现简化）
• 不同点：
  • 匿名内部类会被保存为Demo$1.class字节码文件，而Lambda不会保存为class字节码文件
  • 匿名内部类可以用于任意类，Lambda表达式只能用于函数式接口