Clear Understanding of Inner Class..

[Thiru Thangavelu]

Shall we come to a conclusion like this for inner class?
Anonymous Inner Class
1) Anonymous inner class is allowed to extend AT MOST one class or to implement AT MOST one interface explicitly.
2) Anonymous inner class always assumed to extend Object if it is not extending any other class or any other interface explicitly.
3) If Anonymous inner class extends a class, then it is not possible to extend anyother class including Object or implement an interface explicitly. But of course, the extended class must be derived from Object.
4) If Anonymous inner class implements a interface, then it is not possible to extend anyother class including Object or implement an interface explicitly. But of course, the extended interface must be derived from Object.
5) Anonymous inner class is one type of Local Inner class.
6) It can call superclass constructor. But how?
Local Inner Class
1) It has only access to the final variables of the enclosing method or final paramer passed to the method.
2) It can extend any number of classes or implement any number of interfaces.(Not sure)
3) Can not be decared with any modifier(only default is allowed)
4) static is not allowed
5) Can be declared inside a block like { /*Inner Class */} But why?
Member Inner class
1) All modifiers are allowed including private and protected.
2) static class is possible
3) Has access to enclosing class including private.
Correct me guys, if anything wrong in this and add more points to this to get a basic understanding of the Inner Classes.

[Dave Vick]

Thiru
For your annonymous section:
1, 3 and 4 say about the same thing just in different words. In #2 you say it is assumed to extend Object if it doesn't explicitly name a parent class or interface. You can't have an implied super class for an annonymous class or how would you write the code?
On the local class section:
3 and 4 say the same thing.
For number 5, it has to be defined in the block it is local to, thus the name.
Number two, no class whether it is a nested class or a top level class can extend more then one other class.
On #1, it also has access to all variables of the enclosing class instance unless it is defined inside a static block.
You could also break up your last section into two parts: inner classes and static member classes. from my notes:
static member classes:
can not access member variables of enclosing class, can only access static variables of the enclosing class.
created with: InnerClass ic = new OuterClass.InnerClass();
inner classes:
Cannot have member interfaces, can have static variables but they must be final
cannot have static initializers. Because the static variables are final they must be defined when declared
Cannot contain static methods (even if they are final)
All non static inner classes have a reference to (are associated with) an outer class object.
Can access the outer class variables by simply refering to the variable name.
If an inner class shadows a variable of the enclosing class then the enclosing class variable can be accessed by doing: OuterClass.this.variable Create an inner class instance in a method of the enclosing class (ie there is an instance of the enclosing class) using only the inner class name.

[Jose Botella]

Hello Thiru, this code responds some of your questions. (I hope)

public class Test
{
{class CalledFromTheConstructor //instance block placed by the compiler in the constructor (see *)
{void method()
{System.out.println("This was called from the constructor");
}
}
new CalledFromTheConstructor().method();
}

static 
{class CalledFromTheStaticInitializer//static block executed when the class is initalized
{void method()
{ System.out.println("Called when the class is initialized");
}
}
new CalledFromTheStaticInitializer().method();
}

public static void main(String[] args)
{new Object()//static annonymous class //annon 5
{void method()
{System.out.println("Hello");
}
}.method();

new MyClass(5)//calling the super constructor in MyClass //annon 6
{void method()
{System.out.println(i);
}
}.method();

new Test();//if this is commented out you won't see: (*)
}//This was called from the constructor

void method()
{final class LocalInner{} // Can be declared with final 
}

}
class MyClass
{int i;
MyClass(int i)
{this.i = i;
}
}
/*
C:\Java\test>java  Test
Called when the class is initialized
Hello
5
This was called from the constructor
*/