2.1.6.1 Nested Classes vs. Inner Classes
Keywords: current

Next: 2.1.6.2 Mutable Visitors Up: 2.1.6 Quasi-Functional Lists Previous: 2.1.6 Quasi-Functional Lists

###
2.1.6.1 Nested Classes vs. Inner Classes

A nested class is a class whose definition appears inside the definition of another class, as if it were a member of the other class. For example, if a program contains

    class A {
      class B {
        // fields, methods of class B...
      }
      // fields, methods of class A...
    }

then class `B` is a nested class of class `A`. Code outside of the methods of class `A` can refer to class `B` by calling it `A.B`, using the same dot notation as for field and method references. Within the methods of class `A` class `B` can be used without qualifying the name. `B` could be hidden from code outside of class `A` by declaring it `private`, just as with fields and methods.

A nested class like `B` is known as an inner class. An inner class has access to the fields of an instance of its enclosing class. For this reason, an instance of `B` can only be created in association with an instance of `A`, using the expression

> `/it instanceA.new A.B(...)`

outside of `A`'s methods, where instanceA is an instance of `A`, and

> `new B(...)`

inside of `A`'s methods. The new instance of `B` also knows about the enclosing instance of `A` and can refer to it using the expression

> `A.this`

We can think of an instance of an inner class as having two `this` references, one for itself and one for its enclosing instance. An inner class may be nested within another inner class, so an inner class can even have multiple levels of `this` references. Nesting inner classes more deeply than one level is quite uncommon, however, and should usually be avoided.

A nested class can be declared `static`, in which case it has reduced access to its enclosing class. For example, if `B` were declared `static` above, it could no longer access the instance variables of `A`, and there would be no associated instance `A.this`. Static nested classes are known as nested top-level classes, because they are exactly like classes declared outside any other class, except for the way they are named. Instances of a static nested class are created using regular new, as in

> `new A.B(...)`

We'll see uses for both static nested classes and inner classes when we present the full implementation of imperative lists.

Next: 2.1.6.2 Mutable Visitors Up: 2.1.6 Quasi-Functional Lists Previous: 2.1.6 Quasi-Functional Lists