> Java > Nested Interface

Nested Interface in Java

Last Updated: 28 May, 2022

An interface defined inside another interface or a class is known as Nested Interface in Java. A nested interface is used to increase encapsulation It groups interfaces that are related or used in one place for more readable and maintainable code.

Nested Interface is always accessed outside with its outer interface or outer class name but it cannot be accessed outside directly.

For example, java.util.Map.Entry interface defined inside java.util.Map interface. We access it as Map.Entry, because Entry is a nested interface of Map Interface.

Let's have a look at the below-given syntax for more clarity.

Syntax: Nested Interface within an Interface and Class

  interface OuterInterface {  
    // Code
    interface NestedInterface {  
      // code  
    }  
  }

  class OuterClass {  
    // Code
    interface NestedInterface {  
      // code  
    }  
  }

There are the following important points about Nested Interface

The nested interface declared within an interface is public by default, but it can have any access modifier if declared inside the class.
Nested interfaces are declared as static by default.
Nested interface and outer interfaces both can have the same name methods and variables.
A class or interface can have any number of nested interfaces inside it.

Nested Interface within an Interface

Java allows to create an interface inside another interface, it must be accessed outside as OuterInterfaceName.NestedInterfaceName but not directly.

Example 1 : Nested Interface implementation within an Interface

  interface MyInterface {
    void method1();
    interface MyNestedInterface {
      void method2();
    }
  }
  
  // Implementing interface which contains nested interface inside it.
  class MyClass implements MyInterface {
    @Override
    public void method1() {
      System.out.println("Outer Interface - method1() called...");
  }
  
  // Implementing nested interface with the help of outer interface name
  class TestNestedInerface implements MyInterface.MyNestedInterface {
    @Override
    public void method2() {
      System.out.println("Nested Interface - method2() called...");
    }
  }
  
  public class NestedInterfaceInsideInterface {
    public static void main(String[] args) {
      // Creating the objects and calling the interfaces overridden method
      MyClass myClassObj = new MyClass();
      myClassObj.method1();
      
      TestNestedInerface testNestInObj = new TestNestedInerface();
      testNestInObj.method2();
    }
  }

Output

Outer Interface - method1() called...
Nested Interface - method2() called...

Nested Interface within a Class

Java allows to create an interface inside a class, it must be accessed outside as OuterClassName.NestedInterfaceName but not directly.

Example 2 : Nested Interface implementation within a Class

  class MyClass {
    interface MyNestedInterface {
      void myMethod();
    }
  }
  
  // Implementing nested interface with the help of outer class name
  class TestClass implements MyClass.MyNestedInterface {
    @Override
    public void myMethod() {
      System.out.println("MyNestedInterface - myMethod() called...");
    }
  }
  
  public class NestedInterfaceInsideClass {
    public static void main(String[] args) {
      TestClass testObj = new TestClass();
      testObj.myMethod();
    }
  }

Output

MyNestedInterface - myMethod() called...

That's all guys, hope this Java article is helpful for you.

Happy Learning... 😀

Please share this article on social media to help others.

If you have any query or suggestion regarding this artical please share with us
feedback@javabytechie.com

Nested Interface - Interview Questions and Answers

What are the benefits of using Nested Interface in Java?

Ans. Nested Interface provides the following benefits in Java programming:

It is a mechanism for logically grouping interfaces that are related or used in one place only.
It provides to write more readable and maintainable code in Java.
It increases encapsulation in Java programming.

How we can implement a nested interface outside the outer interface or outer class?

Nested Interface is always accessed outside with its outer interface or outer class name only. For example,
OuterInterfaceName.NestedInterfaceName
OuterClassName.NestedInterfaceName

Does the Java compiler create a separate .class file for nested interfaces?

Yes, the Java compiler creates a separate .class file for nested interfaces, whose name is made with a combination of outer and nested interface names with a $ sign in between.

How many nested interfaces we can create inside a class or interface?

There is no limitation, we can create any number of nested interfaces inside a class or interface in Java.

Can we define a class inside the interface?

Ans. Yes, Java allows defining a class inside the interface.

interface OuterInterfacce { class InnerClass{} }

Nested Interface in Java

Nested Interface within an Interface

Nested Interface within a Class

Nested Interface - Interview Questions and Answers

Nested Interface - Video