My recommendation: don't worry about inner classes at this point. Just
realize that they exist, and move on with your Java studies. When you start
working with large frameworks or complex APIs, you'll have more background
and experience that might let you understand why inner classes are sometimes
useful.

   - Oliver

They are definately worth using, especially as you move into doing programs
of realistic size and complexity.  Anonymous inner classes are widely used
for GUI event handlers because they allow you to specify functionality that
is separate from the GUI class but that will execute in the context of that
class.

myButton.addActionListener (new ActionListener () {
public void actionPerformed (ActionEvent actionEvent) {
 // Write your code here that will be executed when the button is pressed
 // It can use the instance variables of the enclosing class.
}
});

Notice that the ActionListener is actually an Interface.  For some listeners
that have many methods there are default implementations that have empty
methods that you can use so that you only have to provide an implementation
for the one you want, as in using a MouseAdapter or WindowAdapter (check
these out in the API)

I often use named inner classes for specialized GUI data structures, such as
special kinds of JTree nodes or Cell Renderers and so forth.

Matt Humphrey matth@ivizNOSPAM.com http://www.iviz.com/

led schrieb:

Often.

http://www.javaworld.com/javaworld/javaqa/2000-03/02-qa-innerclass.html

Bye
Michael

If you reading the book first, I suggest you can pass it. Because if
you cannt use it in some practice, you won't get the deeper understand.
And when you write some complex GUI program, you will use and know it.
 In the first, I think the basic grammer and detail is useful for the
beginner.

Frequently.

Basically, nesting classes inside other classes have two effects:

1) They become nested inside a namespace, thus they don't collide with
  other classes which might share the same short name elsewhere.

2) They gain a strong association with their enclosing class that
  other classes lack.

You should; Nested (member) classes, whether inner classes or static,
are just as important members as methods or fields - and you do learn
about those, right? :)

The problem is that they are just "member" classes for the purposes of
the language; once compiled they are synthesized into top-level
classes with some magic regarding visibility and access.