skip to content

How do you refer to the enclosing instance from inside an inner class, including when names collide? Explain OuterClass.this.

level: middleimportance: should knowfreq 58%

answer

  1. plain this = inner instance
  2. Outer.this = enclosing instance
  3. bare name walks inner -> outer -> further out
  4. shadowing forces the qualified form
  5. name the level: A.this vs B.this when deeply nested

basics

~20 s

Inside an inner class, plain field names refer to the inner object first. To reach the outer object explicitly — for example when both have a field with the same name — write OuterClass.this.field or OuterClass.this.method().

solid answer

~40 s

From inside an inner class, an unqualified name resolves by walking outward: first the inner class's own members, then the enclosing instance's members, then outer-outer, and so on. Usually you can just write `count` and it finds the outer field. But when the inner class declares a member with the same name as an outer one, the inner one shadows the outer, so the simple name no longer reaches the outer member. The qualified `this` expression `OuterClass.this` gives you an explicit handle to the enclosing instance of that named outer class, letting you write `Outer.this.count` to bypass the shadowing, or `Outer.this.render()` to call the outer method. With multiple levels of nesting you name the specific level, e.g. `Grandparent.this`. Plain `this` always means the inner instance itself.

code

java · 18 lines
java
class Outer {
    private int count = 1;

    class Inner {
        private int count = 100;   // shadows Outer.count

        void show() {
            int count = 9999;      // local, shadows the inner field
            System.out.println(count);            // 9999  (local)
            System.out.println(this.count);       // 100   (inner field)
            System.out.println(Outer.this.count); // 1     (enclosing instance)
        }
    }

    public static void main(String[] args) {
        new Outer().new Inner().show();
    }
}

go deeper

for a junior

Knows you can read outer fields from an inner class and has seen Outer.this syntax.

for a middle

Explains the inner-then-outer name lookup, what shadowing is, and uses Outer.this correctly to disambiguate.

for a senior

Handles multi-level nesting (A.this vs B.this), knows the static-context restrictions, and prefers avoiding shadowing.

for a principal

Reasons about readability/maintenance of qualified-this usage and sets conventions to keep enclosing-state access explicit and safe.

## Setup An **inner (non-static) class** is a class declared without `static` inside another class. Each inner object is permanently attached to one **enclosing (outer) instance** and may use that outer object's members. The question is: *which* object does a name refer to, and how do you be explicit? ## The two `this`-like things - **`this`** inside an inner method = the **inner** instance (the object whose method is running). - **`Outer.this`** = the **enclosing** instance — the specific outer object that this inner object belongs to. The general form is `EnclosingClassName.this`, a **qualified `this`**. ## Name resolution (the lookup walk) When you write a bare name like `count` inside an inner method, the compiler searches in order: 1. local variables / parameters of the method, 2. the **inner** class's own fields, 3. the **enclosing** instance's fields, 4. the next enclosing class out (if nesting is deeper), 5. then static/imported scopes. The first match wins. So most of the time `count` transparently finds the outer field, and you never think about it. ## Shadowing — why you need the qualified form **Shadowing** is when an inner-scope name hides an identically named outer-scope name. If the inner class has its own field `count`, then bare `count` resolves to the *inner* `count` (step 2 wins before step 3). The outer `count` is now unreachable by simple name. To reach it you must qualify: ```java Outer.this.count // the enclosing instance's field this.count // (or just count) the inner field ``` The same applies to methods: `Outer.this.render()` calls the outer class's method even if the inner class defines its own `render()`. ## Deeper nesting With `A` containing `B` containing inner `C`, from inside `C` you can write `A.this` and `B.this` to select exactly which enclosing instance you mean. Each names the class of the level you want. ## What does NOT have an enclosing `this` - A **static nested class** has no enclosing instance, so `Outer.this` is a compile error there. - A **static method** of the outer class has no `this` at all. ## Practical guidance Prefer to *avoid* shadowing by naming inner fields differently; reach for `Outer.this` when shadowing is unavoidable or when you want to make the intent ("the outer object, not me") explicit to readers.

  • Inside a static nested class, can you write `Outer.this`?
    No. A static nested class has no enclosing instance, so there is nothing for `Outer.this` to denote; it is a compile error. You would need an explicit `Outer` reference passed in instead.
  • If an inner method has a local variable, an inner field, and an outer field all named `x`, which does a bare `x` reference?
    The local variable. Lookup goes local first, then inner field, then enclosing field; the nearest scope wins, so the local shadows both fields.

saying these in an interview costs you the question

  • Believing `this` inside an inner class refers to the outer object
  • Thinking `Outer.this` works inside a static nested class or static method
  • Assuming a shadowed outer field is still reachable by its simple name

context

resolving links…