【JAVA学习之路 | 进阶篇】方法引用与构造器引用

1.方法引用的理解

(1). 方法的引用，可以看作是对lambda表达式的进一步刻画.

(2). 当需要提供一个函数式接口的实例时，可以使用lambda表达式提供.当满足一定的条件下，我们还可以使用方法引用或构造器引用替代.

(3). 方法引用的本质就是提供了函数式接口的实例.

2.使用情况

(1). 对象 :: 实例方法

要求 : 函数式接口的抽象方法a与其内部实现时调用的某个方法b的形参列表与返回值类型都相同或一致时.此时可以使用方法b对方法a实现覆盖，替换.

@Test
    public void test1() {
        //繁琐的匿名实现类的对象的写法
        Consumer<String> c1 = new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        };
        c1.accept("hexua");
        //简洁的方法引用的写法
        //System.out为标准输出流, 类型为PrintStream
        Consumer<String> c2 = System.out :: println;
        c2.accept("hexua");
        //输出 : hexua
        //      hexua
    }

注 : 此时accept方法与println方法形参列表相同(都是String类型)，都没有返回值类型.所以可以用方法引用，用println方法对accept方法进行覆盖.

(2). 类 :: 类方法

要求 : 函数式接口的抽象方法a与其内部实现时调用的某个类中的静态方法b的形参列表与返回值类型都相同或一致时.此时可以使用方法b对方法a实现覆盖，替换.

@Test
    public void test2() {
        //繁琐的匿名实现类的对象的写法
        Function<Double , Long> f1 = new Function<Double, Long>() {
            @Override
            public Long apply(Double aDouble) {
                return Math.round(aDouble);
            }
        };
        System.out.println(f1.apply(34.4));
        //简洁的方法引用的写法
        Function<Double, Long> f2 = Math :: round;
        System.out.println(f2.apply(34.4));
        //输出 : 34
        //      34
    }

注 : 此时apply方法与round方法的形参列表一致(apply是Double型，round是double型).且返回值类型同样一致.所以可以实现round方法对apply的覆盖.

(3). 类 :: 实例方法

要求 : 函数式接口中的抽象方法a与其内部实现时调用的某个对象的实例方法b的返回值类型相同或一致.

同时，抽象方法a中有n个参数，方法b中有n-1个参数，且抽象方法a中的第一个参数作为方法b的调用者，且抽象方法a的第一个参数后的n-1的参数与方法b的n-1个参数类型均相同或一致，则可以考虑使用方法b对方法a的覆盖.

注 : 此时方法b为非静态方法，需要对象调用，但形式上，需要写出对象a(抽象方法a参数列表中的第一个参数)所属的类.

@Test
    public void test3() {
        //繁琐的匿名实现类的对象的写法
        Comparator<String> c1 = new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return o1.compareTo(o2);
            }
        };
        System.out.println(c1.compare("hexua", "hexuan"));
        //简洁的方法引用的写法
        Comparator<String> c2 = String :: compareTo;
        System.out.println(c2.compare("hexua", "hexuan"));
        //输出 : -1
        //      -1
    }

注 : compare方法的第一个参数作为compareTo方法的调用者，且compare方法的后一个参数的类型与compareTo方法的参数类型相同，且该两个方法的返回类型相同，故可以实现compareTo方法对compare方法的覆盖.

3.构造器引用

(1). 格式 : 类名 :: new.

(2). 例 : 

public class Employee {
    int age;
    String name;

    public Employee() {
        System.out.println("调用了空参构造器");
    }

    public Employee(int age, String name) {
        System.out.println("调用了有两个参数的构造器");
        this.age = age;
        this.name = name;
    }

    public Employee(int age) {
        System.out.println("调用了一个参数构造器");
        this.age = age;
    }
}

@Test
    public void test4() {
        Supplier<Employee> s1 = new Supplier<Employee>() {
            @Override
            public Employee get() {
                return new Employee();
            }
        };
        Employee e1 = s1.get();

        Supplier<Employee> e2 = Employee :: new;
        Employee s2 = e2.get();
        //输出 : 调用了空参构造器
        //调用了空参构造器
    }
    @Test
    public void test5() {
        Function<Integer, Employee> f1 = Employee :: new;
        f1.apply(12);
        //输出 : 调用了一个参数构造器
    }
    @Test
    public void test6() {
        BiFunction<Integer, String, Employee> f1 = Employee :: new;
        f1.apply(12, "hexua");
        //输出:调用了有两个参数的构造器
    }

注 : 

• 调用了类名对应的类中某个对应的构造器.
• 具体调用的构造器取决于函数式接口中的抽象方法的参数列表.如Supplier接口中的get()方法无参，返回值类型为Employee，则返回无参数的Employee对象.Function接口中的apply方法有一个参数(类型Integer)，则返回有一个参数的Employee对象.

4.数组引用.

(1). 格式 : 数组元素的类型[] :: new

(2). 例 : 

@Test
    public void test7() {
        Function<Integer, Employee[]> f1 = new Function<Integer, Employee[]>() {
            @Override
            public Employee[] apply(Integer integer) {
                return new Employee[integer];
            }
        };
        Employee[] e1 = f1.apply(4);
        System.out.println("数组的长度" + e1.length);

        Function<Integer, Employee[]> f2 = Employee[] :: new;
        Employee[] e2 = f2.apply(4);
        System.out.println("数组的长度" + e2.length);
        //输出 :数组的长度4
        //数组的长度4
    }