JDK8新特性（1）—— 函数式接口

1 函数式接口

• 有且仅有一个抽象方法的接口
• 格式

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

由于接口中的 public abstract 是可以省略的，所以函数式接口可以定义为

public interface MyInterface{
	void myMethod();
}

---

/**
 * @FunctionalInterface 检测接口是否为函数式接口
 *  是：编译成功
 */
@FunctionalInterface
public interface MyFuncInterface {
    public abstract void method();
}

1.1 函数式接口的使用

• 接口

/**
 * @FunctionalInterface 检测接口是否为函数式接口
 *  是：编译成功
 */
@FunctionalInterface
public interface MyFuncInterface {
    public abstract void method();
}

• 实现类

public class   MyFuncInterfaceImpl implements MyFuncInterface{
    @Override
    public void method() {
        System.out.println("方法执行了");
    }
}

/**
 * @Description 函数式接口使用：一般可以作为方法的参数和返回值类型
 * @Author tzb
 * @Date 2020/11/30 16:56
 * @Version 1.0
 **/
public class Demo {

    // 参数是函数式接口
    public static void show(MyFuncInterface myInter) {
        myInter.method();
    }

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

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

        // 方法2：调用show 方法，方法参数是一个接口，可以传递 lambda表达式
        show(()->{
            System.out.println("使用lambda表达式重写抽象方法");
        });

        // 简化 lambda 表达式
        show(() -> System.out.println("简化lambda表达式重写抽象方法"));
    }

}

1.2 使用 lambda 作为参数和返回值

• lambda 表达式可以被当做是匿名内部类的替代品，如果方法参数是一个函数式接口，那么就可以使用 lambda 表达式进行替换。
• 使用lambda 表达式作为方法参数，其实就是使用函数式接口作为方法参数；
  Runnable接口就是一个函数式接口

public class Demo01Runnable {

    // 方法参数使用函数式接口 Runnable
    public  static void startThread(Runnable runnable){
        // 开启多线程
        new Thread(runnable).start();
    }

    public static void main(String[] args) {
        // 调用 startThread 方法，参数是一个接口，那么可以传递这个接口的匿名内部类
        startThread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"--启动了");
            }
        });

        // 传递lambda表达式,run方法没有参数
        startThread(()->{
            System.out.println(Thread.currentThread().getName()+"--启动了");
        });
    }

}

---

• 案例

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 = {"a", "bb", "ccc"};
        Arrays.sort(arr,getComparator());
        System.out.println(Arrays.toString(arr));
    }
}