Nested classes are further divided into two types:
-
static nested classes: If the nested class is static, then
it’s called static nested class. Static nested classes can access only static
members of the outer class. Static nested class is same as any other top-level
class and is nested for only packaging convenience.
Static class object can be created with following statement:
12OuterClass.StaticNestedClass nestedObject =newOuterClass.StaticNestedClass();静态嵌套类：如果嵌套类是静态的，则称作静态嵌套类。静态嵌套类只能访问外部类的静态成员。
-
java inner class: Any non-static nested class is known as
inner class. Inner classes are associated with the object of the class and
they can access all the variables and methods of the outer class. Since inner
classes are associated with instance, we can’t have any static variables in
them. Object of inner class are part of the outer class object and to create
an instance of inner class, we first need to create instance of outer class.
Inner classes can be instantiated like this:
12OuterClass outerObject =newOuterClass();OuterClass.InnerClass innerObject = outerObject.newInnerClass();
There are two special kinds of java inner classes.
-
local inner class: If a class is defined in a method body,
it’s known as local inner class. Since local inner class is not associated
with Object, we can’t use private, public or protected access modifiers with
it. The only allowed modifiers are abstract or final. A local inner class can
access all the members of the enclosing class and local final variables in the
scope it’s defined.
Local inner class can be defined as:
1234567publicvoidprint() {//local inner class inside the methodclassLogger {String name;}//instantiate local inner class in the method to useLogger logger =newLogger(); -
anonymous inner class: A local inner class without name is
known as anonymous inner class. An anonymous class is defined and instantiated
in a single statement. Anonymous inner class always extend a class or
implement an interface. Since an anonymous class has no name, it is not
possible to define a constructor for an anonymous class. Anonymous inner
classes are accessible only at the point where it is defined.
It’s a bit hard to define how to create anonymous inner class, we will see it’s real time usage in test program below.
Here is a java class showing how to define java inner class, static nested class, local inner class and anonymous inner class.
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
|
package
com.journaldev.nested;
import java.io.File;
import java.io.FilenameFilter;
public class OuterClass {
private
static String name = "OuterClass";
private
int
i;
protected
int
j;
int
k;
public
int
l;
//OuterClass constructor
public
OuterClass(int
i, int j, int k, int l) {
this.i = i;
this.j = j;
this.k = k;
this.l = l;
}
public
int getI() {
return
this.i;
}
//static nested class, can access OuterClass static variables/methods
static
class StaticNestedClass {
private
int
a;
protected
int
b;
int
c;
public
int
d;
public
int getA() {
return
this.a;
}
public
String getName() {
return
name;
}
}
//inner class, non static and can access all the variables/methods of outer class
class
InnerClass {
private
int
w;
protected
int
x;
int
y;
public
int
z;
public
int getW() {
return
this.w;
}
public
void setValues() {
this.w = i;
this.x = j;
this.y = k;
this.z = l;
}
@Override
public
String toString() {
return
"w=" + w + ":x="
+ x + ":y="
+ y + ":z="
+ z;
}
public
String getName() {
return
name;
}
}
//local inner class
public
void print(String initial) {
//local inner class inside the method
class
Logger {
String name;
public
Logger(String name) {
this.name = name;
}
public
void log(String str) {
System.out.println(this.name + ": "
+ str);
}
}
Logger logger = new
Logger(initial);
logger.log(name);
logger.log(""
+ this.i);
logger.log(""
+ this.j);
logger.log(""
+ this.k);
logger.log(""
+ this.l);
}
//anonymous inner class
public
String[] getFilesInDir(String dir, final
String ext) {
File file = new
File(dir);
//anonymous inner class implementing FilenameFilter interface
String[] filesList = file.list(new
FilenameFilter() {
@Override
public
boolean accept(File dir, String name) {
return
name.endsWith(ext);
}
});
return
filesList;
}
} |
Here is the test program showing how to instantiate and use nested class in java.
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
|
package
com.journaldev.nested;
import java.util.Arrays;
//nested classes can be used in import for easy instantiationimport com.journaldev.nested.OuterClass.InnerClass;
import com.journaldev.nested.OuterClass.StaticNestedClass;
public class NestedClassTest {
public
static void main(String[] args) {
OuterClass outer = new
OuterClass(1,2,3,4);
//static nested classes example
StaticNestedClass staticNestedClass = new
StaticNestedClass();
StaticNestedClass staticNestedClass1 = new
StaticNestedClass();
System.out.println(staticNestedClass.getName());
staticNestedClass.d=10;
System.out.println(staticNestedClass.d);
System.out.println(staticNestedClass1.d);
//inner class example
InnerClass innerClass = outer.new
InnerClass();
System.out.println(innerClass.getName());
System.out.println(innerClass);
innerClass.setValues();
System.out.println(innerClass);
//calling method using local inner class
outer.print("Outer");
//calling method using anonymous inner class
System.out.println(Arrays.toString(outer.getFilesInDir("src/com/journaldev/nested", ".java")));
System.out.println(Arrays.toString(outer.getFilesInDir("bin/com/journaldev/nested", ".class")));
}
} |
Here is the output of above program:
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
OuterClass100OuterClassw=0:x=0:y=0:z=0w=1:x=2:y=3:z=4Outer: OuterClassOuter: 1Outer: 2Outer: 3Outer: 4[NestedClassTest.java, OuterClass.java][NestedClassTest.class, OuterClass$1.class, OuterClass$1Logger.class, OuterClass$InnerClass.class, OuterClass$StaticNestedClass.class, OuterClass.class] |
Notice that when OuterClass is compiled, separate class files are created for inner class, local inner class and static nested class.
Benefits of Java Nested Class
- If a class is useful to only one class, it makes sense to keep it nested and together. It helps in packaging of the classes.
- Nested classes increases encapsulation. Note that inner classes can access outer class private members and at the same time we can hide inner class from outer world.
- Nesting small classes within top-level classes places the code closer to where it is used and makes code more readable and maintainable.