An Advanced Code Pattern: Inner Classes

1
An Advanced Code PatternInner Classes

• CSE301
• University of Sunderland
• Harry R. Erwin, PhD
• Half Lecture

2
Why Bother with Inner Classes?

• Java (like C) tends to separate class
  definitions from where they are used.
• Java also tends to produce an exponential
  explosion in the number of classes in the system.
  This makes the architecture hard to understand
  and manage.
• Inner classes hide (encapsulation!) the extra
  helper classes needed to implement the system.
• Inner classes also localize the definition of
  these helper classes to exactly where they are
  used.
• Particularly important in graphical user
  interfaces, where events are usually handled by
  inner classes.

3
Inner Classes

• Static member classes (and interfaces) are
  defined as static members of another class.
• Member classes are instantiated within another
  class and have access to the fields of the
  enclosing class.
• Local classes are defined within a code block for
  use there.
• Anonymous classes are designed to be used as
  temporary variables in method calls without being
  given names.

4
Static Member Classes and Interfaces

• class or interface defined as a static member of
  another class.
• class Foo
• static class Bar
• Behaves like a top-level class but can access the
  static members of the containing class, including
  private members.
• Use like friend in C, frequently serving as a
  helper class. A static member interface can be
  defined to document how a class is to be accessed
  by another class.

5
Member Classes

• A class (not interface) defined as a member of
  another class.
• class Foo
• class Bar
• Can access the members of the containing class
  instance.
• Cannot contain static fields, methods, or classes
  (except static constant fields).
• Use like friend in C, often to implement a
  static member interface or a standard interface.
• For example, this can be used to define an
  Iterator for a user-defined Collection class.

6
Local Classes

• Defined within a block of Java code (in a method
  or initializer) and visible only there.
• Similar to member classes because the code is in
  a class. Local variables, arguments, and
  exception parameters it uses must be declared
  final so it can keep its own copies and have them
  be current.
• Often used to define an implementation of an
  interface
• Iterator getIterator()
• class myIterator implements Iterator
• define here how myIterator works
• return new myIterator()

7
Anonymous Classes

• A local class without a name. Often used as an
  adaptor or a method argument.
• Combines class definition syntax with object
  instantiation syntax. No constructor. Use an
  instance initializer block instead.
• An expression, so it can be part of a larger
  expression, such as a method invocation.
• new java.util.Iterator() class definition that
  implements an interface or extends a class
• new MyIterator(arg list) another class defn.

8
Initialization Blocks

• static code is used to initialize static member
  fields for a class. These are run in order of
  appearance in the class definition.
• code is used to do common initialization of
  instance fields for all constructors. These are
  also run in order of appearance before the
  constructor runs.
• This does imply initialization code may run in an
  unexpected order!
• Used to support anonymous inner classes, which
  cannot have constructors (as they have no name).

9
Example of Initialization
public class Foo public Foo() bar
2 static baz 2 bar 1 int bar
0 static int baz 1
What are the values of bar and baz when the class
instance is finally initialized?
10
Defining a Static Member Interface
public class LinkedStack public static
interface Linkable public Linkable
getNext() public void setNext(Linkable
node) Linkable head public void
push(Linkable node) public Object pop()
From Flanagan, Java in a Nutshell, 4th
edition, OReilly, 2002.
11
Using that Interface
Class LinkableInteger implements
LinkedStack.Linkable int I public
LinkableInteger(int I) this.I
I LinkedStack.Linkable next public
LinkedStack.Linkable getNext() return
next public void setNext(LinkedStack.Linkable
node) next node Note the syntax for
referring to the interface outside the
class. From Flanagan, Java in a Nutshell, 4th
edition, OReilly, 2002.
12
A Member Class
public class LinkedStack public static
interface Linkable private Linkable
head class members public java.util.Iterator
iterate() return new myIterator() protect
ed class myIterator implements java.util.Iterator
Linkable current public myIterator()
current head Iterator definition
From Flanagan, Java in a Nutshell, 4th
edition, OReilly, 2002.
13
A Local Class
// returns an Iterator object Public
java.util.Iterator iterate() class myIterator
implements java.util.Iterator Linkable
current public myIterator() current
head provide the member functions
required to implement an Iterator return
new myIterator() This encapsulates an
Iterator in the class being iterated. From
Flanagan, Java in a Nutshell, 4th edition,
OReilly, 2002.
14
An Anonymous Class
Public java.util.Iterator iterate() return new
java.util.Iterator Linkable current
current head // instance initializer // No
constructor! various member functions
implementing Iterator // semicolon
terminates the return statement From Flanagan,
Java in a Nutshell, 4th edition, OReilly, 2002.