Inside an anonymous class, what does `this` refer to, and how do you reach the enclosing instance? How does this differ from a lambda?

## `this` is about the *current object* `this` always means 'the object whose method is currently executing.' An anonymous class and a local class each define a **new class**, and when you call a method on an instance of that class, `this` inside the method is **that inner instance** — distinct from the object of the method that created it. ```java class Outer { int x = 10; Runnable make() { return new Runnable() { int x = 20; // shadows Outer.x @Override public void run() { System.out.println(x); // 20 -> the anonymous instance's field System.out.println(this.x); // 20 -> `this` is the anonymous instance System.out.println(Outer.this.x); // 10 -> the enclosing instance } }; } } ``` ## Reaching the enclosing instance: `Outer.this` A non-static local or anonymous class holds a hidden reference to the **enclosing instance** (the object whose method created it). You access it with the **qualified this** syntax `EnclosingClassName.this`. This is necessary whenever a name inside the inner class **shadows** (hides) an enclosing name, or whenever you simply want to pass the outer object somewhere (`someApi.register(Outer.this)`). ## Shadowing Because the inner class is its own scope, a field or method declared inside it with the same name as one in the enclosing class **shadows** the outer one for unqualified references. Unqualified `x` resolves to the nearest enclosing scope that declares `x` — the inner class first. To pierce the shadow you qualify: `Outer.this.x`. Captured *local* variables can't be shadowed-then-reached the same way, since you can't have two locals of the same name in scope. ## Lambdas: no `this` of their own A **lambda expression** is deliberately *not* a new scope for `this`. The Java Language Specification says a lambda's body sees `this`, `super`, and simple names exactly as the **enclosing context** does. So inside a lambda: ```java class Outer { int x = 10; Runnable make() { return () -> { System.out.println(this.x); // 10 -> `this` is the Outer instance System.out.println(x); // 10 -> same }; } } ``` There is **no** `Outer.this` distinction inside a lambda, because there is only one `this` — the enclosing one. This is sometimes called 'lexical `this`'. ## Why the difference matters in practice 1. **Refactoring hazard.** Turning an anonymous class into a lambda (or vice versa) changes the meaning of `this`. A listener written as `new Listener() { void on() { source.remove(this); } }` removes the *listener* object; the lambda form `e -> source.remove(this)` would try to remove the *enclosing* object — a bug. 2. **Self-reference.** Only an anonymous/local class can refer to *itself* via `this` (to deregister, store itself, etc.). A lambda cannot reference itself with `this`; you'd need a named field. 3. **Debugging / class files.** Each anonymous class compiles to `Outer$1.class`, `Outer$2.class`, … and shows up as such in stack traces; lambdas appear as synthetic methods (`lambda$make$0`). Named local classes give the most readable stack traces. ## Local classes follow the anonymous rules A named local class behaves like the anonymous case for `this`: `this` is the local-class instance, `Outer.this` reaches the enclosing instance, and names can shadow. The only difference is that the local class has a name (so it can be instantiated multiple times and have constructors).