【Java】方法引用

方法引用

概念

把已有的方法拿过来用，当作函数式接口中抽象方法的方法体

• 函数式接口

  函数式接口（Functional Interface）是指只包含一个抽象方法的接口。在Java编程语言中，函数式接口是支持函数式编程的关键。函数式编程是一种编程范式，它将计算视为数学函数的求值，并避免改变状态和可变数据。Java 8引入了Lambda表达式和函数式接口，以支持函数式编程的特性。

  在函数式接口中，只能有一个抽象方法，但可以有多个默认方法（带有默认实现的方法）或静态方法。这种设计允许在使用Lambda表达式时，将接口实例化为一个函数对象。

  函数式接口的定义要求使用**@FunctionalInterface**注解，这样在编译时能够确保接口只包含一个抽象方法。以下是一个简单的函数式接口示例：

  javaCopy code
  @FunctionalInterface
  interface MyFunctionalInterface {
      // 抽象方法
      void myAbstractMethod();
  
      // 默认方法
      default void myDefaultMethod() {
          System.out.println("Default method implementation");
      }
  
      // 静态方法
      static void myStaticMethod() {
          System.out.println("Static method implementation");
      }
  }
  
  

  在上述示例中，MyFunctionalInterface是一个函数式接口，它包含一个抽象方法myAbstractMethod，以及一个默认方法和一个静态方法。

  通过使用Lambda表达式，可以轻松地实例化这样的函数式接口：

  javaCopy code
  public class Main {
      public static void main(String[] args) {
          MyFunctionalInterface myFunctionalInterface = () -> {
              System.out.println("Lambda expression implementation");
          };
  
          myFunctionalInterface.myAbstractMethod();
          myFunctionalInterface.myDefaultMethod();
          MyFunctionalInterface.myStaticMethod();
      }
  }
  
  

  这里，Lambda表达式用于实现函数式接口的抽象方法，从而创建一个可以通过接口引用进行调用的函数对象。

1. 引用处必须是函数式接口

public static void main(String[] args) {
		Integer[] arr=new Integer[10];
		Arrays.sort(arr, new Comparator<Integer>() {
			@Override
			public int compare(Integer o1, Integer o2) {
				return 0;
			}
		});

1. 被引用的方法必须已经存在
2. 被引用的方法的形参和返回值需要跟抽象方法保持一致
3. 被引用方法的功能要满足当前的需求

public int subtraction(int n1,int n2){
		return n2-n1;
	}

引用后：

Arrays.sort(arr,new DemoApplication()::subtraction);

• 引用静态方法

格式：类名::静态方法

• 引用成员方法

格式：对象::成员方法

1. 其他类：其他类对象::方法名
2. 本类：this::方法名
3. 父类：super::方法名

静态类中没有this，在静态类中引用本类方法就只能通过创建类的对象来引用

• 引用数组的构造方法

格式：数据类型[]::new

• 使用类名引用成员方法

格式：类名::成员方法

第一个参数：表示被引用方法的调用者，决定了可以引用哪些类中的方法，第一个参数一般表示这里面的每一个数据。假设流里面的数据是字符串，那么使用这种方式进行方法引用，只能引用String这个类中的方法
第二个参数到最后一个参数：跟被引用方法的形参保持一致
通常是优先使用引用成员方法的形式，如果形参不符合，不是完全一致，则考虑使用该方法

代码示例

1. 静态方法引用

静态方法引用形式为 类名::静态方法，它适用于已经存在的、无需实例化的方法。以下是一个简单的例子：

// 定义一个接口
interface Calculator {
    int add(int a, int b);
}

// 定义一个工具类
class MathUtil {
    static int staticAdd(int a, int b) {
        return a + b;
    }
}

public class Main {
    public static void main(String[] args) {
        // 使用静态方法引用
        Calculator calculator = MathUtil::staticAdd;

        // 调用方法
        int result = calculator.add(3, 7);
        System.out.println("Result: " + result);
    }
}

在这个例子中，Calculator 接口有一个抽象方法 add，我们使用了静态方法引用 MathUtil::staticAdd 来实现该抽象方法。这使得我们可以通过 calculator.add(3, 7) 调用 MathUtil.staticAdd(3, 7)。

2. 实例方法引用

实例方法引用形式为 实例::实例方法，它适用于已经存在的、需要实例化的方法。以下是一个示例：

// 定义一个接口
interface Printer {
    void print(String message);
}

// 定义一个实例类
class MessagePrinter {
    void printMessage(String message) {
        System.out.println(message);
    }
}

public class Main {
    public static void main(String[] args) {
        // 使用实例方法引用
        MessagePrinter messagePrinter = new MessagePrinter();
        Printer printer = messagePrinter::printMessage;

        // 调用方法
        printer.print("Hello, Method Reference!");
    }
}

在这个例子中，Printer 接口有一个抽象方法 print，我们使用了实例方法引用 messagePrinter::printMessage 来实现该抽象方法。这使得我们可以通过 printer.print("Hello, Method Reference!") 调用 messagePrinter.printMessage("Hello, Method Reference!")。

3. 特定类的任意对象的方法引用

特定类的任意对象的方法引用形式为 类名::实例方法，它适用于已经存在的、需要实例化的方法。以下是一个示例：

// 定义一个接口
interface Greeter {
    void greet(String name);
}

// 定义一个实例类
class GreetingService {
    private String prefix;

    GreetingService(String prefix) {
        this.prefix = prefix;
    }

    void greetPerson(String name) {
        System.out.println(prefix + " " + name);
    }
}

public class Main {
    public static void main(String[] args) {
        // 使用特定类的任意对象的方法引用
        GreetingService englishGreeting = new GreetingService("Hello");
        GreetingService frenchGreeting = new GreetingService("Bonjour");

        Greeter englishGreeter = englishGreeting::greetPerson;
        Greeter frenchGreeter = frenchGreeting::greetPerson;

        // 调用方法
        englishGreeter.greet("John");
        frenchGreeter.greet("Alice");
    }
}

在这个例子中，Greeter 接口有一个抽象方法 greet