Regular inner class

Normal (or) Regular inner class

If we are declaring any named class inside another class directly without static modifier such type of inner classes are called normal or regular inner classes.

class OuterClass {
   class InnerClass {

   }
}

When you compile the above code, compiler generates two classes named OuterClass.class and OuterClass$InnerClass.class.

package com.ashok.innerclasses;

/**
 * 
 * @author ashok.mariyala
 *
 */
public class OuterClass {
   class InnerClass {
   }
   public static void main(String[] args) {
      System.out.println("OuterClass main method");
   }
}

Output

java OuterClass 
OuterClass main method

java OuterClass$InnerClass
Exception in thread "main" java.lang.NoSuchMethodError:main

Inside inner class we can’t declare static members. Hence it is not possible to declare main() method and we can’t invoke inner class directly from the command prompt.

Accessing inner class code from static area of outer class
package com.ashok.innerclasses;

/**
 * 
 * @author ashok.mariyala
 *
 */
public class OuterClass {
   class InnerClass {
      private void m1() {
         System.out.println("Inside inner class");
      }
   }

   public static void main(String[] args) {
      OuterClass out = new OuterClass();
      OuterClass.InnerClass in = out.new InnerClass();
      in.m1();
      // Or
      OuterClass.InnerClass inn = new OuterClass().new InnerClass();
      inn.m1();
      // Or
      new OuterClass().new InnerClass().m1();
   }
}

Output

Inside inner class
Inside inner class
Inside inner class
Accessing inner class code from instance area of outer class
package com.ashok.innerclasses;

/**
 * 
 * @author ashok.mariyala
 *
 */
class OuterClass {
   class InnerClass {
      public void inner() {
         System.out.println("Inside InnerClass class method");
      }
   }

   public void outer() {
      InnerClass in = new InnerClass();
      in.inner();
   }

   public static void main(String[] args) {
      OuterClass out = new OuterClass();
      out.outer();
   }
}

Output

Inside InnerClass class method
Accessing inner class code from outside of outer class
package com.ashok.innerclasses;

/**
 * 
 * @author ashok.mariyala
 *
 */
class OuterClass {
   class InnerClass {
      public void inner() {
         System.out.println("Inside InnerClass method");
      }
   }
}

public class Test {
   public static void main(String[] args) {
      new OuterClass().new InnerClass().inner();
   }
}

Output

Inside InnerClass method

From inner class we can access all members of outer class (both static and non-static, private and non private methods and variables) directly.

package com.ashok.innerclasses;

/**
 * 
 * @author ashok.mariyala
 *
 */
public class OuterClass {
   String str = "Waytoeasylearn";
   static int y = 100;

   class InnerClass {
      public void inner() {
         System.out.println(str);// 10
         System.out.println(y);// 20
      }
   }

   public static void main(String[] args) {
      new OuterClass().new InnerClass().inner();
   }
}

Output

Waytoeasylearn
100

Within the inner class “this” always refers current inner class object. To refer current outer class object we have to use “outer class name.this”.

package com.ashok.innerclasses;
/**
 * 
 * @author ashok.mariyala
 *
 */
public class OuterClass {
   int x = 10;
   class InnerClass {
      int x = 100;
      public void inner() {
         int x = 1000;
         System.out.println(x);// 1000
         System.out.println(this.x);// 100
         System.out.println(OuterClass.this.x);// 10
      }
   }
   public static void main(String[] args) {
      new OuterClass().new InnerClass().inner();
   }
}

Output

1000
100
10

The applicable modifiers for outer classes are

  1. public
  2. default
  3. final
  4. abstract
  5. strictfp

But for the inner classes in addition to this the following modifiers also allowed.

  1. private
  2. protected
  3. static [static nested classes]
Nesting of Inner classes

We can declare an inner class inside another inner class.

package com.ashok.innerclasses;
/**
 * 
 * @author ashok.mariyala
 *
 */
public class OuterClass {
   class A {
      class B {
         private void method() {
            System.out.println("Welcome to Waytoeasylearn");
         }
      }
   }
 
   public static void main(String[] args) {
      OuterClass out = new OuterClass();
      OuterClass.A a = out.new A();
      OuterClass.A.B b = a.new B();
      b.method();
   }
}

Output

Welcome to Waytoeasylearn
Regular inner class


Scroll to top