Java新特性之方法引用

方法引用的使用

最初，引用只是针对引用类型完成的，也就是只有数组、类、接口才具备引用操作。JDK1.8后追加了方法引用。实际上引用的本质就是别名。
因此方法的引用就是别名的使用。
方法的引用有四种形式：

1. 引用静态方法： 类名称:: static方法名称；
2. 引用某个对象的方法：实例化对象::普通方法；
3. 引用某个特定类的方法：类名称::普通方法；
4. 引用构造方法：类名称::new。

方法的引用是结合函数式编程使用。

---

1.引用静态方法

举例：使用函数编程返回静态方法

//函数接口+泛型接口 = 函数泛型接口
@FunctionalInterface
public interface IUtil<P,R>{
    R swithPara(P p);
}

public class TestMothod {
    public static void main(String[] args) {
        IUtil<Integer,String> iUtil = (p)->{
            //String.valueOf()为静态方法，将int->String
            return String.valueOf(p);
        };
        iUtil.swithPara(5);  //5
    }
}

举例：使用静态方法引用

//函数接口+泛型接口 = 函数泛型接口
@FunctionalInterface
public interface IUtil<P,R>{
    R swithPara(P p);
}

public class TestMothod {
    public static void main(String[] args) {
       
        String str = "1234";
         //使用类的静态方法,将int->Sring
        IUtil<Integer,String> iUtil = String::valueOf;
        System.out.println(iUtil.swithPara(5));  //5
		//将String->int
        IUtil<String,Integer> iUtil1 = Integer::parseInt;
        System.out.println(iUtil1.swithPara(str)); //1234
    }
}

在上述例子中，可以两个方法看做数学函数去理解，即y = f(x)。其中：

1. y = switchPara(x) ,其中x = p ， 是把int->String;
2. y = valueOf(x), 其中x = p ， 把int-> String;

这两者做的事情是一样的，那么给String的静态方法取个别名，就是静态方法引用。

2. 引用对象方法

举例：对象方法的引用

@FunctionalInterface
public interface IUtil<P>{
    P convert();
}

public class TestMothod {
    public static void main(String[] args) {

        String str = "hello";
        /*
        IUtil<String> iUtil = ()->{
            return str.toUpperCase();
        };*/

        //对象的方法引用
        IUtil<String> iUtil = str::toUpperCase;
        System.out.println(iUtil.convert());  //HELLO
    }
}

3.引用类中的普通方法

举例：引用普通方法

@FunctionalInterface
public interface IUtil<P1,P2,R>{
    R compare(P1 p1, P2 p2);
}

public class TestMothod {
    public static void main(String[] args) {

        /*
          IUtil<Integer,Integer,Integer> iUtil = (p1,p2)->{
              return p1.compareTo(p2);
          };*/
        //成员方法引用--- 类名::成员方法
        IUtil<Integer,Integer,Integer> iUtil = Integer::compareTo;
        System.out.println(iUtil.compare(4,1));

        IUtil<String,String,Integer> iUtil1 = String::compareTo;
        System.out.println(iUtil1.compare("A","a"));  //-32

    }
}

4. 引用构造方法

举例：引用构造方法

public interface IUtil<P1,P2,R>{
    R createObject(P1 p1, P2 p2);
}

public class Person {
    private String name;
    private Integer age;

    public Person(String name, Integer age) {
        this.name = name;
        this.age = age;
    }

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

public class TestMothod {
    public static void main(String[] args) {

        /*
        IUtil<String,Integer,Person> iUtil= (p1,p2)->{
            return new Person(p1,p2);
        };*/
        
        //引用构造方法--- 类名称::new
        //函数接口中的参数要和构造方法中的参数匹配
        IUtil<String,Integer,Person> iUtil = Person::new;
        System.out.println(iUtil.createObject("张三",20));

    }
}

总结：
1. 结合函数式编程使用，接口中值允许有一个方法；
2.无论是静态引用，还是普通成员方法引用，上面几种方式中接口的返回值和要引用的返回值相同。