Inner classes, also called Nested Classes, are nothing but classes that are defined
within other classes. The nesting is a relationship between classes, not objects.
Inner classes have clearly two benefits, name control &
access control. In Java, this benefit is not as important because Java packages give the name control.
Java inner classes have feature that makes them richer and more
useful. An object of an inner class has an implicit reference to the outer
class object that instantiated it. Through this pointer, it gains access to any
variable of the outer object. Only static inner classes don’t have this
pointer. It is actually invisible when we write the code, but compiler takes
care of it. Inner classes are actually a phenomenon of the compiler and not the JVM.
Inner classes may be defined with following access modifiers
: public, protected, private, or with default
package access.
The syntax for inner class is as follows:
[modifiers] class OuterClassName
{
code...
[modifiers] class InnerClassName
{
code....
}
}
|
Inner
Classes:
Following properties can be noted about Inner
classes:
·
The outer class (the
class containing the inner class) can instantiate as many number of inner classobjects as it wishes, inside it’s code.
·
If the inner class is public & the containing class as well,
then code in some other unrelated class can as well create an instance of the
inner class.
·
In above case the inner class can be created as follows:
<OuterClassName>
outerObj = new <OuterClassName>(arguments);
outerObj.<InnerClassName>
innerObj = outerObj.new <InnerClassName>(arguments);
|
·
·
No inner class objects
are automatically instantiated with an outer class object.
·
If the inner class is static, then static inner
class can be instantiated
without an outer class instance, otherwise, the inner class object must be associated with an instance of
the outer class.
·
Inner class code has
free access to all elements of the outer class object that contains it, by name
(no matter what the access level of the elements is), if the inner class has a
varible with same name then the outer class’s variable can be accesse like this:
1
|
<OuterClassName>.this.<variableName>
|
·
The outer class can
call even the private methods of the inner class.
Static
Inner Classes:
Syntax for static inner class is as follows:
<access-specifier>
class OuterClassName {
public static class <StaticInnerClassName>
{
. . .
}
. . .
}
|
for static inner classes following additional properties hold:
·
Static members of the outer class are visible to the static inner
class, what ever their
access level be.
·
Non-static members of the outer
class are not available, because there is not instance of the outer class.
·
An inner class may not have static members unless the
inner class is itself marked as static.
·
Sometimes static nested class
are not refered to as inner class at all, as they don’t require outer classes
instance.
·
A static inner class is just
like any other inner class, but it dose not have the reference to its outer
class object that generated it.
There are two more types of inner classes, i.e local inner
classes & anonymous
inner classes. The local inner
class are defined within a method. Anonymous inner classes are also defined
with in a method but have no name.
Local
Inner Classes:
Syntax of the local inner class is as follows:
|
<access-specifier>
class <OuterClassName> {
code...
<access-specifier>
<return-type> <MethodName>(<arguments>){
class <LocalInnerClassName>{
code...
}
code...
}
code...
}
|
·
Local classes are
never declared with an access specifier (that is, public or private). Their scope is always restricted to the block in which they
are declared.
·
Local classes have a
great advantage: they are completely hidden from the outside world.
·
They can not only
access the instance variables but local variables of the method (in which they
are defined) as well, but the local varible has to be declared final.
Anonymous
Inner Classes
When using local inner
classes, you can often go a step further. If you want to make only a single
object of this class, you don’t even need to give the class a name.
Such a class is called an anonymous inner class. Usually the inner class extend some
interface or extend other class.
This syntax for anonymous classes is very cryptic.
1
2
3
|
new SuperType(construction
parameters) {
inner class methods
and data
}
|
·
Here, SuperType can be an interface, such as ActionListener; then, the inner class implements that
interface. Or SuperType can be a class; then, the inner class extends
that class.
·
An anonymous inner
class cannot have constructors because the name of a constructor must be the
same as the name of a class, and the class has no name. Instead, the
construction parameters are given to the superclass constructor. In
particular, whenever an inner class implements an interface, it cannot have any
construction parameters. Nevertheless, you must supply a set of parentheses as
in
1
|
new InterfaceType
() { methods and data }
|
·
It is recommended to
refrain from using them as many programmers find too many anonymous classes
hard to read.
The following table shows the types of nested classes:
Type
|
Scope
|
Inner
|
static nested class
|
member
|
no
|
inner [non-static]
class
|
member
|
yes
|
local class
|
local
|
yes
|
anonymous class
|
only the point where
it is defined
|
yes
|
Types of Nested
Classes
|
An inner class may not havestaticmembers unless the inner class is itself marked asstatic
Class
Files Generation for Inner Classes
As we mentioned
earlier each class can have more than one inner classes. Once the main class is
compiled which has several inner classes, the compiler generates separate class
files for each of the inner class. Have a look at below example.
// Main class
public class Main
{
// Inner class Test1
class Test1
{
}
// Inner class Test2
class Test2
{
}
public static void main(String
[] args) {
// Anonymous inner class 1
new
Object() {
};
// Anonymous inner class 2
new
Object() {
};
System.out.println("Hello
World");
}
}
|
Here we have a Main
class which has four inner classes. Test1, Test2, Anonymous inner class 1 and
Anonymous inner class 2. Once we compile this class using javac command, the
compiler will generates following class files.
Main.class
Main$Test1.class
Main$Test2.class
Main$1.class
Main$2.class
|
No comments:
Post a Comment