Nested Class

1. Why Use Nested Classes?

There are several compelling reasons for using nested classes, among them:

• It is a way of logically grouping classes that are only used in one place.
• It increases encapsulation.
• Nested classes can lead to more readable and maintainable code.

2. Taxonomy of Classes

2.1 Static Nested Classes

A static nested class is associated with its outer class. And like static class methods, a static nested class cannot refer directly to instance variables or methods defined in its enclosing class — it can use them only through an object reference.

2.1.1 Create an object for the static nested class

OuterClass.StaticNestedClass nestedObject = new OuterClass.StaticNestedClass();

2.1.2 When to use static nested class

B is A's assistant class and only be used by A, define B as A's static nested class like JDK's LinkedList and it's Entry.

public class LinkedList<E> extends AbstractSequentialList<E> 
   …;
   private static class Entry<E> {
    E element;
    Entry<E> next;
    Entry<E> previous;

    Entry(E element, Entry<E> next, Entry<E> previous) {
        this.element = element;
        this.next = next;
        this.previous = previous;
    }
    }
    …;
}

2.2 Inner Classes

As with instance methods and variables, an inner class is associated with an instance of its enclosing class and has direct access to that object's methods and fields. Also, because an inner class is associated with an instance, it cannot define any static members itself.

2.2.1 Instantiate an inner class

OuterClass.InnerClass innerObject = outerObject.new InnerClass();

2.2.2 Obtain outer class's reference

OuterClass.this

2.2.3 When to use

Inner class's most important feature is it can access outer class's any fields or methods, for example, in JDK's Collection

library, every collection must provide a according Iterator to support unified collection traversal.

public abstract class AbstractList<E> extends AbstractCollection<E> implements List<E> {
    private class Itr implements Iterator<E> {
         ………;
    }

     public Iterator<E> iterator() {
        return new Itr();
     }
}

2.3 Anonymous Inner Classes

 An inner class within the body of a method without naming it

2.3.1 When to use

The class has few code to implement