Java में नेस्टेड इंटरफेस (Nested Interface)

हम किसी अन्य इंटरफेस या क्लास के अंदर एक इंटरफेस घोषित कर सकते हैं। ऐसे इंटरफेस को नेस्टेड इंटरफेस (Nested Interface) कहा जाता है।

नेस्टेड इंटरफेस को नियंत्रित करने वाले निम्नलिखित नियम हैं:

• एक इंटरफेस के भीतर घोषित नेस्टेड इंटरफेस public होना चाहिए।
• एक क्लास के भीतर घोषित नेस्टेड इंटरफेस का कोई भी एक्सेस मॉडिफायर हो सकता है।
• एक नेस्टेड इंटरफेस डिफ़ॉल्ट रूप से static होता है।

उदाहरण

class Animal {
    interface Activity {
        void move();
    }
}

class Dog implements Animal.Activity {
    public void move() {
        System.out.println("Dogs can walk and run");
    }
}

public class Tester {
    public static void main(String args[]) {
        Dog dog = new Dog();
        dog.move();
    }
}

आउटपुट

Dogs can walk and run

नेस्टेड इंटरफेस के प्रकार

1. इंटरफेस के अंदर इंटरफेस (Interface inside Interface)

interface OuterInterface {
    // अंतर्निहित रूप से public static
    interface InnerInterface {
        void innerMethod();
    }
    
    void outerMethod();
}

// उपयोग
class Implementation implements OuterInterface.InnerInterface {
    public void innerMethod() { ... }
}

2. क्लास के अंदर इंटरफेस (Interface inside Class)

class OuterClass {
    // कोई भी एक्सेस मॉडिफायर संभव
    private interface PrivateInterface { void doSomething(); }
    protected interface ProtectedInterface { void doSomething(); }
    public interface PublicInterface { void doSomething(); }
    
    // आंतरिक उपयोग के लिए प्राइवेट इंटरफेस
    private PrivateInterface createImplementation() {
        return new PrivateInterface() {
            public void doSomething() { ... }
        };
    }
}

// उपयोग (यदि public)
class External implements OuterClass.PublicInterface {
    public void doSomething() { ... }
}

नेस्टेड इंटरफेस के उपयोग

• नेमस्पेसिंग: संबंधित इंटरफेस समूहित करना (Map.Entry, Node.ListNode)
• एनकैप्सुलेशन: आंतरिक अनुबंध छिपाना (private/protected इंटरफेस)
• लॉजिकल ग्रुपिंग: क्लास/इंटरफेस से संबंधित कॉन्ट्रैक्ट्स को साथ रखना

प्रसिद्ध उदाहरण: Map.Entry

public interface Map {
    // नेस्टेड इंटरफेस
    interface Entry {
        K getKey();
        V getValue();
        V setValue(V value);
    }
    
    // ...
}

// उपयोग
Map map = new HashMap<>();
for (Map.Entry entry : map.entrySet()) {
    System.out.println(entry.getKey() + " = " + entry.getValue());
}

महत्वपूर्ण नियम सारांश

निष्कर्ष: नेस्टेड इंटरफेस संबंधित अनुबंधों को तार्किक रूप से समूहित करने, एनकैप्सुलेशन प्रदान करने और नेमस्पेस प्रबंधन में मदद करते हैं। वे डिफ़ॉल्ट रूप से static होते हैं। Map.Entry Java API में सबसे प्रसिद्ध उदाहरण है।