Can a lambda access members of its target functional interface?

Question

I have created a simple interface using java8. In that it contains one method and one default method.

interface Lambda{

default void dummy(){
    System.out         


        

Answer 1

If I understand it correctly. You are trying to call a default method in an interface through lambda implementation. I think it can be done.

@FunctionalInterface
interface Value 
{
    String init(Value a);


    default String add(String b) 
    {
        return "added content "+b;
    }


    default String getResult()
    {
        String c = init(this);
        return c;
    }
}

public class Main
{


    public static void main(String[] args)
    {

        Value v = a -> a.add("inpout"); // here I am calling add method in Value interface.
        String c = v.getResult();

        System.out.println(c);

    }
}

Answer 2

It can't be done.

JLS 15.27.2 addresses this:

Unlike code appearing in anonymous class declarations, the meaning of names and the this and super keywords appearing in a lambda body, along with the accessibility of referenced declarations, are the same as in the surrounding context (except that lambda parameters introduce new names).

The transparency of this (both explicit and implicit) in the body of a lambda expression - that is, treating it the same as in the surrounding context - allows more flexibility for implementations, and prevents the meaning of unqualified names in the body from being dependent on overload resolution.

Practically speaking, it is unusual for a lambda expression to need to talk about itself (either to call itself recursively or to invoke its other methods), while it is more common to want to use names to refer to things in the enclosing class that would otherwise be shadowed (this, toString()). If it is necessary for a lambda expression to refer to itself (as if via this), a method reference or an anonymous inner class should be used instead.

Answer 3

The inner class implementation works since the code is called as if you coded:

check.activate(new Lambda() {
  @Override
  public void yummy() {
    this.dummy();
  }
});

Our problem now is that lambdas do not introduce a new scope. So, if you want your lambda to be able to reference itself, you may refine your @FunctionalInterface so that its functional method accepts itself and its required parameters:

check.activate(this_ -> this_.dummy());

where Lambda is defined as:

@FunctionalInterface
public interface Lambda {
  void yummy(Lambda this_);

  default void yummy() {
    yummy(this);
  }

  default void dummy(){
    System.out.println("Call this..");
  }
}