方法引用

Lambda表达式中，提供了特殊的语法，能让我们直接引用已经存在的方法，作为当前要表示的函数，例如

public class Test {
    public static void main(String[] args) {
        //通过lambda表达式表示一个函数，这个函数作为run方法的具体实现
        Action a1 = () -> System.out.println("hello!");

        //方法引用：被引用的Student类中的sayHello方法作为run方法的具体实现
        Action a2 = Student::sayHello;

        //调用接口中的run()方法
        a1.run();
        a2.run();

    }
}

interface Action{
    void run();
}

class Student{
    public static void sayHello(){
        System.out.println("hello!");
    }
}

方法引用和lambda表达式一样，需要保证接口时函数式接口才可以使用。

静态方法引用

使用Lambda表达式可以引用类中的静态方法，语法要求为：

例如：

public class Test {
    public static void main(String[] args) {
        //Lambda表达式中只要参数是String类型，返回值是int类型就可以作为Action接口的具体实现
        Action a1 = str -> str.length();

        //使用静态方法引用（类名::静态方法名）来引用当前类中的静态方法len
        Action a2 = Test::len;
        
        System.out.println(a1.run("hello")); //输出5
        System.out.println(a2.run("hello")); //输出5
    }

    public static int len(String str){
        return str.length();
    }
}

interface Action{
    int run(String str);
}

实例方法引用

使用Lambda表达式可以引用类中的非静态方法，语法如下：

例如：

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

        //引用的非静态方法中没有参数
        Action a1 = String::length;
       /* 等价于：
         Action a1 = new Action() {
            @Override
            public int run(String str) {
                return str.length();
            }
        };
        */
        //引用的非静态方法中有一个参数
        Index i1 = String::indexOf;
       /* 相当于：
        Index i1 = new Index(){
            @Override
            public int run(String str, String s) {
                return str.indexOf(s);
            }
        };
        */
        System.out.println(a1.run("hello")); //输出5
        System.out.println(i1.run("hello","e")); //输出1

    }
}

interface Action{
    //该方法中只有一个参数
    int run(String str);
}
interface Index{
    //该方法中有两个参数
    int run(String str, String s);
}

对象引用方法

语法格式为：

例如：

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

        /* 匿名内部类实现
        Action a1 = new Action() {
            @Override
            public String run(String str) {
                return "ByeBye! " + str;
            }
        };
        */
        //Lambda表达式简化
        Action a1 = str -> "ByeBye! " + str;

        //对象引用方法
        MyHandler myHandler = new MyHandler();
        Action a2 = myHandler::test;
         
        System.out.println(a1.run("Tom"));;
        System.out.println(a2.run("John"));
    }
}

interface Action{
    String run(String str);
}
class MyHandler{
    public String test(String name){
        return "hello! " + name;
    }
}

构造方法引用

语法格式

无参构造器

public class Test {
    public static void main(String[] args) {
       /* 匿名内部类实现
       Action a1 = new Action() {
            @Override
            public Student run() {
                return new Student();
            }
        };
        */
        
        //Lambda表达式简化
        //Action a1 = ()->new Student();
        
        //使用Student类的无参构造函数对Action接口进行实现
        Action a1 = Student::new;
        System.out.println(a1.run());

    }
}

interface Action{
    //返回值是Student类型
    Student run();
}
class Student{

}

含参构造器

public class Test {
    public static void main(String[] args) {
       /* 匿名内部类实现
       Action a1 = new Action() {
            @Override
            public Student run(String name) {
                return new Student(name);
            }
        };
        */

        //Lambda表达式简化
        //Action a1 = name->new Student(name);

        //使用Student类的含参构造器对Action接口进行实现
        Action a1 = Student::new;
        System.out.println(a1.run("tom"));
		//输出的是student对象中的name属性值tom所在的位置
    }
}

interface Action{
    //返回值是Student类型
    Student run(String name);
}
class Student{
    private String name;
    //含参构造器
    public Student(String name){
        this.name = name;
    }
}

数组构造

使用lambda表达式可以引用数组类型的构造函数，语法要求为

例如：

public class Test {
    public static void main(String[] args) {
       /* 匿名内部类实现
       Action a1 = new Action() {
            @Override
            public Student run(int len) {
                return new int[len];
            }
        };
        */

        //Lambda表达式简化
        //Action a1 = len->new int(len);

        //使用int数组的构造函数，来对Action接口进行实现
        //int数组的构造函数恰好是和run方法的参数列表和返回类型保持一致，所以可饮用
        Action a1 = int[]::new;
        System.out.println(a1.run(5));

    }
}

interface Action{
    //返回值是数组类型
   int[] run(int len);
}