To see an inner class in use, consider a simple stack of integers. Stacks, which are a common data structure in programming, are well-named— they are like a "stack" of dishes. When you add a dish to the stack, you put it on top; when you remove one, you remove it from the top. The acronym for this is LIFO (last in, first out). Dishes on the bottom of the stack may stay there quite a long time while the upper dishes come and go.The
StackOfInts
class below is implemented as an array. When you add an integer (called "pushing"), it goes into the first available empty element. When you remove an integer (called "popping"), you remove the last integer in the array.The
StackOfInts
class below (an application) consists of:
- The
StackOfInts
outer class, which includes methods to push an integer onto the stack, pop an integer off the stack, and test to see if the stack is empty.- The
StepThrough
inner class, which is similar to a standard Java iterator. Iterators are used to step through a data structure and typically have methods to test for the last element, retrieve the current element, and move to the next element.- A
main
method that instantiates aStackOfInts
array (stackOne
) and fills it with integers (0, 2, 4, etc.), then instantiates aStepThrough
object (iterator
) and uses it to print out the contents ofstackOne
.The output is:public class StackOfInts { private int[] stack; private int next = 0; // index of last item in stack + 1 public StackOfInts(int size) { //create an array large enough to hold the stack stack = new int[size]; } public void push(int on) { if (next < stack.length) stack[next++] = on; } public boolean isEmpty() { return (next == 0); } public int pop(){ if (!isEmpty()) return stack[--next]; // top item on stack else return 0; } public int getStackSize() { return next; } private class StepThrough { // start stepping through at i=0 private int i = 0; // increment index public void increment() { if ( i < stack.length) i++; } // retrieve current element public int current() { return stack[i]; } // last element on stack? public boolean isLast(){ if (i == getStackSize() - 1) return true; else return false; } } public StepThrough stepThrough() { return new StepThrough(); } public static void main(String[] args) { // instantiate outer class as "stackOne" StackOfInts stackOne = new StackOfInts(15); // populate stackOne for (int j = 0 ; j < 15 ; j++) { stackOne.push(2*j); } // instantiate inner class as "iterator" StepThrough iterator = stackOne.stepThrough(); // print out stackOne[i], one per line while(!iterator.isLast()) { System.out.print(iterator.current() + " "); iterator.increment(); } System.out.println(); } }Note that the0 2 4 6 8 10 12 14 16 18 20 22 24 26StepThrough
class refers directly to thestack
instance variable ofStackOfInts
.Inner classes are used primarily to implement helper classes like the one shown in this example. If you plan on handling user-interface events, you'll need to know about using inner classes because the event-handling mechanism makes extensive use of them.
Local and Anonymous Inner Classes
There are two additional types of inner classes. You can declare an inner class within the body of a method. Such a class is known as a local inner class. You can also declare an inner class within the body of a method without naming it. These classes are known as anonymous inner classes. You will encounter such classes in advanced Java programming.
Modifiers
You can use the same modifiers for inner classes that you use for other members of the outer class. For example, you can use the access specifiers private
,public
, andprotected
to restrict access to inner classes, just as you do to other class members.