संक्षिप्त उत्तर है: यह पूरी तरह से संभव है, लेकिन जावा ऐसा नहीं करता है।
यहां कुछ कोड दिए गए हैं जो वर्तमान स्थिति को दर्शाते हैं जावा में :
फ़ाइल Base.java:
package sp.trial;
public class Base {
static void printValue() {
System.out.println(" Called static Base method.");
}
void nonStatPrintValue() {
System.out.println(" Called non-static Base method.");
}
void nonLocalIndirectStatMethod() {
System.out.println(" Non-static calls overridden(?) static:");
System.out.print(" ");
this.printValue();
}
}
फ़ाइल Child.java:
package sp.trial;
public class Child extends Base {
static void printValue() {
System.out.println(" Called static Child method.");
}
void nonStatPrintValue() {
System.out.println(" Called non-static Child method.");
}
void localIndirectStatMethod() {
System.out.println(" Non-static calls own static:");
System.out.print(" ");
printValue();
}
public static void main(String[] args) {
System.out.println("Object: static type Base; runtime type Child:");
Base base = new Child();
base.printValue();
base.nonStatPrintValue();
System.out.println("Object: static type Child; runtime type Child:");
Child child = new Child();
child.printValue();
child.nonStatPrintValue();
System.out.println("Class: Child static call:");
Child.printValue();
System.out.println("Class: Base static call:");
Base.printValue();
System.out.println("Object: static/runtime type Child -- call static from non-static method of Child:");
child.localIndirectStatMethod();
System.out.println("Object: static/runtime type Child -- call static from non-static method of Base:");
child.nonLocalIndirectStatMethod();
}
}
यदि आप इसे चलाते हैं (मैंने इसे मैक पर किया था, ग्रहण से, जावा 1.6 का उपयोग करके) आपको मिलता है:
Object: static type Base; runtime type Child.
Called static Base method.
Called non-static Child method.
Object: static type Child; runtime type Child.
Called static Child method.
Called non-static Child method.
Class: Child static call.
Called static Child method.
Class: Base static call.
Called static Base method.
Object: static/runtime type Child -- call static from non-static method of Child.
Non-static calls own static.
Called static Child method.
Object: static/runtime type Child -- call static from non-static method of Base.
Non-static calls overridden(?) static.
Called static Base method.
यहाँ, केवल वे मामले जो आश्चर्यचकित कर सकते हैं (और जो प्रश्न के बारे में है) पहला मामला प्रतीत होता है :
"रन-टाइम प्रकार का उपयोग यह निर्धारित करने के लिए नहीं किया जाता है कि कौन से स्थिर तरीके कहलाते हैं, यहां तक कि जब ऑब्जेक्ट ऑब्जेक्ट ( obj.staticMethod()) के साथ कहा जाता है ।"
और अंतिम मामला:
"जब किसी क्लास के ऑब्जेक्ट मेथड से स्टैटिक मेथड को कॉल किया जाता है, तो जो स्टैटिक मेथड चुना जाता है वह क्लास से ही ऐक्सेस होता है ना कि क्लास से ऑब्जेक्ट के रन-टाइम टाइप को डिफाइन करता है।"
किसी वस्तु उदाहरण के साथ कॉल करना
स्थिर कॉल को संकलन-समय पर हल किया जाता है, जबकि रन-टाइम में एक गैर-स्थिर पद्धति कॉल को हल किया जाता है। ध्यान दें कि यद्यपि स्थैतिक विधियाँ विरासत में मिली हैं (अभिभावक से) उन्हें अधिभूत नहीं किया गया है (बच्चे द्वारा) जाता है। यदि आप अन्यथा की उम्मीद करते हैं तो यह आश्चर्य की बात हो सकती है।
किसी वस्तु विधि के भीतर से कॉल करना
रन-टाइम प्रकार का उपयोग करके ऑब्जेक्ट विधि कॉल का समाधान किया जाता है, लेकिन स्टैटिक ( क्लास ) विधि कॉल का संकलन-समय (घोषित) प्रकार का उपयोग करके हल किया जाता है।
नियमों में बदलाव
इन नियमों को बदलने के लिए, ताकि अंतिम उदाहरण में कॉल किया जा सके Child.printValue() , स्टैटिक कॉल को रन-टाइम पर एक प्रकार के साथ प्रदान करना होगा, बजाय संकलक के ऑब्जेक्ट के घोषित वर्ग के साथ संकलन-समय पर कॉल को हल करना (या संदर्भ)। स्टैटिक कॉल तब कॉल को हल करने के लिए (डायनामिक) प्रकार पदानुक्रम का उपयोग कर सकते थे, जैसे कि ऑब्जेक्ट मेथड कॉल आज करते हैं।
यह आसानी से संभव होगा (यदि हमने जावा: -ओ को बदल दिया है), और यह अनुचित नहीं है, हालांकि, इसके कुछ दिलचस्प विचार हैं।
मुख्य विचार यह है कि हमें यह तय करने की आवश्यकता है कि कौन सी स्थिर विधि कॉल को ऐसा करना चाहिए।
फिलहाल, जावा में यह "quirk" भाषा है जिसमें obj.staticMethod()कॉल को ObjectClass.staticMethod()कॉल द्वारा प्रतिस्थापित किया जाता है (आमतौर पर एक चेतावनी के साथ)। [ नोट: ObjectClass संकलन-समय का प्रकार है obj।] इस तरह से ओवरराइड करने के लिए अच्छे उम्मीदवार होंगे, जो रन-टाइम प्रकार का है obj।
अगर हमने ऐसा किया है तो यह विधि निकायों को पढ़ने के लिए कठिन बना देगा: माता-पिता वर्ग में स्थिर कॉल संभवतः गतिशील रूप से "पुन: रूट किए गए" हो सकते हैं। इससे बचने के लिए हमें स्टैटिक विधि को एक क्लास नाम के साथ कॉल करना होगा - और इससे कॉल्स को स्पष्ट रूप से कंपाइल-टाइम टाइप पदानुक्रम (अब) के साथ हल किया जाता है।
स्थैतिक विधि को लागू करने के अन्य तरीके अधिक मुश्किल हैं: this.staticMethod()इसका मतलब उसी तरह होना चाहिए obj.staticMethod(), जैसे कि रन-टाइम प्रकार this। हालांकि, इससे मौजूदा कार्यक्रमों के साथ कुछ सिरदर्द हो सकते हैं, जो सजावट के बिना (जाहिरा तौर पर स्थानीय) स्थिर तरीकों को कॉल करते हैं (जो यकीनन इसके बराबर है this.method())।
तो अनजाने कॉल के बारे में क्या staticMethod()? मेरा सुझाव है कि वे आज की तरह ही करें, और स्थानीय वर्ग के संदर्भ का उपयोग करके यह तय करें कि क्या करना है। अन्यथा बहुत भ्रम पैदा होता। बेशक इसका मतलब यह है कि अगर कोई गैर-स्थैतिक विधि थी, और अगर एक स्थैतिक विधि थी, तो method()इसका मतलब होगा । यह भ्रम का एक और स्रोत है।this.method()methodThisClass.method()method
अन्य बातें
यदि हमने इस व्यवहार को बदल दिया (और स्थैतिक रूप से गतिशील रूप से गैर-स्थानीय कॉल किया गया), तो हम शायद इसका अर्थ फिर से समझना चाहेंगे final , privateऔर protectedक्वालिफायर के रूप में पर staticएक वर्ग के तरीके। हम तो सब तथ्य यह है कि करने के लिए इस्तेमाल करने के लिए होता है private staticऔर public finalतरीकों ओवरराइड नहीं कर रहे हैं, और इसलिए सुरक्षित रूप से संकलन समय पर हल किया जा सकता है, और "सुरक्षित" स्थानीय संदर्भ के रूप में पढ़ने के लिए कर रहे हैं।