21.java的::方法引用的总结。

2023-12-26 14:40:47

注意:方法引用返回的是一个函数式接口对象(该函数式接口抽象方法被引用方法替代了,调用抽象方法实际上就是调用引用的方法)。?

比如:Function<String, String> function = String::toUpperCase;

Java 中的双冒号(::)用于方法引用,它可以简化 Lambda 表达式的书写。总结一下双冒号的使用情况,并举例说明:

  1. 静态方法引用:类名::静态方法名

    • 用于引用类的静态方法。

    示例:

    // 定义一个函数式接口
    interface MathOperation {
        int operation(int a, int b);
    }
    
    // 定义一个静态方法
    static int add(int a, int b) {
        return a + b;
    }
    
    public static void main(String[] args) {
        // 使用静态方法引用
        MathOperation operation = Math::add;
        int result = operation.operation(10, 5);  // 调用静态方法
        System.out.println(result);  // 输出:15
    }
    
  2. 实例方法引用:对象::实例方法名

    • 用于引用对象的实例方法。

    示例:

    // 定义一个函数式接口
    interface StringLength {
        int getLength(String str);
    }
    
    public static void main(String[] args) {
        StringLength length = String::length;  // 使用实例方法引用
        int len = length.getLength("Hello");  // 调用实例方法
        System.out.println(len);  // 输出:5
    }
    
  3. 类名引用普通方法:类名::方法名

    • 用于引用类的普通方法(非静态方法)。
    • 可以认为是底层new了一个该类名的对象,然后引用该实例方法。

    示例:

    // 定义一个函数式接口
    interface StringFormatter {
        String format(String str);
    }
    
    // 定义一个普通方法
    String toUpperCase(String str) {
        return str.toUpperCase();
    }
    
    public static void main(String[] args) {
        StringFormatter formatter = String::toUpperCase;  // 使用类名引用普通方法
        String result = formatter.format("hello");  // 调用普通方法
        System.out.println(result);  // 输出:HELLO
    }
    
  4. 构造函数引用:类名::new

    • 用于引用类的构造函数。
    • 类名::new出来的是一个函数式接口对象。因为Person的构造方法参数与PersonFactory接口的create方法参数类型和返回值是一样的,所以create的实例方法已经变成了Person类的构造方法,所以该函数式接口已经被实现了。

    示例:

    // 定义一个函数式接口
    interface PersonFactory {
        Person create(String name, int age);
    }
    
    class Person {
        private String name;
        private int age;
        
        public Person(String name, int age) {
            this.name = name;
            this.age = age;
        }
    }
    
    public static void main(String[] args) {
        PersonFactory factory = Person::new;  // 使用构造函数引用
        Person person = factory.create("Alice", 25);  // 调用构造函数
        System.out.println(person.getName());  // 输出:Alice
        System.out.println(person.getAge());  // 输出:25
    }
    

双冒号(::)可以提高代码的可读性和简洁性,特别适用于函数式编程和集合操作等场景。

方法引用?::可以认为是代替了一部分的lambda表达式,都是为函数式接口服务。

解析:

函数式接口:?

@FunctionalInterface
public interface AFactory<T> {
    T getObject(String a);
}

String类(我自己瞎写的):

public class String{
    T toT(String s){
        ....
    }
}

lambda表达式:

(s)-> {

? ? ? ? return a.toT(s);

}

方法引用:

String::toT

总结:

1.可以看出方法引用跟函数式接口的返回值和方法参数一样。

2.跟lambda表达式相比,不用标明方法参数,因为会调用跟函数式接口方法参数和返回值一样的方法。也不用实现,因为引用的方法就是实现。

文章来源:https://blog.csdn.net/khmff/article/details/135219484
本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。