Object-Oriented Programming with Java Lecture Notes

26 February 2009 • Inner Classes

---

Outline

• Inner classes.

  • Information hiding and name-space control.

  • Inner-class scope access.

  • On-the-fly class creation.

N-ary Trees

• An n-ary tree can have up to n children.

• An n-ary-tree class needs an implementation of n-ary-tree nodes.

• An n-ary-tree node can be implemented different ways.

  • Children can be stored in arrays, linked lists, hash tables, and so on.

  • The choice probably depends on n.

Hiding Information

• The node implementation should be hidden to all but the tree implementation.

  • Hiding preserves the ability to change node implementations.

• How can the node class be hidden from all but the tree class?

  • Package-level scope is no help.

  • Every other class in the package as the same access to the node as the tree does.

Inner Classes

• Inner (nested) classes solve the node-hiding problem.

• An inner class is a class defined inside another class.

  • Classes not contained in other classes are top-level classes.

  • Inner classes can have public, package (default), protected, or private access.

• The node class can be a private inner class to the tree class.

Example

public class NaryTree {

  // blah blah blah

  private class
  NaryTreeNode {
    // blah blah blah
    }
  }

• NaryTree can access NaryTreeNode, but no other class — including NaryTree ancestors — can.

Tying Classes

• Some times you have the opposite problem:

  two classes should be tied together and made available as a unit.

• Non-private inner classes can solve this problem too.

• This is a less-compelling use of inner classes, but occasionally useful.

Example

public class AdmissionQueue {

  // blah blah blah

  public class
  Ticket { ... }

  public Ticket enqueue(Object o) { ... }
  public void cancel(Ticket t) { ... }
  }

• Inner classes are accessed with dot notation: AdmissionQueue.Ticket.

Tree Traversal

• Tree classes should support traversals.

  • Pre- and post-order traversals for n-ary trees.

• The Iterator interface defines the Java-standard data-structure traversal mechanism.

  public interface Iterator {
    boolean hasNext();
    Object next();
    void remove();  // optional
    }
  

Example

import java.util.Iterator;

void moo() {
  NaryTree root = new NaryTree(10)

  // blah blah blah

  final Iterator i = 
    root.preorderIterator()

  while (i.hasNext())
    final Object o = i.next()
    // blah blah blah
  }

Implementing Tree Iterators

• There needs to be a TreeIterator class implementing the Iterator interface.

• Where is TreeIterator relative to NaryTree?

• The TreeIterator class details aren’t generally interesting.

  • It behaves like an Iterator, that’s what matters.

• Because it’s interesting only to NaryTree, make TreeIterator an inner class.

Implementation Details

• How is TreeIterator implemented?

  • The iterator needs access to the n-ary tree innards.

    • The root, for example, or the tree nodes.

  • But n-ary-tree innards should be private.

• C++ has the friends designation; mercifully, Java does not.

• Now where’s TreeIterator relative to NaryTree?

Proposal

public class NaryTree {

  private class NaryTreeIterator
  implements Iterator {
    NaryTreeIterator(...) {...}
    // blah blah blah
    }

  public Iterator prefixIterator() {
    final NaryTreeIterator i = 
      new NaryTreeIterator(...);
    // blah blah blah
    return i;
    }
  }

Iterator-Use Example

• In a client:

  final NaryTree t = new NaryTree(10)
  
  // blah blah blah
  
  final Iterator i = t.prefixIterator()
  

  

Inner-Scope Access

• An inner-class instance has access to the outer-class instance that created it.

  • The outer-class reference is named OuterClass.this in the inner class.

  • And like this, it’s redundant.

• The reference gives the inner-class instance access to outer-class-instance features.

  • Such as outer-class instance variables and methods.

Example

class OuterClass {
  String talk = "moo";

  void say(String what) {
    System.out.println(what);
    }

  private class InnerClass {
    void go() {
      say(talk);
      OuterClass.this.say(
        OuterClass.this.talk);
      }
    }
  }

Nested Class Scopes

• There are now three nested class scopes:

  1. inner-class method scope,

  2. inner-class scope, and

  3. Outer-class scope.

• Inner classes may nest to arbitrary depths.

  • Each inner class can only access its immediately inclosing outer class.

Scope Example

Preventing Outer-Class Access

• Outer-class access and information hiding are separate but related features.

• Inner classes being hidden may not need outer-class access.

  • And should not have it to preserve encapsulation.

• Declaring an inner class static eliminates the outer-class reference.

Static-Class Example

• N-ary-tree nodes don’t care about the tree that uses them.

  • They shouldn’t have access to outer-class (n-ary-tree class) features.

• NaryTreeNode should be a static inner class.

  public class NaryTree {
    private static class 
    NaryTreeNode { ... }
    }
  

Class Instantiation

• The new operator creates class instances.

  NaryTree root = new NaryTree(10);
  

• Why can’t an interface be instantiated the same way?

  Comparable c = new Comparable();
  

  • It has no methods to call through the instance.

• What would be necessary to instantiate an interface?

  • Or abstract classes more generally?

Instantiating Abstract Classes

• If an abstract class had all its methods, it could be instantiated.

  class t {
    int moo() {
      Comparable c = new Comparable() {
        public int compareTo(Object o) {
          return -1;
          }
        };
  
      return c.compareTo(this);
      }
    }

Anonymous Classes

• An anonymous class is an instance of a completed abstract class.

• The instance’s type is an anonymous subclass of the abstract class.

  • “Anonymous” means it doesn’t have a name.

  • But otherwise it’s just like a subclass of the abstract class.

  • Perhaps “anonymous subclasses” is a better term.

Instantiation Syntax

• The instantiation syntax is similar to non-anonymous class instantiation.

  new classConstructorCall { 
    classFeatureDefinitions... 
    }
  

  • This is an expression whoes value is a reference to the anonymous-class instance.

• The trailing block must override all abstract methods.

• New features can be added, as in a subclass.

Example

abstract class t {
  t(int i, String s) { }
  abstract void moo();
  }

class u {
  void moo() {
    t t1 = new t(1, "hello") {
          String label = "hello";
          void moo() { }
          void baa() { }
          };
    }
  }

Summary

• Inner classes are the last major scope and access entity.

• Inner classes provide more information hiding and name-space control.

  • And occasionally more strongly ties classes together.

• Anonymous inner classes provide quasi-first-order programming.

  • And are important in Java GUI programming.