Nested class in JAVA with EXAMPLES

Nested class if we declare one or more classes in a class then these classes are known as nested class.

Java Allows two category of nested class

1. Static nested class
2. Non Static nested class or inner class.

i) Member inner class: When declare any class inside a class but outside a method

ii) Anonymous inner class: this class uses for interface and abstract

iii) Local inner class: this class is more restricted class than others. This class used inside method.

Why use nested class? When we declare a private variable in a class others class can’t use this variable. So the purpose of nested class is hiding or encapsulate.

Inner class or non-static class can use outer class variable as global variable.

Member inner class example:

1. public class Outerclass {
   private int data=30;
   class Inner{
   void printline(){
   System.out.println("inner class Printline");
   System.out.println("Outer class data variable value: "+data);
   }
   }
   void display(){
   Outerclass.Inner inner = new Outerclass.Inner();
   inner.printline();
   }
   public static void main(String args[]){
   Outerclass outer = new Outerclass();
   outer.display();
   }
   }

    

Following the program Inner class use as member inner class. To display any line in the Inner class and to print outer class variable, here need outer class object in main method.

Line 10 can be rewritten as Inner inner = new Inner(). Keep in mind we can’t create Inner class object in main method because main method is a static method. In outer class create display method where need to create inner class object to print inner class method.

When outer.display() called then inner class method printline() is run.

Output:

run:

inner class Printline

30

BUILD SUCCESSFUL (total time: 0 seconds)

Outer class variable value run as globally, In case of Inner class variable or method need to create inner class object that already used in the example.

Anonymous inner class: This type of inner class most important. This inner class used in interface and abstract. As interface and abstract can’t create any object so inner class is the best use for interface and inner class.

Interface consist of ‘able’ ,e.g default interface Cloneable()

Now example for anonymous inner class

1. interface Enable{
   void screen();
   }
   public class TestClass{
   public static void main(String args[]){
   Enable e = new Enable() {
   @Override
   public void screen() {
   System.out.println("Nice and Simple");
   }
   };
   e.screen();
   }
   }
   
   
   

   Following the example Enable is an interface there contains a method void screen(). To implement the method there needs to be @Override following

1. interface Enable{
   void screen();
   }
   public class TestClass implements Enable{
   public static void main(String args[]){
   }
   @Override
   public void screen() {
   System.out.println("Using implements Enable interface");
   }
   }

    

We can use Enable interface by using implements. When implements Enable interface this TestClass  show message for Override method of interface.

So anonymous inner class can be used as inner class or by implements interface.

As this class known as anonymous we can rewrite the inner class like

1. new Enable() {
   @Override
   public void screen() {
   System.out.println("Using implements Enable interface");
   }
   }.screen();
   

   Here this inner class means obj.method() where object is anonymous. This anonymous inner class can be used for interface similarly for the abstract class. We know interface is implicitly public abstract where no method has any body part. For the abstract class user need to declare class and method as abstract. Example anonymous inner class for abstract class:

1. abstract interface newinterface
   {
   abstract void eat();
   }
   public class NewClass {
   public static void main(String args[])
   {
   new newinterface(){
   @Override
   public void eat()
   {
   System.out.println("Sweet food");
   }
   }.eat();
   }
   }
   

   Here this inner class means obj.method() where object is anonymous and the class is abstract.

Local inner class:

A class that is created inside a method is known as local inner class. If you want to invoke the methods of local inner class, you must instantiate this class inside the method.

1)      Local inner class cannot be invoked from outside the method.

2)      Local inner class cannot access non-final variable.

Example of local inner class:

public class LocalInner {    
 private int data = 30;    
 void localmethod()    
 {     
class Inner   
  {    
 void message()  
   {    
     System.out.println("Local variable value: "+data);   
  }  
   }   
  Inner inner = new Inner(); 
    inner.message();   
  }     
public static void main(String args[])
{   
  LocalInner obj = new LocalInner();
     obj.localmethod();  
   }    
 }

In main method when obj.localmethod(); is called local inner method called to run the inner class method  that is  inner.message(); is called.

Another example

public class LocalInner {
 private int data = 30; 
void localmethod() { 
int x=2;
 class Inner { 
void message() {
 System.out.println("Local variable value: "+data +"   "  +x); 
} } 
Inner inner = new Inner(); 
inner.message(); } 
public static void main(String args[])
{ 
LocalInner obj = new LocalInner();
 obj.localmethod(); 
} }

Here we declare a local variable x (line 5) in the inner class and want to invoke message() method then need to declare x as final. Example

void localmethod() {
 final int x=2; class Inner{ 
void message() { 
System.out.println("Local variable value: "+data+"   " +x);
 } }

Above all if local variable does not final,local variable can’t invoke the local inner class.

Static Nested Class;

Example:

public class NewClass1 { 
    static int a =1;
     static class Inner{
     void message()
     {      
   System.out.println("Simple statements " +a);    
 }     static void display()     
{         System.out.println("Display statements");    
 }     }    
 public static void main(String args[])     { 
      Inner n = new Inner();      
 n.message(); // as message() is non-static so need to create object to call the method.    
   Inner.display(); //display() method is static so can be called by class ,no need create object here.           } }

Nested Interface: Interfaces can be nested, by default nested Interfaces are public and static (implicitely) Nested Interface program: public interface Displable {     void msg();     interface Eatable{         void eat();     } }

When we want to use eat() method in class the program would be:

class Exinterface implements Displable.Eatable{

@Override

public void eat() {

System.out.print(" Mango ");

}

}

public class NestedInterface{

public static void main(String args[]){

Exinterface ex = new Exinterface();

ex.eat();

}

}

In this program we implements outer interface class with inner interface to use eat() method.

When we want to use msg()  method in class the program would be:

class Exinterface implements Displable{

    @Override

    public void msg() {

        System.out.print(" This is a Nested Interface example ");

    }

}

public class NestedInterface{

public static void main(String args[]){

Exinterface ex = new Exinterface();

ex.msg();

}

}