In a Java lambda versus an anonymous inner class, what does the `this` keyword refer to, and why does it differ?

## Terms first - **Lambda expression**: a compact way to write an instance of a *functional interface* (an interface with one abstract method), e.g. `Runnable r = () -> System.out.println("hi");`. - **Anonymous inner class**: a class with no name, declared and instantiated in one expression, e.g. `Runnable r = new Runnable() { public void run() { System.out.println("hi"); } };`. - **`this` keyword**: a reference to 'the current object'. Which object that is depends on *what scope* the code belongs to. - **Lexical (static) scoping**: name meaning is decided by *where the code is written* in the source, not by what object is running it. ## The core difference An **anonymous class creates a brand-new class and a brand-new object**. That object has its own identity, so `this` inside it points to *that anonymous instance*. If the anonymous class is defined inside a class `Outer`, and you want the surrounding `Outer` object, you must write the *qualified* form `Outer.this`. A **lambda does NOT create a new scope for `this`**. The Java Language Specification treats the body of a lambda as if it were just more code in the enclosing method. So `this`, `super`, field names, and method names inside a lambda mean exactly what they would mean *on the line just before the lambda*. There is no separate lambda object whose `this` you could grab. ```java class Outer { Runnable lambda = () -> System.out.println(this); // 'this' = the Outer instance Runnable anonymous = new Runnable() { public void run() { System.out.println(this); } // 'this' = the anonymous instance // to reach Outer here you'd write Outer.this }; } ``` ## Why it matters in practice 1. **Calling enclosing methods**: inside a lambda you can call `someEnclosingMethod()` directly and it resolves to the outer class — no qualification. Inside an anonymous class, an unqualified call could accidentally bind to a method the anonymous class itself declares. 2. **Name shadowing**: an anonymous class may declare a local variable or parameter named the same as an enclosing field and *shadow* it; a lambda's parameters must NOT clash with local variables already in scope (the compiler rejects it), precisely because the lambda shares the enclosing scope rather than opening a fresh one. 3. **Listeners / callbacks**: a common bug is writing `this` inside an anonymous `ActionListener` expecting the enclosing component but getting the listener object instead. Converting it to a lambda 'just works' because `this` now means the enclosing object. ## Summary mental model - Anonymous class = *a new object* → `this` is the new object; reach outer with `Outer.this`. - Lambda = *inline code spliced into the method* → `this` is the enclosing object; no new scope, no shadowing of the enclosing scope.