Nested Interfaces in Java

Similar to nested classes we have nested interfaces in java. An interface defined inside another interface or class is known as nested interface. Nested interface is also known as inner interfaces or member interfaces. Nested interfaces are generally used to group related interfaces. The syntax of declaring nested interface is :

 interface OuterInterfaceName { 
 
   interface InnerInterfaceName {
       // constant declarations   
       // Method declarations
    }
 }    
  
 Example :  
 
 interface MyInterface {
 
   interface MyInnerInterface {
      int id = 20;
      void print();
    }
 }        

Nested interface can be defined anywhere inside outer interface or class. Some of the key points about nested interfaces are :

• Nested interfaces are static by default, irrespective of you declare it static or not.
• Nested interfaces are accessed using outer interface or class name.
• Nested interfaces declared inside a class can have any access modifier, while nested interfaces declared inside another interfaces are public by default.
• Classes implementing inner interface are required to implement only inner interface methods, not outer interface methods.
• Classes implementing outer interface are required to implement only outer interface methods, not inner interface methods.

Nested interface program in Java

 interface MyInterface {
    void calculateArea();
    interface MyInnerInterface {
       int id = 20;
       void print();     
    }
  }
  
 class NestedInterface implements MyInterface.MyInnerInterface {   
    public void print() {
       System.out.println("Print method of nested interface");
     }    
    public static void main(String args []) {
       NestedInterface obj = new NestedInterface();
       obj.print();
       System.out.println(obj.id);
    }
 }           

Output:

As mentioned above nested interface can be declared inside a class as well. Class implementing such interface needs to define all the methods of that nested interface. The program below demonstrates the nested interface declared inside a class.

Java program of nested interface declared inside a class

 class OuterClass { 
    interface MyInnerInterface {
       int id = 20;
       void print();     
    }
  }
 
 class NestedInterfaceDemo implements OuterClass.MyInnerInterface {   
    public void print() {
       System.out.println("Print method of nested interface");
     }    
    public static void main(String args []) {
       NestedInterfaceDemo obj = new NestedInterfaceDemo();       
       obj.print();
       System.out.println(obj.id);
       // Assigning the object into nested interface type
       OuterClass.MyInnerInterface obj2 = new NestedInterfaceDemo();
       obj2.print();
    }
 }           

Output:

The object of implementing class can also be assigned in to nested interface type, as in above program obj2 is an object of NestedInterfaceDemo class but assigned into MyInnerInterface type.

As mentioned above class implementing an outer interface are not required to implement the inner or nested interface methods. The program below demonstrates the same.

 interface MyInterface {
    void calculateArea();
    interface MyInnerInterface {
       int id = 20;
       void print();     
     }
  }
 
 class OuterInterfaceTest implements MyInterface {   
    public void calculateArea() {
       System.out.println("Calculate area inside this method");
     }    
    public static void main(String args []) {
       OuterInterfaceTest obj = new OuterInterfaceTest();
       obj.calculateArea();
     }
 }           

Output:

Why do we use nested interface in java

There are couple of reasons for using nested interfaces in java :

• Nesting of interfaces is a way of logically grouping interfaces which are related or used at one place only.
• Nesting of interfaces helps to write more readable and maintainable code.
• It also increases encapsulation.

One example of nested interface in java library is java.util.Map.Entry interface defined inside java.util.Map interface. We access it as Map.Entry, as it's a nested interface.