एक गुमनाम वर्ग एक सुपरक्लास का विस्तार कैसे कर सकता है या एक इंटरफ़ेस लागू कर सकता है?
जवाबों:
बेनामी वर्गों को किसी भी अन्य जावा वर्ग की तरह कुछ का विस्तार या कार्यान्वयन करना चाहिए , भले ही वह बस हो java.lang.Object।
उदाहरण के लिए:
Runnable r = new Runnable() {
public void run() { ... }
};
यहां, rएक अनाम वर्ग की एक वस्तु है जो लागू करता है Runnable।
एक अनाम वर्ग एक ही वाक्यविन्यास का उपयोग करके दूसरे वर्ग का विस्तार कर सकता है:
SomeClass x = new SomeClass() {
...
};
आप जो नहीं कर सकते हैं वह एक से अधिक इंटरफ़ेस लागू है। आपको ऐसा करने के लिए एक नामित वर्ग की आवश्यकता है। न तो एक अनाम आंतरिक वर्ग, न ही एक नामित वर्ग, हालांकि, एक से अधिक वर्ग का विस्तार कर सकते हैं।
SomeClass। यह अभी भी गुमनाम है, के कारण है {...}।
एक अनाम वर्ग आमतौर पर एक इंटरफ़ेस लागू करता है:
new Runnable() { // implements Runnable!
public void run() {}
}
JFrame.addWindowListener( new WindowAdapter() { // extends class
} );
अगर आपको लगता है कि आप 2 या अधिक इंटरफेस लागू कर सकते हैं , तो मुझे लगता है कि यह संभव नहीं है। फिर आप एक निजी इंटरफ़ेस बना सकते हैं जो दोनों को जोड़ता है। हालांकि मैं आसानी से कल्पना नहीं कर सकता कि आप एक अनाम वर्ग क्यों चाहते हैं:
public class MyClass {
private interface MyInterface extends Runnable, WindowListener {
}
Runnable r = new MyInterface() {
// your anonymous class which implements 2 interaces
}
}
बेनामी कक्षाएं हमेशा सुपरक्लास या इम्प्लीमेंट इंटरफेस का विस्तार करती हैं। उदाहरण के लिए:
button.addActionListener(new ActionListener(){ // ActionListener is an interface
public void actionPerformed(ActionEvent e){
}
});
इसके अलावा, हालांकि अनाम वर्ग कई इंटरफेस को लागू नहीं कर सकता है, आप एक इंटरफ़ेस बना सकते हैं जो अन्य इंटरफ़ेस का विस्तार करता है और आपके अनाम वर्ग को इसे लागू करने देता है।
मुझे लगता है कि किसी को भी सवाल समझ में नहीं आया। मुझे लगता है कि इस आदमी को क्या चाहिए था कुछ इस तरह से:
return new (class implements MyInterface {
@Override
public void myInterfaceMethod() { /*do something*/ }
});
क्योंकि यह कई इंटरफ़ेस कार्यान्वयन जैसी चीजों की अनुमति देगा:
return new (class implements MyInterface, AnotherInterface {
@Override
public void myInterfaceMethod() { /*do something*/ }
@Override
public void anotherInterfaceMethod() { /*do something*/ }
});
यह वास्तव में वास्तव में अच्छा होगा; लेकिन यह जावा में अनुमति नहीं है ।
आप क्या कर सकते हैं विधि खंडों के अंदर स्थानीय कक्षाओं का उपयोग करें :
public AnotherInterface createAnotherInterface() {
class LocalClass implements MyInterface, AnotherInterface {
@Override
public void myInterfaceMethod() { /*do something*/ }
@Override
public void anotherInterfaceMethod() { /*do something*/ }
}
return new LocalClass();
}
// The interface
interface Blah {
void something();
}
...
// Something that expects an object implementing that interface
void chewOnIt(Blah b) {
b.something();
}
...
// Let's provide an object of an anonymous class
chewOnIt(
new Blah() {
@Override
void something() { System.out.println("Anonymous something!"); }
}
);
एक अनाम वर्ग उदाहरण के लिए अपनी वस्तु बनाते समय विस्तार या कार्यान्वित कर रहा है:
Interface in = new InterFace()
{
..............
}
यहां अनाम वर्ग इंटरफ़ेस लागू कर रहा है।
Class cl = new Class(){
.................
}
यहाँ अनाम वर्ग एक अमूर्त वर्ग का विस्तार कर रहा है।