One difference is that static inner class' access can be limited more.
So if you want a class that is A) only available for use by a certain
top level class and B) does not have a reference to the top level
class,  then you use a static inner class.

Seperatly, sometimes a class only makes sense in context of another
class but does not need to have a reference to top level class.  You
could make two top level classes TopLevelClass and
TopLevelClassSymbiont or you could make TopLevelClass and an inner
class which could be refered to as TopLevelClass.Symbiont.  Putting the
inner class into the top level class marks the context relationship
mentioned in the first sentance of this paragraph.

Seperatly, occasionally, with Java 5.0 import static, I use a top level
classes to group public classes.

A new concept indeed needs be understood.  The compensating factor is
that it can reduce complexity of code.

Features take effort.

opalpa
opalpa@gmail.com
http://opalpa.info/

Why do some OO languages only support implementation inheritance?
Why do some other OO languages prevent implementation inheritance?
Why do some OO languages allow other types of polymorphism than
subtype polymorphism?

etc.

Note that anyway what you say isn't necessarly true: if your
static nested class contains, for example, a static field
(JLS 8.3.1.1: "static fields") you do not necessarly need to
have an instance of the nested class to access that field.

You're confused on the terminology...

You ask "why do we need 'static' inner classes??" in the
subject then "why would we need a nested class (i.e. static)...".

It seems like you think that nested imply static.

You've got it backward :  "inner" means "not static".

There's no such thing as a "static inner" class in Java.

Inner classes are nested classes.

A static nested class is NOT an inner class.

An inner class can NEVER be static.

A nested class is either static or inner.

The *very first time* the term "inner class" appears in the JLS it
is defined like this:

"An inner class is a nested class that is not explicitly
or implicitly declared static"

http://java.sun.com/docs/books/jls/third_edition/html/classes.html#8.1.3

And "inner class" implies that there's an enclosing instance.

Not surprisingly, that section of the JLS is called :

"8.1.3 Inner Classes and Enclosing Instances"

Do not pay attention to supposedly common usage.  There may be
many people mixing up nested/inner...  But there are also many
experienced people who do not mix these terms.

The Java Language Specification is authoritative on that subject.

It helps communication to use the correct terms.

See you later,

 Driss