3.5 Inner classes  (Page 5/8)

Inner classes do not have to be anonymous as shown in the above examples. They can be named as well.

Access specifier

Just like any other class, a class defined inside of another class can be public , protected , package private, or private .

Extensibility specifier

Just like a regular class, a final nested/inner class cannot extended.

Abstract specifier

Just like a regular class, an abstract nested/inner class cannot be instantiated.

Inheritance specifier

Just like a regular class, an nested/inner can extend any non-final class and implement any number of interfaces that are within its scope.

Usage

Nested classes are used mostly to avoid name clash and to promote and enforce information hiding. For example the specialized double precision geometric point class, Point2D.Double is defined as an nested class of Point2D which is in turn a nested class of Point . In such, it has access to all the functionality of its parent plus it avoids the name clash with the double precision number class, Double

Inner classes are used to create (at run-time) objects that have direct access to the internals of the outer object and perform complex tasks that simple methods cannot do. Most of the time, they are defined anonymously. For examples, " event listeners " for Java GUI components are implemented as inner classes. The dynamic behavior and versatility of these "listeners" cannot be achieved by the addition of a set of fixed methods to a GUI component. We shall study Java event handling soon!

An inner object can be thought as an extension of the outer object.

6. closure

In functional programming, the closure of a function ( lamdba ) consists of the function itself and an environment in which the function is well-defined. In Java, a function is replaced by a class. An inner class is only defined in the context of its outer object (and the outer object of the outer object, etc...). An inner class together with its nested sequence of outer objects in which the inner class is well-defined is the equivalent of the notion of closure in functional programming. Such a notion is extremely powerful. Just like knowing how to effectively use lambda expressions and higher order functions is key to writing powerful functional programs in Scheme, effective usage of anonymous inner classes is key to writing powerful OO programs in Java.

Some important points to remember about closures and inner classes:

• An object's closure is defined at the time of its creation.
• An object "remembers" its closure for its entire lifetime.
• An inner object's closure includes any local variables that are declared as final , plus all fields of the enclosing object, including private ones.
• Every time a factory method is run, where a new anonymous object is created, a new closure for that object is created. This is because the local variables could change between calls.
• Closures enable decoupled communication because an inner class can communicate with its outer class through its closure.

One of the most important ways in which we will use anonymous inner classes it to take advantage of their closure properties. Anonymous inner classes are the only objects in Java that can be instantiated in such a manner that the variables in their environments (closures) can be dynamically defined. That is, since an anonymous inner class can reference a local variable (that is declared final ) and since local variables are created every time a method is called, then every the anonymous inner class object created has a different set of dynamically created variables that it is referencing. This means that we can make unique objects with unique behaviors at run time.