函数式接口和方法引用

什么是函数式接口
一个接口里面只有一个抽象方法，那么这个接口就称为函数式接口

       @FunctionalInterface注解概述

                这个注解是jdk1.8的新特性，用在接口上面，说明这个接口是一个函数式接口，只能有一个抽象方法，如果有多个抽象方法就编译不通过

 

        常用函数式接口

                 Runnable   Callable   Comparator    FileFilter   Consumer    Function   Predicate

方法引用
什么是方法引用

                    方法引用是jdk1.8的新特性，是用来简化lambda表达式的

            使用方法引用的前提

                    必须要有函数式接口，必须要使用到lambda表达式，的前提下才可以考虑可不可以使用方法引用

           方法引用的好处

                    简化了lambda表达式，重复使用已经存在的方法

            方法引用类型

                      静态方法引用    格式    类名 ::  静态方法名

                      对象方法引用     格式   对象名 ::非静态方法名

                      构造方法引用    格式    类名 :: new

                      特定类型的实列方法引用    格式    类名 :: 非静态方法名

             

                 使用方法引用注意：必须要使用到lambda表达式，并且只有当lambda表达式里面只有一条语句，的前提下才可以考虑能不能使用方法引用；

                 如果函数式接口里面的抽象方法，没有返回值，被引用的方法可以没有返回值，也可以有返回值

                 如果函数式接口的抽象方法，有返回值，那么被引用的方法也一定要有返回值，并且返回值类型要是他的子类或者和抽象方法的类型一样

类名引用静态方法：

@FunctionalInterface  // 声明函数式接口
public interface Calcable {
    public abstract int calc(int num);
}

public class Math {

    public static int abs(int num) {
        // 获取一个数字的绝对值
        if (num < 0) {
            return -num;
        } else {
            return num;
        }
    }
}

/**
 * 静态方法引用的格式：
 * 方法中（类名::静态方法名称）
 */
public class Test {

    public static void main(String[] args) {
        // 使用Lambda表达式形式来调用method方法
        method(-10,(int num)->{return Math.abs(num);});
        // 方法引用
        method(-20,Math::abs);
        /**
         * 等效于：
         * 重写了calc方法
         * public int calc (int num){
         *     return Math.abs(num);
         * }
         */
    }

    public static void method(int num,Calcable calcable){
        System.out.println(calcable.calc(num));
    }
}

对象名引用方法

@FunctionalInterface
public interface Printable {
    public abstract void print(String s);
}

public class StringUtils {

    public void printUpperCase(String s){
        System.out.println(s.toUpperCase());
    }
}

/**
 * 对象名的方法引用
 * 格式：
 * 方法（对象名:: 方法名）
 */
public class Test {

    public static void main(String[] args) {
        StringUtils stringUtils = new StringUtils();
        // 使用Lambda表达式来实现
        method("abc",s -> stringUtils.printUpperCase(s));

        // 使用对象名引用名方法来实现
        method("abc",stringUtils::printUpperCase);
    }

    public static void method(String s,Printable printable){
        printable.print(s);
    }
}

构造器引用：

@FunctionalInterface
public interface PersionBuild {

    public abstract Persion buildPersion(String name);
}

public class Persion {

    private String name;

    public Persion() {
    }

    public Persion(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Persion{" +
                "name='" + name + '\'' +
                '}';
    }
}

/**
 * 构造方法引用格式
 * 方法（类名:: new）
 */
public class Test {

    public static void main(String[] args) {
        // 使用Lambda表达式实现
        method("杨过",name -> new Persion(name));

        // 使用构造方法引用实现
        method("小龙女",Persion::new);
    }


    public static void method(String name,PersionBuild persionBuild){
        System.out.println(persionBuild.buildPersion(name));
    }
}

类名引用普通方法：

@FunctionalInterface
public interface Printable {
    public abstract void print(StringUtils su,String s);
}

public class StringUtils {

    public void printUpperCase(String s){
        System.out.println(s.toUpperCase());
    }
}

/**
 * 类名引用普通方法
 * 方法(类名::普通方法名称)
 */
public class Test {

    public static void main(String[] args) {
        // 使用Lambda表达式来使用
        method(new StringUtils(),"abc",(StringUtils stringUtils,String s)->stringUtils.printUpperCase(s));

        // 使用类名引用普通方法的形式
        method(new StringUtils(),"asd",StringUtils::printUpperCase);
    }

    public static void method(StringUtils stringUtils,String s,Printable printable){
        printable.print(stringUtils,s);
    }
}