Java Lambda vs Method Reference - One does not receive the local vars of the caller

Question

Trying to refactor from a lambda to a method reference I realized that there seems to be a difference in method references not getting the local variables of the caller (the lexical scope?). When using a lambda as its inline code there isn't problem at all.

public class MethodRef {

  public static void main(String[] args) {
    String appender = "I am appended";

    //possible
    appender("Hello! ", former ->  {
      StringBuilder builder = new StringBuilder(former);
      builder.append(appender);
      System.out.println(builder.toString());
    });

    //not possible
    appender("Hello! ", this::theRef);
  }

  //Delegater
  public static void appender(String former, Consumer<String> consumer){
      consumer.accept(former);
  }

  //Method Ref
  public void theRef(String former){
    StringBuilder builder = new StringBuilder(former);
    builder.append(appender);
    System.out.println(builder.toString());
  }
}

I understand the fact that the param list of the method does not yield any "appender" but isn't there a "hidden" param I can use to access the lexical vars of the caller/consumer scope?

You are trying to access a member method from a static context. Try changing `theRef` method signature to `public static void theRef(String former)` and then use `MethodRef::theRef` instead of `this::theRef`. See [Reference to a Static Method](https://docs.oracle.com/javase/tutorial/java/javaOO/methodreferences.html) in oracle documentation. — Jezor, Jun 22 '16 at 12:50

score 2 · Accepted Answer · answered Jun 22 '16 at 12:51

No, this is not possible.

The lexical scope is resolved during the compile time. The method is written in generic way and can be technically called from anywhere. Therefore compiler cannot guess the lexical scope of all potential calls.

The only way, if you want to maintain separate method, is to wrap the call into wrapping lambda and pass the local variable as a parameter. But I assume this wasn't original goal.

score 1 · Answer 2 · answered Jun 22 '16 at 12:54

No, you can't create a regular method that has access to local variables outside of the method.

The name of lambdas keeping copies of local variables from the scope in which it is defined is closure.

The only other way that I know of using closures in Java is anonymous inner classes.

Java Lambda vs Method Reference - One does not receive the local vars of the caller

2 Answers2