java方法引用怎么用(java怎么引用函数)

什么是Java方法引用？

Java方法引用是一种新的语言特性，它可以让你在Lambda表达式中直接引用一个方法，无需再次定义特定的Lambda表达式。它是一种更加简洁、优雅的实现方式，并且可以让代码更加易于理解，减少冗余代码的编写。

如何使用Java方法引用？

Java方法引用的使用步骤非常简单。首先，你需要有一个方法可以被引用，并且你需要定义一个函数式接口。接下来，你可以在Lambda表达式中添加一个“::”的操作符，然后添加需要引用的方法名。最后，你可以传递这个Lambda表达式给函数式接口。接下来我们来看一个例子：

//定义一个函数式接口
interface MethodInterface {
    void printHello();
}

//定义一个可以被引用的方法
public class methodReference {
    public static void printMethod() {
        System.out.println("Hello World!");
    }

    public static void main(String[] args) {
        //使用方法引用来传递Lambda表达式
        MethodInterface methodInterface = methodReference::printMethod;
        methodInterface.printHello();
    }
}

在这个例子中，我们首先定义了一个函数式接口MethodInterface和一个可以被引用的方法printMethod。然后我们使用方法引用的语法，将printMethod方法引用传递给MethodInterface。接下来，我们调用printHello方法，就会直接调用printMethod方法。

Java方法引用的四种使用方式

Java方法引用有四种使用方式：

• 类名::静态方法
• 引用名::实例方法
• 类名::实例方法
• 类名::new

我们来一一讲解一下：

1. 类名::静态方法：这种方式用来引用静态方法。

//定义一个函数式接口
interface StaticMethodInterface {
    int getMax(int a, int b);
}

public class methodReference {
    //定义一个静态方法
    public static int max(int a, int b) {
        return a > b ? a : b;
    }

    public static void main(String[] args) {
        StaticMethodInterface staticMethodInterface = methodReference::max;
        System.out.println(staticMethodInterface.getMax(2, 5));
    }
}

2. 引用名::实例方法：用来引用该对象的任意实例方法。需要注意的是，这个方法的参数类型需要与定义Lambda表达式的函数式接口中的参数类型保持一致。

//定义一个函数式接口
interface InstanceMethodInterface {
    int getLength(String str);
}

public class methodReference {
    public static void main(String[] args) {
        String str = "Hello World!";
        InstanceMethodInterface instanceMethodInterface = str::length;
        System.out.println(instanceMethodInterface.getLength(str));
    }
}

3. 类名::实例方法：这种方式与第二种方式类似，只是该方法的参数列表的第一个参数是实例方法的调用者。

//定义一个函数式接口
interface ClassInstanceMethodInterface {
    boolean isContain(String str, CharSequence cs);
}

public class methodReference {
    public static void main(String[] args) {
        String str = "Hello World!";
        ClassInstanceMethodInterface classInstanceMethodInterface = String::contains;
        System.out.println(classInstanceMethodInterface.isContain(str, "World"));
    }
}

4. 类名::new：这种方式用来引用构造器，并且要求与定义Lambda表达式的函数式接口兼容。

//定义一个函数式接口
interface NewInterface {
    HelloWorldInterface sayHelloWorld(String msg);
}

//定义一个接口
interface HelloWorldInterface {
    void sayHelloWorld();
}

public class methodReference {
    public static void main(String[] args) {
        //使用方法引用引用构造器
        NewInterface newInterface = HelloWorld::new;
        HelloWorldInterface helloWorldInterface = newInterface.sayHelloWorld("Hello World!");
        helloWorldInterface.sayHelloWorld();
    }
}

class HelloWorld implements HelloWorldInterface {
    private String msg;

    public HelloWorld(String msg) {
        this.msg = msg;
    }

    @Override
    public void sayHelloWorld() {
        System.out.println(msg);
    }
}

在这个例子中，我们定义了一个函数式接口NewInterface和一个接口HelloWorldInterface和一个实现HelloWorldInterface的HelloWorld类。然后我们使用方法引用引用构造器，将NewInterface和HelloWorld连接起来，从而也就实现了对于构造器的引用。