feat: Demonstrate nested interface implementation with Parent.Test and Child

WHAT the code does:
- Defines a class Parent containing a **nested interface** Test with a method show().
- Defines class Child that implements Parent.Test and provides a concrete implementation of show().
- In NestedInterface.main():
  - Declares a reference of type Parent.Test.
  - Creates an instance of Child and assigns it to the interface reference.
  - Calls show() on the reference, which executes Child’s implementation and prints "show method of interface".

WHY this matters:
- Demonstrates **nested interfaces**, where an interface is defined inside a class or interface.
- Nested interfaces provide scoping: Test is tied to Parent, so its full name is Parent.Test.
- Shows how nested interfaces can be used to group related behavior with their enclosing class, improving modularity.
- Illustrates polymorphism: Parent.Test reference holds a Child object, invoking overridden behavior at runtime.

HOW it works:
1. Parent defines Test interface inside its body.
2. Child implements Parent.Test, fulfilling the contract.
3. In main, Parent.Test obj acts as a reference to Child.
4. Calling obj.show() triggers Child’s show() method, demonstrating runtime polymorphism.

Tips and gotchas:
- Nested interfaces are implicitly static — they don’t require an instance of the enclosing class.
- Common in frameworks like Android: e.g., `View.OnClickListener` is a nested interface inside `View`.
- Use nested interfaces when the contract is strongly associated with the enclosing class, avoiding namespace pollution.
- Don’t overuse nested interfaces; if the interface is broadly applicable, define it at the top level instead.

Use-cases / analogies:
- Event listeners: Button.OnClickListener, where the listener interface is nested inside the Button class.
- Data structures: Map.Entry is a nested interface inside Map.
- Real-world analogy: A company (Parent) has job roles (nested interfaces) that employees (Child) must implement.

Short key: java-nested-interface parent-child polymorphism scoping modularity.

Signed-off-by: https://github.com/Someshdiwan <[email protected]>

Author: Someshdiwan

Section14Interfaces/src/NestedInterface.java

@@ -1,28 +1,5 @@
-/*
-https://www.geeksforgeeks.org/types-of-interfaces-in-java/?ref=asr9 IMP Link Open and read it.
-
-https://www.geeksforgeeks.org/interface-nested-class-another-interface/?ref=ml_lbp
-
-https://www.geeksforgeeks.org/match-lambdas-to-interfaces-in-java/?ref=asr8
-
-We can declare interfaces as members of a class or another interface. Such an interface is called a member interface or nested interface. Interfaces declared outside any class can have only public and default (package-private) access specifiers. In Java, nested interfaces (interfaces declared inside a class or another interface) can be declared with the public, protected, package-private (default), or private access specifiers.
-
-A nested interface can be declared public, protected, package-private (default), or private.
-A top-level interface (not nested) can only be declared as public or package-private (default). It cannot be declared as protected or private.
-
-Uses of Nested Interfaces
-In Java, nested interfaces can be used for a variety of purposes, including:
-
-To group related interfaces together: By nesting one interface within another, you can organize related interfaces in a more logical and readable way. This can make your code easier to understand and maintain.
-To create more secure code: By making an interface nested inside a class, you can limit its scope and prevent it from being accessed outside of that class. This can make your code more secure and less prone to errors.
-To implement multiple interfaces: By nesting interfaces, you can implement multiple interfaces in a single class, without cluttering up the global namespace with too many interface names.
-To create callbacks: Nested interfaces can be used to create callback functions, where an object can be passed to another object and that object can call back a method defined in the nested interface.
-To define a contract between classes: By using nested interfaces, you can define a contract between classes, where each class implements the same interface, but provides its own implementation. This can make your code more modular and easier to test.
-
-working of interface inside a class
-*/
-
 import java.util.*;
+
 class Parent {
 
     // Nested Interface
@@ -31,18 +8,14 @@ interface Test {
     }
 }
 
-// Child Class
 class Child implements Parent.Test {
-    public void show()
-    {
+    public void show() {
         System.out.println("show method of interface");
     }
 }
 
-class NestedInterface
-{
-    public static void main(String[] args)
-    {
+class NestedInterface {
+    public static void main(String[] args) {
         // instance of Parent class
         // with Nested Interface
         Parent.Test obj;
@@ -53,4 +26,49 @@ public static void main(String[] args)
         obj = t;
         obj.show();
     }
-}
+}
+
+/*
+https://www.geeksforgeeks.org/types-of-interfaces-in-java/?ref=asr9
+
+https://www.geeksforgeeks.org/interface-nested-class-another-interface/?ref=ml_lbp
+
+https://www.geeksforgeeks.org/match-lambdas-to-interfaces-in-java/?ref=asr8
+
+We can declare interfaces as members of a class or another interface. Such an interface is called a member interface or
+nested interface.
+
+Interfaces declared outside any class can have only public and default (package-private) access specifiers.
+
+In Java, nested interfaces (interfaces declared inside a class or another interface) can be declared with the public,
+protected, package-private (default), or private access specifiers.
+
+A nested interface can be declared public, protected, package-private (default), or private.
+A top-level interface (not nested) can only be declared as public or package-private (default).
+
+It cannot be declared as protected or private.
+
+Uses of Nested Interfaces:
+In Java, nested interfaces can be used for a variety of purposes, including:
+
+To group related interfaces together: By nesting one interface within another, you can organize related interfaces in a
+more logical and readable way. This can make your code easier to understand and maintain.
+
+To create more secure code: By making an interface nested inside a class, you can limit its scope and prevent it from
+being accessed outside of that class.
+
+This can make your code more secure and less prone to errors.
+
+To implement multiple interfaces: By nesting interfaces, you can implement multiple interfaces in a single class,
+without cluttering up the global namespace with too many interface names.
+
+To create callbacks: Nested interfaces can be used to create callback functions, where an object can be passed to another
+object and that object can call back a method defined in the nested interface.
+
+To define a contract between classes: By using nested interfaces, you can define a contract between classes,
+where each class implements the same interface, but provides its own implementation.
+
+This can make your code more modular and easier to test.
+
+working of interface inside a class
+*/