maybe with this example you can understand it:
Consider a simple stack of integer.
When you add a integer to the stack, you put it on top; when you remove one, you remove it from the top.
The IntegerStack class below is implemented as an array.
When you add an integer, it goes into the first available empty element. When you remove an integer, you remove the last integer in the array.
The IntegerStack class below consists of:
* The IntegerStack 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 IntegerStack 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 IntegerStack {
private int[] stack;
private int next = 0; // index of last item in stack + 1
public IntegerStack (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"
IntegerStack integerStack = new IntegerStack (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 IntegerStack .
Inner classes are used primarily to implement helper classes like the one shown in this example.
I hope that you have understood the idea, I searched this example on google.