Java में एनोनिमस इनर क्लास का उपयोग करके इंटरफेस कैसे इम्प्लीमेंट करें?

एक एनोनिमस इनर क्लास एक ऐसी क्लास है जिसका कोई नाम नहीं होता, हम इसे सीधे इंस्टेंशिएशन लाइन पर परिभाषित करते हैं।

उदाहरण

निम्न प्रोग्राम में, हम TutorialsPoint इंटरफेस के toString() मेथड को एनोनिमस इनर क्लास का उपयोग करके इम्प्लीमेंट कर रहे हैं, और इसके रिटर्न मान को प्रिंट कर रहे हैं।

interface TutorialsPoint {
    public String toString();
}

public class Main implements TutorialsPoint {
    public static void main(String[] args) {
        System.out.print(new TutorialsPoint() {
            @Override
            public String toString() {
                return "Welcome to Tutorials Point";
            }
        });
    }
}

आउटपुट

Welcome to Tutorials Point

कोड व्याख्या

interface TutorialsPoint - एक फंक्शनल इंटरफेस (सिंगल एब्स्ट्रैक्ट मेथड)।
new TutorialsPoint() { ... } - एनोनिमस क्लास निर्माण और इंस्टेंशिएशन एक साथ।
public String toString() { ... } - इंटरफेस के एब्स्ट्रैक्ट मेथड का कार्यान्वयन।
System.out.print(...) - एनोनिमस ऑब्जेक्ट पर toString() निहित रूप से कॉल होता है।

एनोनिमस क्लास के साथ इंटरफेस इम्प्लीमेंटेशन के सामान्य पैटर्न

1. Runnable (थ्रेडिंग)

new Thread(new Runnable() {
    @Override
    public void run() {
        System.out.println("Thread running: " + Thread.currentThread().getName());
    }
}).start();

2. ActionListener (GUI इवेंट्स)

button.addActionListener(new ActionListener() {
    @Override
    public void actionPerformed(ActionEvent e) {
        handleButtonClick();
    }
});

3. Comparator (सॉर्टिंग)

List people = Arrays.asList(
    new Person("Alice", 30),
    new Person("Bob", 25)
);

people.sort(new Comparator() {
    @Override
    public int compare(Person p1, Person p2) {
        return Integer.compare(p1.getAge(), p2.getAge());
    }
});

4. Callable/Runnable (ExecutorService)

ExecutorService executor = Executors.newSingleThreadExecutor();
Future future = executor.submit(new Callable() {
    @Override
    public String call() throws Exception {
        return "Task completed";
    }
});

Java 8+ : लैम्ब्डा एक्सप्रेशंस के साथ सरलीकरण

चूंकि ये सभी फंक्शनल इंटरफेस हैं (सिंगल एब्स्ट्रैक्ट मेथड), इन्हें लैम्ब्डा से बदला जा सकता है:

एनोनिमस क्लास	लैम्ब्डा एक्सप्रेशन
`new Runnable() { public void run() { ... } }`	`() -> { ... }`
`new ActionListener() { public void actionPerformed(e) { ... } }`	`e -> { ... }`
`new Comparator() { public int compare(a,b) { ... } }`	`(a, b) -> ...`
`new Callable() { public String call() { return "x"; } }`	`() -> "x"`

एनोनिमस क्लास कब उपयोग करें (लैम्ब्डा के बजाय)

इंटरफेस में एक से अधिक एब्स्ट्रैक्ट मेथड्स हों।
अतिरिक्त स्टेट (फील्ड्स) की आवश्यकता हो।
कंस्ट्रक्टर लॉजिक की आवश्यकता हो (इंस्टेंस इनिशियलाइजर ब्लॉक के माध्यम से)।
this रेफरेंस की आवश्यकता हो जो एनोनिमस क्लास इंस्टेंस को इंगित करे।
सीरियलाइजेशन आवश्यक हो।

// एकाधिक मेथड्स - लैम्ब्डा नहीं चलेगा
new MouseAdapter() {
    @Override
    public void mouseClicked(MouseEvent e) { ... }
    
    @Override
    public void mouseEntered(MouseEvent e) { ... }
    
    @Override
    public void mouseExited(MouseEvent e) { ... }
};

निष्कर्ष: एनोनिमस इनर क्लास इंटरफेस को त्वरित रूप से इम्प्लीमेंट करने का शक्तिशाली तरीका है। Java 8+ में फंक्शनल इंटरफेस के लिए लैम्ब्डा एक्सप्रेशंस को प्राथमिकता दें, लेकिन जटिल मामलों के लिए एनोनिमस क्लास अभी भी आवश्यक हैं।