Java新特性05 方法引用

一. 定义

方法引用是用来直接访问类或者实例的已经存在的方法或者构造方法。

方法引用是Lambda表达式的一种简写形式；

如果Lambda表达式只是调用一个特定的已经存在的方法，则可以使用方法引用；

如果你觉得Lambda的方法体会很长，影响代码的可读性，则可以用方法引用来解决。

二. 语法

使用 :: 操作符将方法名与对象或类的名字分隔开。

三. 分类

（1）静态方法引用 ContainingClass::staticMethodName

（2）实例方法引用 ContainingObject::instanceMethodName

（3）一个类任意对象的实例方法引用 ContainingType::methodName

（4）构造方法引用 ClassName::new

 Note: Lambda表达式是对匿名内部类的简写，而方法引用是对Lambda表达式的简写

四. 举例

package com.test.a;

public interface Base {    
    public void f3();
}

（1）静态方法引用

package com.test.a;

public class Test {
    public static void f3() {
        System.out.println("hello");
    }

    public static void main(String args[]) {
        //1. 匿名内部类的实现方式
//        Base base = new Base() {
//            @Override
//            public void f3() {
//                System.out.println("hello");
//            }
//        };
//        base.f3();//print "hello"
        
//        //2.Lambda表达式的实现方式
//        Base base2=()->{System.out.println("hello");};
//        base2.f3();//print "hello"
        
        //3.实例方法引用的实现方式
        Test test=new Test();
        Base base3=Test::f3;
        base3.f3();//print "hello"
        
        
    }
}

（2）实例方法引用

package com.test.a;

public class Test {
    public void f3() {
        System.out.println("hello");
    }

    public static void main(String args[]) {
        //1. 匿名内部类的实现方式
//        Base base = new Base() {
//            @Override
//            public void f3() {
//                System.out.println("hello");
//            }
//        };
//        base.f3();//print "hello"
        
//        //2.Lambda表达式的实现方式
//        Base base2=()->{System.out.println("hello");};
//        base2.f3();//print "hello"
        
        //3.实例方法引用的实现方式
        Test test=new Test();
        Base base3=test::f3;
        base3.f3();//print "hello"
        
        
    }
}

Note:这个Lambda内部表达式f3方法已经有一个具体的实现方法了，因此直接引用就可以了。

（3）一个类任意对象的实例方法引用

package com.test.a;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

public class Test {
    public static void main(String args[]) {
        List<String> list=new ArrayList<>();
        list.add("d");
        list.add("a");
        list.add("c");
        list.add("b");
        
//        Collections.sort(list, new Comparator<String>() {
//
//            @Override
//            public int compare(String o1, String o2) {
//                // TODO Auto-generated method stub
//                return o1.compareTo(o2);
//            }
//        });
        
//        Collections.sort(list, (o1,o2)->{return o1.compareTo(o2);});
        
        //简化Lambda，那么我们必须有一个compareTo方法的具体实现的一个方法，发现String类已经有compareTo的具体实现了，可以直接用
        Collections.sort(list, String::compareTo);
        
        for(String s:list) {
            System.out.println(s);
        }
        
    }
}

（4）构造方法引用

package com.test.a;

public class Person {
    public String name;
    public int age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

package com.test.a;

import java.util.function.Supplier;

public class Test {
    public static void main(String args[]) {
        Supplier<Person> supplier=()->new Person();
        Person person=supplier.get();
        System.out.println(person);
        
        Supplier<Person> supplier2=Person::new;
        Person person2=supplier2.get();
        System.out.println(person2);
    }
}

com.test.a.Person@65ab7765
com.test.a.Person@7229724f

 或者自定义：

package com.test.a;

@FunctionalInterface
public interface MyFunction<T> {

    public abstract T f(int age,String name);
}

public class Test {
    
    public static void main(String args[]) {
        MyFunction<Person> myFunction=Person::new;
        Person person=myFunction.f(23, "tom");
        System.out.println(person.getName());
    }
}


tom