Introducing
Nested and Inner Classes
It is
possible to define a class within another class; such classes are known as nested classes. The scope of a nested
class is bounded by the scope of its enclosing class. Thus, if class B is
defined within class A, then B does not exist independently of A. A nested class
has access to the members, including private members, of the class in which it
is nested. However, the enclosing class does not have access to the members of
the nested class. A nested class that is declared directly within its enclosing
class scope is a member of its enclosing class. It is also possible to declare
a nested class that is local to a block.
There
are two types of nested classes: static
and non-static. A static nested class
is one that has the static modifier
applied. Because it is static, it must access the non-static members of its
enclosing class through an object. That is, it cannot refer to non-static
members of its enclosing class directly. Because of this restriction, static
nested classes are seldom used.
The most important type of nested
class is the inner class. An inner
class is a non-static nested class. It has access to all of the variables and
methods of its outer class and may refer to them directly in the same way that
other non-static members of the outer class do.
The following program
illustrates how to define and use an inner class. The class named Outer has one instance variable named outer_x, one instance method named test( ), and defines one inner class called Inner.
// Demonstrate an inner class.
class Outer {
int outer_x = 100;
void test() {
Inner inner = new Inner();
inner.display();
}
// this is an inner class
class Inner {
void display() {
System.out.println("display: outer_x =
" + outer_x);
}
}
}
class InnerClassDemo {
public static void main(String args[]) {
Outer outer = new Outer(); outer.test();
}
}
Output from this application
is shown here:
display: outer_x = 100
In the
program, an inner class named Inner
is defined within the scope of class Outer.
Therefore, any code in class Inner
can directly access the variable outer_x.
An instance method named display( )
is defined inside Inner. This method
displays outer_x on the standard
output stream. The main( ) method of
InnerClassDemo creates an instance
of class Outer and invokes its test( ) method. That method creates an
instance of class Inner and the display( ) method is called.
It is important to realize
that an instance of Inner can be
created only in the context of class Outer.
The Java compiler generates an error message otherwise. In general, an inner
class instance is often created by code within its enclosing scope, as the
example does.
As
explained, an inner class has access to all of the members of its enclosing
class, but the reverse is not true. Members of the inner class are known only
within the scope of the inner class and may not be used by the outer class. For
example,
// This program will not compile.
class Outer {
int outer_x = 100;
void test() {
Inner inner = new Inner();
inner.display();
}
// this is an inner class
class Inner {
int y = 10; // y is local to Inner
void display() {
System.out.println("display: outer_x =
" + outer_x);
}
}
void showy() {
System.out.println(y); // error, y not known
here!
}
}
class InnerClassDemo {
public static void
main(String args[]) { Outer outer = new Outer(); outer.test();
}
}
Here, y is declared as an instance variable of Inner. Thus, it is not known outside of that class and it cannot be
used by showy( ).
Although
we have been focusing on inner classes declared as members within an outer
class scope, it is possible to define inner classes within any block scope. For
example, you can define a nested class within the block defined by a method or
even within the body of a for loop,
as this next program shows:
// Define an inner class within a for loop.
class Outer {
int outer_x = 100;
void test() {
for(int i=0; i<10; i++) {
class Inner {
void display() {
System.out.println("display: outer_x =
" + outer_x);
}
}
Inner inner = new Inner();
inner.display();
}
}
}
class InnerClassDemo {
public static void
main(String args[]) { Outer outer = new Outer(); outer.test();
}
}
The output from this version
of the program is shown here:
display: outer_x = 100
display: outer_x = 100
display: outer_x = 100
display: outer_x = 100
display: outer_x = 100
display: outer_x = 100
display: outer_x = 100
display: outer_x = 100
display: outer_x = 100
display: outer_x = 100
While nested classes are not
applicable to all situations, they are particularly helpful when handling
events. We will return to the topic of nested classes in Chapter 24. There you
will see how inner classes can be used to simplify the code needed to handle
certain types of events. You will also learn about anonymous inner classes, which are inner classes that don’t have a
name.
One final point: Nested classes were not
allowed by the original 1.0 specification for Java. They were added by Java
1.1.
Related Topics
Privacy Policy, Terms and Conditions, DMCA Policy and Compliant
Copyright © 2018-2026 BrainKart.com; All Rights Reserved. Developed by Therithal info, Chennai.