Introduction To Nested Class In Java

Introduction

In this article, we discuss nested classes (inner classes) in Java.

Nested class

One of the nice and highly advantageous features of Java is the ability to define nested classes, in other words, classes within classes. In Java classes are either top-level-classes (a class defined directly within a package) or nested classes (classes defined within top-level-classes).

Syntax:

class MainClass

{

//some coding here

class NestedClass

{

//some coding here

}

Advantages

The main advantages of a nested (inner) class are:

It shows a special type of relationship, in other words, it has the ability to access all the data members (data members and methods) of the main class including private.
They provide easier code because it logically groups classes in only one place.
Reduces coding since we need less code to write.

Types

This can be divided into two categories:

static class
non-static class is also called as inner classes.

Static Classes

This class can't refer directly to their instance variables or methods defined in its enclosing class since they use them only by an object reference. They are accessed by the use of class name:

MainClass.StaticNestedClass

For creating an object, the syntax is:

MainClass.StaticNestedClass nestedObject =new MainClass.StaticNestedClass();

Example

class Main
{
static int value=430;
static class Inner
{
void mesg()
{
System.out.println("Data value is " + value);
}
}
public static void main(String[] args)
{
Main.Inner c=new Main.Inner();
c.mesg();
}
}

Output

Non-static class (Inner class)

This class refers directly to its instance variables or methods defined in its enclosing class. Also, because an inner class is associated with an instance, it cannot define any static members itself.

The syntax for a non-static class is:

class MainClass

{

//Some code here

class InnerClass

{

//some code here

}

Example

In this example, we are invoking the methods of the member Inner1 class from the dsply() method of the Main1 class.

class Main1
{
private int value=330;
class Inner1
{
void passmsg()
{
System.out.println("value is " + value);
}
}
void dsply()
{
Inner1 inr=new Inner1();
inr.passmsg();
}
public static void main(String args[])
{
Main1 m=new Main1();
m.dsply();
}
}

Output

Example

In this example, we are invoking the messg() method of the Inner2 class from outside the class, in other words, the Print class.

class Main2
{
private int value=430;
class Inner2
{
void messg()
{
System.out.println("Vaule is " +value);
}
}
}
class Print
{
public static void main(String args[])
{
Main2 m2=new Main2();
Main2.Inner2 inr = m2.new Inner2();
inr.messg();
}
}

Output