Inner Class Example in Java

By: Tamil Selvan Viewed: 153232 times  Printer Friendly Format    

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 a StackOfInts array (stackOne) and fills it with integers (0, 2, 4, etc.), then instantiates a StepThrough object (iterator) and uses it to print out the contents of stackOne.

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
		   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)
		// retrieve current element
		public int current() {
			return stack[i];
		// last element on stack?
		public boolean isLast(){
			if (i == getStackSize() - 1)
			   return true;
			   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++) {
		// instantiate inner class as "iterator"
		StepThrough iterator = stackOne.stepThrough();
		// print out stackOne[i], one per line
		while(!iterator.isLast()) {
			System.out.print(iterator.current() + " ");

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.


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.

Most Viewed Articles (in Java )

Latest Articles (in Java)

Comment on this tutorial