एक nested class एक ऐसी class है जो किसी अन्य class के अंदर परिभाषित की जाती है। Java में चार प्रकार हैं — static nested, inner (non-static), local, और anonymous — प्रत्येक के पास enclosing class तक अलग-अलग access और अलग-अलग use cases हैं।
public class Outer {
private static int data = 10;
static class Nested { // static → no reference to an Outer INSTANCE
void show() {
System.out.println(data); // can access static members of Outer only
}
}
}
Outer.Nested n = new Outer.Nested(); // created without an Outer instance
एक static nested class एक top-level class की तरह व्यवहार करती है लेकिन outer class के अंदर namespaced होती है। यह किसी outer instance का reference नहीं रखती — helpers को समूहित करने के लिए उपयोग की जाती है (जैसे एक Builder, किसी data structure में Node)।
public class Outer {
private int value = 5;
class Inner { // non-static → has an implicit reference to Outer
void show() {
System.out.println(value); // can access Outer's INSTANCE members (even private)
}
}
}
Outer outer = new Outer();
Outer.Inner inner = outer.new Inner(); // needs an Outer instance to create
एक non-static inner class अपने enclosing instance का एक implicit reference रखती है, इसलिए यह outer object के instance fields को access कर सकती है। (सावधानी: यदि inner instance outer से अधिक समय तक जीवित रहता है तो यह reference memory leaks का कारण बन सकता है।)
void process() {
class Helper { // local to this method
void run() { ... }
}
new Helper().run();
}
शायद ही कभी उपयोग की जाती है; method तक scoped।
// implement an interface/abstract class inline, for single use
button.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) { handleClick(); }
});
Runnable task = new Runnable() {
public void run() { System.out.println("running"); }
};
एक anonymous class किसी interface या class का एक बार का implementation है, जिसे एक साथ परिभाषित और instantiate किया जाता है — ऐतिहासिक रूप से event handlers और callbacks के लिए आम। आधुनिक Java अक्सर इन्हें lambdas से बदलता है जब target एक functional interface हो:
button.addActionListener(e -> handleClick()); // ✅ lambda — much cleaner
Runnable task = () -> System.out.println("running");
Nested classes उन classes को तार्किक रूप से समूहित करने के लिए एक उपयोगी उपकरण हैं जो केवल एक संदर्भ में उपयोग की जाती हैं, encapsulation और पठनीयता बढ़ाते हुए।
प्रकारों को समझना — विशेष रूप से static-बनाम-inner अंतर (static = स्वतंत्र, inner = एक enclosing-instance reference रखती है) — design और bugs से बचने दोनों के लिए मायने रखता है: inner classes का implicit outer reference memory leaks का कारण बन सकता है, और जब आपको outer instance की आवश्यकता न हो तो static चुनना साफ-सुथरा default है।
Anonymous classes inline implementations (event handlers, comparators) प्रदान करने का classic तरीका थे, और यह जानना कि functional interfaces के लिए वे काफी हद तक lambdas द्वारा प्रतिस्थापित हो गई हैं, आधुनिक Java प्रवाह को दर्शाता है।
ये standard library में सर्वत्र दिखाई देती हैं (जैसे Map.Entry एक nested interface है, builders static nested classes हैं), जो उन्हें व्यावहारिक, अक्सर सामना किया जाने वाला ज्ञान बनाती हैं।
विस्तृत उत्तरों के साथ IT इंटरव्यू प्रश्नों की एक लाइब्रेरी — जूनियर से सीनियर तक।
दान करें