In Java, it is possible to define a class within another class, such classes are known as nested classes. They enable you to logically group classes that are only used in one place, thus this increases the use of encapsulation, and creates more readable and maintainable code.
- The scope of a nested class is bounded by the scope of its enclosing class. Thus in below example, class NestedClass does not exist independently of class OuterClass.
- A nested class has access to the members, including private members, of the class in which it is nested. But the enclosing class does not have access to the members
of the nested class. - A nested class is also a member of its enclosing class.
- As a member of its enclosing class, a nested class can be declared private, public, protected, or package private(default).
- Nested classes are divided into two categories:
- static nested class : Nested classes that are declared static are called static nested classes.
- inner class : An inner class is a non-static nested class.
Syntax:
class OuterClass { ... class NestedClass { ... } }
Static nested classes
In the case of normal or regular inner classes, without an outer class object existing, there cannot be an inner class object. i.e., an object of the inner class is always strongly associated with an outer class object. But in the case of static nested class, Without an outer class object existing, there may be a static nested class object. i.e., an object of a static nested class is not strongly associated with the outer class object.As with class methods and variables, a static nested class is associated with its outer class. And like static class methods, a static nested class cannot refer directly to instance variables or methods defined in its enclosing class: it can use them only through an object reference.They are accessed using the enclosing class name.
OuterClass.StaticNestedClass
For example, to create an object for the static nested class, use this syntax:
OuterClass.StaticNestedClass nestedObject = new OuterClass.StaticNestedClass();
Tóm Tắt
Java
class
OuterClass
{
static
int
outer_x =
10
;
int
outer_y =
20
;
private
static
int
outer_private =
30
;
static
class
StaticNestedClass
{
void
display()
{
System.out.println(
"outer_x = "
+ outer_x);
System.out.println(
"outer_private = "
+ outer_private);
}
}
}
public
class
StaticNestedClassDemo
{
public
static
void
main(String[] args)
{
OuterClass.StaticNestedClass nestedObject =
new
OuterClass.StaticNestedClass();
nestedObject.display();
}
}
Output:
outer_x = 10 outer_private = 30
Inner classes
To instantiate an inner class, you must first instantiate the outer class. Then, create the inner object within the outer object with this syntax:
OuterClass.InnerClass innerObject = outerObject.new InnerClass();
There are two special kinds of inner classes :
Java
class
OuterClass
{
static
int
outer_x =
10
;
int
outer_y =
20
;
private
int
outer_private =
30
;
class
InnerClass
{
void
display()
{
System.out.println(
"outer_x = "
+ outer_x);
System.out.println(
"outer_y = "
+ outer_y);
System.out.println(
"outer_private = "
+ outer_private);
}
}
}
public
class
InnerClassDemo
{
public
static
void
main(String[] args)
{
OuterClass outerObject =
new
OuterClass();
OuterClass.InnerClass innerObject = outerObject.
new
InnerClass();
innerObject.display();
}
}
Output:
outer_x = 10 outer_y = 20 outer_private = 30
Comparison between normal or regular class and static nested class
S.NONormal/Regular inner classStatic nested class1.Without an outer class object existing, there cannot be an inner class object. That is, the inner class object is always associated with the outer class object.Without an outer class object existing, there may be a static nested class object. That is, static nested class object is not associated with the outer class object.2.Inside normal/regular inner class, static members can’t be declared.Inside static nested class, static members can be declared.3.As main() method can’t be declared, regular inner class can’t be invoked directly from the command prompt.As main() method can be declared, the static nested class can be invoked directly from the command prompt.4.Both static and non static members of outer class can be accessed directly.Only a static member of outer class can be accessed directly.
My Personal Notes
arrow_drop_up