import java.io.PrintStream;
import java.util.Comparator;
import java.util.function.*;

/**
 * 一、方法引用
 * lambda方法體之 --> 方法引用：若Lambda 體中的內容有方法已經實現了，我們可以使用"方法引用"
 * （可以理解為方法引用是Lambda 表達式的另外一種表現形式）
 *
 *
 * 主要有三種語法格式：
 *
 * 對象::實例方法名
 *
 * 類::靜態方法名
 *
 * 類::實例方法名
 *
 * 註意：
 *  1）Lambda 體中調用方法的參數列表與返回值類型，要與函數式接口中抽象方法的函數列表和返回值類型保持一致！
 *  2) 若Lambda參數列表中的第一參數是實例方法的調用者，而第二個參數是實例方法的參數時，可以使用 ClassName::method
 *      ClassName代表第一個參數的類型，也代表方法調用者的類型
 *      method的參數類型需要等同於第二個參數的類型
 *
 * 二、構造器引用
 *  格式：
 *  ClassName:new
 *      註意：需要調用的構造器參數列表要與函數式接口中抽象方法的參數列表保持一致
 *  三、數組引用
 *
 
 
*/

public class MethodRef {
    public static void main(String[] args) {
        test01();
        test02();
        test03();
        test04();
        test05();
        test06();
        test07();

    }
    /**
     * 對象::實例方法名
     */
    public static void test01() {
        PrintStream out = System.out;

        
 
//1.lambda表達式  --> 方法的實現
        Consumer<String> con2 = (x) -> out.println(x);

        //2.lambda對象方法的引用  --> 方法的引用
        // 前提：引用的方法的參數列表和返回值類型 要與函數式接口的方法的 參數列表和返回值類型一致
        Consumer<String> con = System.out::println;
        con.accept("abcdef");
    }

    /**
     * 對象::實例方法名
     
 
*/
    public static void test02() {
        Employee emp = new Employee();
        Supplier<String> sup1 = () -> emp.getName(); //lambda方法體：對匿名類創建的寫法的簡化
        String name = sup1.get();
        System.out.println(name);

        System.out.println("---------------");
        Supplier<Integer> sup2 = emp::getAge;  //lambda之方法引用：對lambda方法體的引用
        Integer age = sup2.get();

        System.out.println(age);
    }

    //類::靜態方法名
    public static void test03() {
        Comparator<Integer> com = (x,y) -> Integer.compare(x,y);
        Comparator<Integer> com2 = Integer::compare;
    }

    /**
     * 類::實例方法名
     * 前提條件：
     * 若Lambda參數列表中的第一參數是實例方法的調用者，而第二個參數是實例方法的參數時，可以使用 ClassName::method
     *      ClassName代表第一個參數的類型，也代表方法調用者的類型
     *      method的參數類型需要等同於第二個參數的類型
     */
    public static void test04() {
        BiPredicate<String,String> pre = (x,y) -> x.equals(y);
        BiPredicate<String,String> pre2 = String::equals;
    }

    /**
     * 構造器引用  無參數構造器
     */
    public static void test05() {
        Supplier<Employee> sup = () -> new Employee();
        Employee emp = sup.get();
        System.out.println(emp);

        System.out.println("----------");
        Supplier<Employee> sup2 = Employee::new;
        Employee emp2 = sup2.get();
        System.out.println(emp2);
    }

    /**
     * 構造器引用 有參數構造器，根據參數類型自動判斷
     */
    public static void test06() {
        Function<Integer,Employee> fun = (x) -> new Employee(x);
        Employee emp = fun.apply(1);
        System.out.println(emp);

        System.out.println("----------");
        Function<Integer,Employee> fun2 = Employee::new;//泛型中參數類型是Integer
        Employee emp2 = fun2.apply(2);  //構造器一個參數，自動根據參數類別判斷
        System.out.println(emp2);

        System.out.println("----------");
        Function<String,Employee> fun3 = Employee::new; //泛型中參數類型是String
        Employee emp3 = fun3.apply("hello world");//構造器一個參數，自動根據參數類別判斷
        System.out.println(emp3);
    }

    /**
     * 數組引用
     */
    public static void test07() {
        Function<Integer,String[]> fun = (x) -> new String[x];
        String[] arr = fun.apply(10);
        System.out.println(arr);

        System.out.println("----------");
        Function<Integer,String[]> fun2 = String[]::new;//泛型中參數類型是Integer
        String[] arr2 = fun2.apply(20);  //構造器一個參數，自動根據參數類別判斷
        System.out.println(arr2);
    }

}

JDK8新特性04 方法引用與構造器引用