Trail: Learning the Java Language
Lesson: Classes and Objects
Section: Nested Classes
Inner Class Example
Inner Class Example
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:

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();
		
	}
	
}
The output is:
0 2 4 6 8 10 12 14 16 18 20 22 24 26 
Note that the StepThrough class refers directly to the stack instance variable of StackOfInts.

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, and protected — to restrict access to inner classes, just as you do to other class members.
Previous page: Nested Classes
Next page: Summary of Nested Classes