JavaSE-23.1.1【函数式接口、函数式接口作为方法的参数和返回值】

package day14.lesson1;

/*
1 函数式接口

1.1 函数式接口概述

    概念
        有且仅有一个抽象方法的接口
        java中的函数式编程体现就是Lambda表达式，所以函数式接口就是可以适用于Lambda使用的接口
        只有确保接口中有且仅有一个抽象方法，java中的Lambda才能顺利进行推导
    如何检测一个接口是不是函数式接口
        @FunctionalInterface
        放在接口定义的上方：如果接口是函数式接口，编译通过；如果不是，编译失败
    注意事项
        我们自己定义函数式接口的时候，@FunctionalInterface是可选的，就算我不写这个注解，只要保证满足函数
        式接口定义的条件，也照样是函数式接口。但是，建议加上该注解
 */
public class Demo1MyInter {
    public static void main(String[] args) {
        MyInter mi = () -> System.out.println("函数式接口"); // 根据局部变量的赋值得知Lambda对应的接口https://www.cnblogs.com/yppah/p/14874679.html
        mi.show();
    }
}

@FunctionalInterface
interface MyInter{
    void show();

//    void method(); //注解FunctionalInterface编译异常
}

 

 

package day14.lesson1;

/*
1.2 函数式接口作为方法的参数

    需求描述
        定义一个类(RunnableDemo)，在类中提供两个方法
        一个方法是：startThread(Runnable r) 方法参数Runnable是一个函数式接口
        一个方法是主方法，在主方法中调用startThread方法
 */
public class Demo2Runnable {
    public static void main(String[] args) {
        // 匿名内部类
        startThread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "线程启动了");
            }
        });

        // Lambda表达式
        startThread(() -> System.out.println(Thread.currentThread().getName() + "线程启动了"));
        // 如果方法的参数是一个函数式接口，则可以使用Lambda表达式作为参数传递
    }

    private static void startThread(Runnable r){ // Runnable是函数式接口，可以作为形参
        /*Thread t = new Thread(r);
        t.start();*/
        new Thread(r).start();
    }

//    Runnable源码
//    @FunctionalInterface
//    public interface Runnable {
//        /**
//         * When an object implementing interface <code>Runnable</code> is used
//         * to create a thread, starting the thread causes the object's
//         * <code>run</code> method to be called in that separately executing
//         * thread.
//         * <p>
//         * The general contract of the method <code>run</code> is that it may
//         * take any action whatsoever.
//         *
//         * @see     java.lang.Thread#run()
//         */
//        public abstract void run();
//    }
}

 

 

package day14.lesson1;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;

/*
1.3 函数式接口作为方法的返回值

    需求描述
        定义一个类(ComparatorDemo)，在类中提供两个方法
        一个方法是：Comparator<String> getComparator() 方法返回值Comparator是一个函数式接口
        一个方法是主方法，在主方法中调用getComparator方法
 */
public class Demo3Comparator {
    public static void main(String[] args) {
        ArrayList<String> arrayList = new ArrayList<>();
        arrayList.add("ccc");
        arrayList.add("aa");
        arrayList.add("e");
        arrayList.add("dddd");
        arrayList.add("bbbbb");
        System.out.println("排序前：" + arrayList); // [ccc, aa, e, dddd, bbbbb]

//        Collections.sort(arrayList); // [aa, bbbbb, ccc, dddd, e] 自然顺序(按字母顺序)排序

        /*Collections.sort(arrayList, new Comparator<String>() {
            @Override
            public int compare(String s1, String s2) {
                return s1.length() - s2.length();
            }
        }); // [e, aa, ccc, dddd, bbbbb] 按字符串长度排序*/

        Collections.sort(arrayList, getComparator()); // 效果同上

        System.out.println("排序后：" + arrayList);
    }

    private static Comparator<String> getComparator(){ // Comparator是函数式接口
        //匿名内部类
        /*Comparator<String> comparator = new Comparator<String>(){
            @Override
            public int compare(String s1, String s2) {
                return s1.length() - s2.length();
            }
        };
        return comparator;*/
//        return new Comparator<String>() {
//            @Override
//            public int compare(String s1, String s2) {
//                return s1.length() - s2.length();
//            }
//        };

        // Lambda表达式
        /*return (String s1, String s2) -> {
            return s1.length() - s2.length();
        };*/
        return (s1, s2) -> s1.length()-s2.length();
        // 如果方法的返回值是一个函数式接口，则可以使用Lambda表达式作为结果返回
    }

//    Comparator源码
//    @FunctionalInterface
//    public interface Comparator<T> {...}
}