Java Lambda表达式疑问：为何需引用方法名，不能直接调用add1(7)？

Hey Jeff, these are really solid questions that get to the heart of how Java's Lambda expressions and method references work under the hood. Let’s break them down one by one:

1. Why do we have to reference a method name explicitly? #

Java is a statically typed language, so every expression’s type needs to be clear at compile time. Method references are just syntactic sugar for Lambda expressions, but they still rely on Java’s type system to bind to a functional interface’s abstract method.

Here’s the key point: even if a class only has one method that matches the functional interface’s signature, Java requires you to specify the method name for two main reasons:

• Overload resolution: If the class had multiple methods with the same parameter/return type signature (overloaded methods), the compiler wouldn’t know which one you intended to reference. For example:

  class Calculator {
      public static int add(int a, int b) { return a + b; }
      public static int multiply(int a, int b) { return a * b; }
  }
  

  When assigning to a BiFunction<Integer, Integer, Integer>, you have to write Calculator::add or Calculator::multiply—the compiler can’t guess which you mean.
• Explicit intent: Even with a single matching method, Java enforces explicit method references to avoid ambiguity and make your code more readable. The compiler needs a concrete method to link to the functional interface’s abstract method, and naming it directly removes any guesswork.

2. Why can’t I call add1(7) directly when there’s only one callable method? #

Let’s use a concrete example to clarify this. Suppose you have:

@FunctionalInterface
interface MyMathOperation {
    int compute(int num);
}

// Assign a Lambda to the functional interface variable
MyMathOperation add1 = x -> x + 1;

The variable add1 is not a method—it’s an instance of the MyMathOperation interface. Java doesn’t treat functions as first-class citizens (unlike languages like JavaScript or Python), so Lambda expressions and method references are just ways to create instances of functional interfaces.

Even though MyMathOperation only has one abstract method (compute), you still need to call that method explicitly:

int result = add1.compute(7); // This works
// add1(7); // This doesn't—Java doesn't allow calling interface instances like methods

The reason is simple: the variable’s type is the interface, not a method. Java’s syntax requires you to invoke the interface’s defined method name to execute the Lambda’s logic. The fact that there’s only one method doesn’t change the variable’s type or how Java handles method calls on objects/interfaces.

内容的提问来源于stack exchange，提问作者Jeff