When do we use inner classes?

[cruxblack]

Anybody could help?
Im still a bit confused with the use of inner class
What do we use inner class for actually and why should we use inner class?

Declaring a class inside another still seems bit weird for me, don't get it :(

Thanks

CruxBlack

[gabriel]

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.

[levent]

One advantage i can think of is that if you don't want to document a class and want to hide it from outside world, you can use it in that way ;)

And actually i don't think there is any strict rule for making a class inner. So it is more likely a choice matter IMO!

[levent]

And i think gabriel's example is very clear. So, they are helper classes but if you want to help others, you can make those classes public! :)

[cruxblack]

Hmm..so it's a helper class?
To hide it from another class, that i get, analogically, it's like having a class that are owned by it's outer class only right?
But then, won't this class capabilities be limited and un-reusable?:confused:
Why not create an instance of another class in that class instead then, doesn't that give the same effect?

Btw, is there any limit on how deep could an inner class be?
Or maybe it have no limit and could go on like, A is the inner class of B which are the inner class of C in which are the inner class of D and so on and so on...

[Heather]

the advantage of inner class is that this class can access to the methods of the container class
It useful to do listeners classes

these classes are anonymous, that is to say, they don't have name and they don't assign to a variable.

it's the same have a class that are owned by it's outer class
But I don't know why people doesn't do that

won't this class capabilities be limited and un-reusable

YES

is there any limit on how deep could an inner class be?

yes