 <p>As it was <a href="http://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.27.4" rel="nofollow">already pointed out</a>, the actual behavior is not specified by the JLS, a future version is allowed to derive from the current implementation as long as the JLS remains fullfilled.</p> <p><strong>Here is what happens in a current version of HotSpot:</strong></p> <p>Any lambda expression is bound via an <em>invokedynamic</em> call site. This call site requests a bootstrap method to bind a factory for an instance that implements the functional interface of the lambda expression. As arguments, any variables that are required to execute the lambda expression are handed to the factory. The body of the lambda expression is instead copied into a method inside of the class. </p> <p>For your example, the desuggared version would look like the following code snipped with the <em>invokedynamic</em> instruction in angle brackets:</p> <pre><code>class Foo { public static Object o = new Object(); public static Callable x1() { Object x = o; return Bootstrap.&lt;makeCallable&gt;(x); } private static Object lambda$x1(Object x) { return x; } public static Callable x2() { return Bootstrap.&lt;makeCallable&gt;(); } private static void lambda$x2() { return Foo.o; } } </code></pre> <p>The boostrap method (which is actually located in <code>java.lang.invoke.LambdaMetafactory</code>) is then asked to bind the call site on its first invocation. For lambda expressions, this binding will never change, the bootstrap method is therefore only called once. In order to being able to bind a class that implements the functional interface, the bootstrap method must first create a class at runtime which look like the following for example:</p> <pre><code>class Lambda$x1 implements Callable { private static Callable make(Object x) { return new Lambda$x1(x); } private final Object x; // constructor omitted @Override public Object call() { return x; } } class Lambda$x2 implements Callable { @Override public Object call() { return Foo.o; } } </code></pre> <p>After creating these classes, the <em>invokedynamic</em> instruction is bound to invoke the factory method that is defined by the first class to the call site. For the second class, no factory is created as the class is fully stateless. Therefore, the bootstrap method creates a singleton instance of the class and binds the instance directly to the call site (using a constant <code>MethodHandle</code>).</p> <p>In order to invoke static methods from another class, an anonymous class loader is used for loading the lambda classes. If you want to know more, I recently <a href="http://mydailyjava.blogspot.no/2015/03/dismantling-invokedynamic.html" rel="nofollow">summarized my findings on lambda expressions</a>. </p> <p>But again, <strong>always code against the spec, not the implementation</strong>. This can change!</p>