Inner class in java

Inner class in java

A class which is a member of another class is called Inner class.
Inner classes are class within Class or Interface. Inner class instance has special relationship with Outer class. This special relationship allow to access member of outer class in Inner class as if they are the part of outer class.

Syntax of Inner class

//outer class
class OuterClass {
    //inner class
   class InnerClass {
    }
}

Note: Inner class instance has access to all member of the outer class(Public, Private & Protected)

There are basically four types of inner classes in java.
 

1. Nested Inner class 
2. Method Local inner
3. classes Anonymous inner
4. classes Static nested classes

1- Nested Inner class can access any private, protected, public and default modifier instance variable of outer class.
Like class, interface can also be nested and can have access specifiers.

Following example demonstrates a nested class.

class Outer {
   // Simple nested inner class
   class Inner {
      public void test() {
           System.out.println("In a nested class method test");
      }
   }
}

class Main {
   public static void main(String[] args) {
       Outer.Inner in = new Outer().new Inner();
       in.test();
   }
}

Output:

In a nested class method test

Note here -  we can’t have static method in a nested inner class because an inner class is implicitly associated with an object of its outer class so it cannot define any static method for itself. For example the following program doesn’t compile.

class Outer {
   void outerMethod() {
      System.out.println("inside outerMethod");
   }
   class Inner {
      public static void main(String[] args){
         System.out.println("inside inner class Method");
      }
   }
}

Output:

Error illegal static declaration in inner class 
Outer.Inner public static void main(String[] args) 
modifier ‘static’ is only allowed in constant 
variable declaration 

Note : An interface can also be nested and nested interfaces have some interesting properties. We will be covering nested interfaces in the next post.

2 -Method Local inner classes
When Inner class can be declared within a method of an outer class. In the following example, Inner is an inner class in outerMethod().

class Outer {
    void outerMethod() {
        System.out.println("inside outerMethod");
        // Inner class is local to outerMethod()
        class Inner {
            void innerMethod() {
                System.out.println("inside innerMethod");
            }
        }
        Inner y = new Inner();
        y.innerMethod();
    }
}

class MethodDemo {
    public static void main(String[] args) {
        Outer x = new Outer();
        x.outerMethod();
    }
}

Output

Inside outerMethod
Inside innerMethod

Method Local inner classes can’t use local variable of outer method until that local variable is not declared as final. For example, the following code generates compiler error (Note that x is not final in outerMethod() and innerMethod() tries to access it)

class Outer {
   void outerMethod() {
      int x = 98;
      System.out.println("inside outerMethod");
      class Inner {
         void innerMethod() {
            System.out.println("x= "+x);
         }
      }
      Inner y = new Inner();
      y.innerMethod();
   }
}

class MethodLocalVariableDemo {
   public static void main(String[] args) {

      Outer x=new Outer();
      x.outerMethod();

   }
}

But the following code compiles and runs fine (Note that x is final this time)

class Outer {
   void outerMethod() {
      final int x=98;
      System.out.println("inside outerMethod");

      class Inner {
         void innerMethod() {
            System.out.println("x = "+x);
         }
      }

      Inner y = new Inner();
      y.innerMethod();

   }
}

class MethodLocalVariableDemo {

    public static void main(String[] args){
      Outer x = new Outer();
      x.outerMethod();

    }
}

Run on IDE

Output-:

Inside outerMethod
X = 98 

The main reason we need to declare a local variable as a final is that local variable lives on stack till method is on the stack but there might be a case the object of inner class still lives on the heap.
Method local inner class can’t be marked as private, protected, static and transient but can be marked as abstract and final, but not both at the same time.

Static nested classes
Static nested classes are not technically an inner class. They are like a static member of outer class.

class Outer {
   private static void outerMethod() {
     System.out.println("inside outerMethod");
   }
  
   // A static inner class
   static class Inner {
     public static void main(String[] args) {

        System.out.println("inside inner class Method");
        outerMethod();

     }
   }
}

Output

inside inner class Method
inside outerMethod 

Anonymous inner classes
Anonymous inner classes are declared without any name at all. They are created in two ways.
a) As subclass of specified type

class Demo {
   void show() {
      System.out.println("i am in show method of super class");
   }
}

class Flavor1Demo {
   //  An anonymous class with Demo as base class
   static Demo d = new Demo() {

       void show() {

           super.show();

           System.out.println("i am in Flavor1Demo class");

       }

   };

   public static void main(String[] args){

       d.show();

   }

}

Output

i am in show method of super class
i am in Flavor1Demo class 

In the above code, we have two class Demo and Flavor1Demo. Here demo act as super class and anonymous class acts as a subclass, both classes have a method show(). In anonymous class show() method is overridden.

a) As implementer of the specified interface

i am in anonymous class

In above code we create an object of anonymous inner class but this anonymous inner class is an implementer of the interface Hello. Any anonymous inner class can implement only one interface at one time. It can either extend a class or implement interface at a time.