Java 8 Lambda in details part V : Functional interface definition and lambda expression implementation

In this last post we’ll look at the functional interface formal definition and the way lambda expressions are implemented.

DISCLAIMER: all the details exposed in this post were observed related to the JDK 8 demo version as of July 10th 2012. Since the JDK is still in beta, some assertions may not hold in future

Please note that all the example code in this post can be found on my GitHub repository


I Functional interface definition

It seems weird to give a definition of a functional interface (aka SAM interface) in the last post but the truth is that I discover the subtle semantic of functional interface only recently.

Usually people naively think that a functional interface must contain only one single abstract method. The real definition is less restrictive indeed.

An interface is considered a functional interface if it contains one and only one abstract method with no default implementation

No assertion is made about the possibility for this interface to declare static fields or many defenders methods. It means that a functional interface can

  1. have one abstract method and many defenders methods and static fields
  2. have one abstract method and inherit defenders from parent interfaces and static fields

The implication of these subtle details is huge indeed. We can have lambda expressions with default behaviors embedded (via defender methods)!

The code example in the next chapter will prove it.


II Lambda expression implementation

Did you ever wonder how the JDK 8 implements an lambda expression ? The following article gives us some insights.

Basically, the compiler will create anonymous inner classes to emulate the functioning of lambda expressions. Two possible scenarios there:

  1. the lambda expression is stateless and does not capture any variable: an anonymous inner class is created with a no argument constructor
  2. the lambda expression does capture variables (this or local variable): they are injected through anonymous inner class constructor as parameters

Let consider the following sample:

public interface SAMWithDefender
	String staticvar = "static var in SAM";
	void test();
	void whoAmI() default 
		System.out.println("I am "+this);

public class LambdaInstance

	public static SAMWithDefender createLambda()
		return () -> {System.out.println("");};

	public static SAMWithDefender createStatefullLambda(String input)
		return () -> {System.out.println("input = "+input);};

	public static void main(String[] args)
		SAMWithDefender samInstance1 = LambdaInstance.createLambda();
		SAMWithDefender samInstance2 = LambdaInstance.createStatefullLambda("statefull");


We define an interface with a static field and 2 methods. One of them is provided a default implementation, the other is let abstract (line 5). This interface meets the requirement to be a functional interface (one single abstract method) as mentioned in the previous chapter.

In the main class, we define 2 lambda expressions, one stateless (line 28) and one capturing local variable (line 29).

I compile the class and use the “javap -verbose” command to examine the generated bytecode.

Definition of fr.doan.lambda.instance.LambdaInstance class:

  public fr.doan.lambda.instance.LambdaInstance();
    flags: ACC_PUBLIC
      stack=1, locals=1, args_size=1
         0: aload_0
         1: invokespecial #1                  // Method java/lang/Object."<init>":()V
         4: return
        line 5: 0

  public static fr.doan.lambda.sam.instance.SAMWithDefender createLambda();
      stack=2, locals=0, args_size=0
         0: new           #2                  // class fr/doan/lambda/instance/LambdaInstance$1
         3: dup
         4: invokespecial #3                  // Method fr/doan/lambda/instance/LambdaInstance$1."<init>":()V
         7: areturn
        line 10: 0

  public static fr.doan.lambda.sam.instance.SAMWithDefender createStatefullLambda(java.lang.String);
      stack=3, locals=1, args_size=1
         0: new           #4                  // class fr/doan/lambda/instance/LambdaInstance$2
         3: dup
         4: aload_0
         5: invokespecial #5                  // Method fr/doan/lambda/instance/LambdaInstance$2."<init>":(Ljava/lang/String;)V
         8: areturn
        line 15: 0 

At lines 16 & 18, the static method createLambda() is instanciating a new anonymous inner class “fr/doan/lambda/instance/LambdaInstance$1” with no argument constructor.

At lines 27 & 30, the static method createStatefullLambda() is instanciating a new anonymous inner class “fr/doan/lambda/instance/LambdaInstance$2” with the captured method parameter as constructor argument.

Let’s decompile the anonymous inner class “fr/doan/lambda/instance/LambdaInstance$2

class fr.doan.lambda.instance.LambdaInstance$2 implements fr.doan.lambda.sam.instance.SAMWithDefender
  SourceFile: ""
  EnclosingMethod: #24.#25                // fr.doan.lambda.instance.LambdaInstance.createStatefullLambda
  InnerClasses:   static #10; //class fr/doan/lambda/instance/LambdaInstance$2
  java.lang.String cap$0;
    flags: ACC_SYNTHETIC

      stack=2, locals=2, args_size=2
         0: aload_0
         1: invokespecial #1                  // Method java/lang/Object."<init>":()V
         4: aload_0
         5: aload_1
         6: putfield      #2                  // Field cap$0:Ljava/lang/String;
         9: return
        line 15: 0

We clearly see at lines 7-8 that the compiler generated a synthetic field cap$0 (capture0) to capture the local variable and passed it to the constructor argument (line 10)

When executing the LambdaInstance class, the output shows:

I am fr.doan.lambda.instance.LambdaInstance$1@59dbd

I am fr.doan.lambda.instance.LambdaInstance$2@b6e768

That’s all folks!


The above scenario can be illustrated by a code example on GitHub at Just execute the LambdaInstance.bat( script



About DuyHai DOAN
Cassandra Technical Evangelist. LinkedIn profile : Follow me on Twitter: @doanduyhai for latest updates on Cassandra

5 Responses to Java 8 Lambda in details part V : Functional interface definition and lambda expression implementation

  1. Hey, really a detailed and interesting set of articles.
    please visit where i have put a detailed explanations of Java Closures with working examples.

  2. Hmm is anyone else having problems with the pictures on this blog loading?
    I’m trying to determine if its a problem on my end or if it’s the blog.

    Any suggestions would be greatly appreciated.

  3. I’m now not sure the place you’re getting your
    info, however good topic. I needs to spend a while studying more or understanding more.
    Thank you for excellent information I used to be searching for this
    info for my mission.

  4. We stumbled over here from a different website and thought I might as
    well check things out. I like what I see so i am just following you.

    Look forward tto going over your web page for a second time.

  5. Anurag Singh says:

    This article is really well explained and it is very useful for learning java 8 features.
    thanks for this nice article.

Leave a Reply

Fill in your details below or click an icon to log in: Logo

You are commenting using your account. Log Out /  Change )

Google+ photo

You are commenting using your Google+ account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )


Connecting to %s

%d bloggers like this: