coderz.py

In Java, an inner class is a class that is declared within another class or interface. To summarize, the same logically related classes as Java is purely object-oriented, bringing it closer to the real world.
It also has access to all the outer class’s members, including private data members and methods.

Syntax:

class Outer_Demo {
    //statements...
   class Inner_Demo {
      //statements...
   }
}

Why do we use inner classes?

The following are some advantages associated with the inner classes:

• Making code that is clean and readable.
• Private methods of the upper class can be accessed, adding a new dimension and bringing it closer to reality.
• The code module is being optimized.

Types of Inner classes:

• Non-static nested class (inner class)
  1. Member inner class
  2. Anonymous inner class
  3. Local inner class
• Static nested class

Examples:

Nested Inner Class :

class Outer {
    
 // Simple nested inner class
 class Inner {

  // show() method of inner class
  public void show()
  {

   // Print statement
  
   for(int i=0;i<5;i++)
   {
        for(int j=0;j<i;j++)
   {
        System.out.print(j+"");
   }
        System.out.println();
   }
    System.out.println("In a nested class method");
   
  }
 }
}

// Class 2
// Main class
class Coderz {

 // Main driver method
 public static void main(String[] args)
 {

  Outer.Inner in = new Outer().new Inner();

  // Calling show() method over above object created
  in.show();
 }
}

Output:

0
01
012
0123
In a nested class method

Local Inner Classes :

class Outer {

 // Method inside outer class
 void outerMethod()
 {

  // Print statement
  System.out.println("inside outerMethod");

 
  class Inner {

   // Method defined inside inner class
   void innerMethod()
   {

   
    System.out.println("inside innerMethod");
   }
  }

  // Creating object of inner class
  Inner y = new Inner();

  // Calling over method defined inside it
  y.innerMethod();
 }
}


class Coderz {

 // Main driver method
 public static void main(String[] args)
 {

 
  Outer x = new Outer();

 
  x.outerMethod();
 }
}

Output:

inside outerMethod
inside innerMethod

Static Nested Classes:

import java.util.*;

class Outer {

 private static void outerMethod()
 {

  // Print statement
  System.out.println("1. inside outerMethod");
 }


 // Static inner class
 static class Inner {

  public static void display()
  {

   // Print statement
   System.out.println("2. inside inner class Method");

   // Calling method inside main() method
   outerMethod();
  }
 }
}


// Main class
class Coderz {

 // Main driver method
 public static void main(String args[])
 {

  Outer.Inner obj = new Outer.Inner();

  // Calling method via above instance created
  obj.display();
 }
}

Output:

2. inside inner class Method
1. inside outerMethod

Anonymous Inner Class:

import java.util.*;


class Demo {

 
 void show()
 {
  // Print statement
  System.out.println(
   "1. show method of super class");
 }
}

// Class 2
// Main class
class Flavor1Demo {

 // An anonymous class with Demo as base class
 static Demo d = new Demo() {
 
  void show()
  {
   // Calling method show() via super keyword
   // which refers to parent class
   super.show();

   // Print statement
   System.out.println("2. Flavor1Demo class");
  }
 };

 // Method 2
 // Main driver method
 public static void main(String[] args)
 {
  // Calling show() method inside main() method
  d.show();
 }
}

Output:

1. show method of super class
2. Flavor1Demo class

Note: also read about the Java connectivity to MongoDB database

Follow Me

If you like my post, please follow me to read my latest post on programming and technology.

https://www.instagram.com/coderz.py/

https://www.facebook.com/coderz.py