Java 1.8 新特性—— 方法引用的详细解释
在使用Lambda表达式的时候，我们实际上传递进去的代码就是一种解决方案：拿什么参数做什么操作。那么考虑一种情况：如果我们在Lambda中所指定的操作方案，已经有地方存在相同方案，那是否还有必要再写重复逻辑？
一、冗余的 Lambda 场景
1、Lambda 表达式需要函数式接口的支持
先写一个函数式接口 Jiekou.java
package cn_lemon;
@FunctionalInterface
public interface Jiekou {//函数式接口
void print(String str);
}
在 Jiekou 中的唯一抽象方法 print 接收一个字符串参数，并打印显示它
package cn_lemon;
public class LambdaDemo {
private static void printString(Jiekou data) {
data.print("Hello Java");
}
public static void main(String[] args) {
printString(s -> System.out.println(s));
}
}
其中printString方法只管调用Jiekou接口的print方法，而并不管print方法的具体实现逻辑会将字符串打印到什么地方去。而main方法通过Lambda表达式指定了函数式接口Jiekou的具体操作方案为：拿到String（类型可推导，所以可省略）数据后，在控制台中输出它。
这段代码的问题在于，对字符串进行控制台打印输出的操作方案，明明已经有了现成的实现，那就是System.out对象中的println(String)方法。既然Lambda希望做的事情就是调用println(String)方法，那何必自己手动调用呢？
其实，只要引用过去就好了：
二、方法引用符 ::
1、概述：
双冒号::为引用运算符，而它所在的表达式被称为方法引用。如果Lambda要表达的函数方案已经存在于某个方法的实现中，那么则可以通过双冒号来引用该方法作为Lambda的替代者。
例如上例中，System.out对象中有一个重载的println(String)方法恰好就是我们所需要的。那么对于printString方法的函数式接口参数，对比下面两种写法，完全等效：
s -> System.out.println(s)System.out :: println
第一中写法：拿到参数之后经 Lambda 之手，继而传递给 System.out.println 方法去处理
第二种写法：直接让 System.out 中的 println来取代 Lambda
注意：Lambda 中 传递的参数 一定是方法引用中 的那个方法可以接收的类型,否则会抛出异常
2、推导与省略
如果使用Lambda，那么根据“可推导就是可省略”的原则，无需指定参数类型，也无需指定的重载形式——它们都将被自动推导。而如果使用方法引用，也是同样可以根据上下文进行推导。
由于上文中的 Jiekou 改变了之后，自动推导出唯一对应的匹配的重载，所以方法引用不用修改，只需改成 int 类型即可
三、通过对象名引用成员方法
先写函数式接口
package cn_lemon;
@FunctionalInterface
public interface Jiekou {
void print(String str);
}
写一个类，类 Lei 里有一个成员方法 printUpper
package cn_lemon;
public class Lei {
public void printUpper(String str) {
System.out.println(str.toUpperCase());
}
}
再写一个主类 LambdaDemo.java 类
package cn_lemon;
public class LambdaDemo {
private static void printString(Jiekou jk) {
jk.print("Hello Java");
}
public static void main(String[] args) {
Lei lei = new Lei();
printString(lei::printUpper);
}
}
当需要使用 Lei 类里的 printUpper 成员方法 来代替 Jiekou 接口中的 Lambda 的时候，已经具有了 Lei 类的对象的实例，就可以使用对象名引用成员方法
四、通过类名称引用静态方法
先写函数式接口
package cn_lemon;
@FunctionalInterface
public interface Jiekou {
int jisuan(int num);
}
使用 Lambda 表达式的写法为：
package cn_lemon;
public class Demo {
private static void method(int num, Jiekou jk) {//静态方法
System.out.println(jk.jisuan(num));
}
public static void main(String[] args) {
method(-12, n -> Math.abs(n));//abs 是取绝对值
}
}
或者使用方法引用
在这个例子中，下面两种写法是等效的：
- Lambda表达式：
n -> Math.abs(n) - 方法引用：
Math::abs
五、通过 super 引用成员方法
如果存在继承关系，当 Lambda 中需要出现 super 时
先写函数式接口 Jiekou.java
package cn_lemon;
@FunctionalInterface
public interface Jiekou {
void say();
}
写父类 Father.java
package cn_lemon;
public class Father {
public void sayHello() {
System.out.println("父类说Hello");
}
}
再写子类 Son.java 并继承父类
package cn_lemon;
public class Son extends Father {
@Override
public void sayHello() {
System.out.println("这是子类重写了父类的 Hello");
}
public void method(Jiekou jk) {//定义方法 method 传递参数 Jiekou 接口
jk.say();
}
public void show() {
method(() -> {//调用 method 方法，使用 Lambda 表达式
new Father().sayHello();
});
//method(() -> new Father().sayHello());//使用简化的 Lambda 表达式
//method(() -> super.sayHello());//使用关键字代替父类对象
//method(super :: sayHello);//通过 super 引用成员方法
}
public static void main(String[] args) {
Son s = new Son();
s.show();
}
}
在上面的代码中，四种写法是等价的
六、通过 this 引用成员方法
先写函数式接口 Jiekou.java
package cn_lemon;
@FunctionalInterface
public interface Jiekou {
void buy();
}
再写一个类 Husband.java
package cn_lemon;
public class Husband {
public void marry(Jiekou jk) {
jk.buy();
}
public void beHappy() {
marry(() -> System.out.println("买房子"));
}
public static void main(String[] args) {
Husband h = new Husband();
h.beHappy();
}
}
开心方法beHappy调用了结婚方法marry，后者的参数为函数式接口Jiekou，所以需要一个Lambda表达式。但是如果这个Lambda表达式的内容已经在本类当中存在了，则可以对Husband丈夫类进行修改：
package cn_lemon;
public class Husband {
public void buyHouse(){
System.out.println("买套房子");
}
public void marry(Jiekou jk){
jk.buy();
}
public void beHappy(){
marry(() -> this.buyHouse());
//取消掉 Lambda 表达式，用方法引用是
//marry(this :: buyHouse);
}
public static void main(String[] args) {
Husband h = new Husband();
h.beHappy();
}
}
两种方法等效
marry(() -> this.buyHouse());marry(this :: buyHouse);
七、类的构造器引用
由于构造器的名称与类名完全一样，并不固定。所以构造器引用使用类名称::new的格式表示
先封装 Person 类
package cn_lemon;
public class Person {
private String name;
public Person(String name){
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
然后用来创建 Person 对象的函数式接口 Jiekou.java
package cn_lemon;
@FunctionalInterface
public interface Jiekou {
Person buder(String name);
}
如果使用函数式接口，则
package cn_lemon;
public class Demo {
public static void printName(String name, Jiekou jk) {
System.out.println(jk.buider(name).getName());
}
public static void main(String[] args){
printName("马云", n -> new Person(n));//Lambda 表达式的写法
//printName("马云", Person::new);//通过构造器引用的写法
}
}
八、数组的构造器引用
数组也是Object的子类对象，所以同样具有构造器，只是语法稍有不同。如果对应到Lambda的使用场景中时，需要一个函数式接口：
package cn_lemon;
@FunctionalInterface
public interface Jiekou {
int[] arr(int length);
}
应用该接口，创建 Demo.java
package cn_lemon;
public class Demo {
private static int[] intarr(int length, Jiekou jk){
return jk.arr(length);
}
public static void main(String[] args){
//通过 Lambda 表达式应用该接口
//int[] array = intarr(10, length -> new int[length]);
//使用数组的构造器引用该接口
int[] array = intarr(10, int[] :: new);
}
}