जावा में निषिद्ध अधिभार या पुल के तरीके

तकनीकी पदों पर मेरे अधिकांश साक्षात्कारों में एक कार्य होता है जिसमें उम्मीदवार को एक ही कक्षा में 2 बहुत समान इंटरफेस लागू करने की आवश्यकता होती है:

यदि संभव हो तो दोनों इंटरफेस को एक कक्षा में लागू करें। यह बताएं कि यह क्यों संभव है या नहीं।

interface WithPrimitiveInt { void m(int i); } interface WithInteger { void m(Integer i); } 

अनुवादक से: यह लेख आपको एक साक्षात्कार में एक ही सवाल पूछने के लिए प्रोत्साहित नहीं करता है। लेकिन अगर आप पूरी तरह से तैयार होना चाहते हैं जब यह सवाल आपसे पूछा जाता है, तो बिल्ली का स्वागत करें।

कभी-कभी, जो आवेदक उत्तर के बारे में सुनिश्चित नहीं होते हैं, वे इस समस्या के बजाय निम्नलिखित स्थिति के साथ हल करना पसंद करते हैं (बाद में, किसी भी मामले में, मैं आपको इसे हल करने के लिए कहता हूं):

 interface S { String m(int i); } interface V { void m(int i); } 

वास्तव में, दूसरा कार्य बहुत सरल लगता है, और अधिकांश उम्मीदवार उत्तर देते हैं कि दोनों विधियों को एक ही कक्षा में शामिल करना असंभव है, क्योंकि हस्ताक्षर Sm(int) और Vm(int) समान हैं, जबकि वापसी मूल्य का प्रकार अलग है। और यह बिल्कुल सच है।

हालाँकि, कभी-कभी मैं इस विषय से संबंधित एक और प्रश्न पूछता हूं:

क्या आपको लगता है कि एक ही हस्ताक्षर के साथ तरीकों को लागू करने की अनुमति देना समझ में आता है लेकिन एक ही वर्ग में विभिन्न प्रकार? उदाहरण के लिए, JVM पर आधारित कुछ काल्पनिक भाषा में, या कम से कम JVM स्तर पर?

यह एक ऐसा प्रश्न है जिसका उत्तर अस्पष्ट है। लेकिन, इस तथ्य के बावजूद कि मुझे इसके उत्तर की उम्मीद नहीं है, सही उत्तर मौजूद है। एक व्यक्ति जो अक्सर प्रतिबिंब एपीआई के साथ व्यवहार करता है, वह बाईटकोड में हेरफेर करता है या जेवीएम विनिर्देश से परिचित होता है, इसका जवाब दे सकता है।

जावा विधि हस्ताक्षर और जेवीएम विधि संभाल

जावा विधि हस्ताक्षर (अर्थात विधि नाम और पैरामीटर प्रकार) का संकलन समय पर केवल जावा कंपाइलर द्वारा किया जाता है। बदले में, जेवीएम एक अयोग्य विधि नाम (अर्थात, बस एक विधि नाम) और एक विधि संभाल का उपयोग करके कक्षा में विधियों को अलग करता है, अर्थात विवरणक मापदंडों और एक वापसी विवरणक की सूची।

उदाहरण के लिए, यदि हम String m(int i) विधि को सीधे foo.Bar पर कॉल करना चाहते हैं। foo.Bar वर्ग के लिए, निम्नलिखित foo.Bar की आवश्यकता है:

 INVOKEVIRTUAL foo/Bar.m (I)Ljava/lang/String; 

और शून्य m(int i) निम्नलिखित हैं:

 INVOKEVIRTUAL foo/Bar.m (I)V 

इस प्रकार, JVM एक ही कक्षा में String m(int i) और void m(int i) साथ काफी सहज है। जरूरत है कि सभी इसी bytecode उत्पन्न करने के लिए है।

कुंग फू बायटेकोड के साथ

हमारे पास एस और वी इंटरफेस है, अब हम एक एसवी क्लास बनाएंगे जिसमें दोनों इंटरफेस शामिल होंगे। जावा में, अगर इसकी अनुमति थी, तो इसे इस तरह दिखना चाहिए:

 public class SV implements S, V { public void m(int i) { System.out.println("void m(int i)"); } public String m(int i) { System.out.println("String m(int i)"); return null; } } 

बाईटेकोड उत्पन्न करने के लिए, हम ऑब्जेक्टवेब एएसएम लाइब्रेरी का उपयोग करते हैं, एक निम्न-स्तरीय लाइब्रेरी जो कि बायोटेक जेवीएम का एक विचार प्राप्त करने के लिए पर्याप्त है।

पूर्ण स्रोत कोड GitHub पर अपलोड किया गया है, यहां मैं केवल सबसे महत्वपूर्ण अंशों को दूंगा और समझाऊंगा।

 ClassWriter cw = new ClassWriter(ClassWriter.COMPUTE_FRAMES); // package edio.java.experiments // public class SV implements S, V cw.visit(V1_7, ACC_PUBLIC, "edio/java/experiments/SV", null, "java/lang/Object", new String[]{ "edio/java/experiments/S", "edio/java/experiments/V" }); // constructor MethodVisitor constructor = cw.visitMethod(ACC_PUBLIC, "<init>", "()V", null, null); constructor.visitCode(); constructor.visitVarInsn(Opcodes.ALOAD, 0); constructor.visitMethodInsn(Opcodes.INVOKESPECIAL, "java/lang/Object", "<init>", "()V"); constructor.visitInsn(Opcodes.RETURN); constructor.visitMaxs(1, 1); constructor.visitEnd(); // public String m(int i) MethodVisitor mString = cw.visitMethod(ACC_PUBLIC, "m", "(I)Ljava/lang/String;", null, null); mString.visitCode(); mString.visitFieldInsn(Opcodes.GETSTATIC, "java/lang/System", "out", "Ljava/io/PrintStream;"); mString.visitLdcInsn("String"); mString.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/io/PrintStream", "println", "(Ljava/lang/String;)V"); mString.visitInsn(Opcodes.ACONST_NULL); mString.visitInsn(Opcodes.ARETURN); mString.visitMaxs(2, 2); mString.visitEnd(); // public void m(int i) MethodVisitor mVoid = cw.visitMethod(ACC_PUBLIC, "m", "(I)V", null, null); mVoid.visitFieldInsn(Opcodes.GETSTATIC, "java/lang/System", "out", "Ljava/io/PrintStream;"); mVoid.visitLdcInsn("void"); mVoid.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/io/PrintStream", "println", "(Ljava/lang/String;)V"); mVoid.visitInsn(Opcodes.RETURN); mVoid.visitMaxs(2, 2); mVoid.visitEnd(); cw.visitEnd(); 

आइए ClassWriter उत्पन्न करने के लिए एक ClassWriter बनाकर शुरू करें।

अब हम एक वर्ग घोषित करेंगे जिसमें इंटरफेस एस और वी शामिल हैं।

हालांकि एसवी के लिए हमारे संदर्भ छद्म जावा कोड में कंस्ट्रक्टर नहीं हैं, फिर भी हमें इसके लिए कोड तैयार करना होगा। यदि हम जावा में कंस्ट्रक्टर्स का वर्णन नहीं करते हैं, तो संकलक निहित रूप से एक खाली कंस्ट्रक्टर बनाता है।

विधियों के शरीर में, हम java.io.PrintStream के System.out फ़ील्ड को प्राप्त करके और इसे ऑपरेंड स्टैक में जोड़कर शुरू करते हैं। तब हम स्टैक पर स्थिरांक ( String या void ) लोड करते हैं और एक तर्क के रूप में एक स्ट्रिंग स्थिरांक के साथ परिणामी चर में println कमांड को कॉल करते हैं।

अंत में, String m(int i) स्टैक के मान null साथ संदर्भ प्रकार की निरंतरता को जोड़ते हैं और इसी प्रकार के return उपयोग करते return , अर्थात् ARETURN , विधि कॉल के आरंभकर्ता को मान वापस करने के लिए। void m(int i) आपको बिना वैल्यू लौटाए केवल विधि कॉल के आरंभकर्ता पर लौटने के लिए अनपिट RETURN का उपयोग करना होगा। यह सुनिश्चित करने के लिए कि बायटेकोड सही है (जो मैं लगातार करता हूं, त्रुटियों को कई बार सही करता है), हम डिस्क पर उत्पन्न वर्ग को लिखते हैं।

 Files.write(new File("/tmp/SV.class").toPath(), cw.toByteArray()); 

और jad (Java decompiler) का उपयोग करके बाइटकोड को जावा सोर्स कोड में वापस ट्रांसलेट करें:

 $ jad -p /tmp/SV.class The class file version is 51.0 (only 45.3, 46.0 and 47.0 are supported) // Decompiled by Jad v1.5.8e. Copyright 2001 Pavel Kouznetsov. // Jad home page: http://www.geocities.com/kpdus/jad.html // Decompiler options: packimports(3) package edio.java.experiments; import java.io.PrintStream; // Referenced classes of package edio.java.experiments: // S, V public class SV implements S, V { public SV() { } public String m(int i) { System.out.println("String"); return null; } public void m(int i) { System.out.println("void"); } } 

मेरी राय में बुरा नहीं है।

उत्पन्न वर्ग का उपयोग करना

जद का सफल jad अनिवार्य रूप से हमारे लिए कुछ नहीं की गारंटी देता है। jad यूटिलिटी आपको केवल बाइटकोड में आम समस्याओं के लिए अलर्ट करती है, फ्रेम साइज से लेकर लोकल वैरिएबल मिसमैच या गुम रिटर्न स्टेटमेंट तक।

रनटाइम पर उत्पन्न वर्ग का उपयोग करने के लिए, हमें किसी तरह इसे जेवीएम में लोड करना होगा और फिर इसे तुरंत करना होगा।

आइए अपने खुद के AsmClassLoader लागू करें। यह सिर्फ ClassLoader.defineClass लिए एक आसान आवरण है:

 public class AsmClassLoader extends ClassLoader { public Class defineAsmClass(String name, ClassWriter classWriter) { byte[] bytes = classWriter.toByteArray(); return defineClass(name, bytes, 0, bytes.length); } } 

अब इस क्लास लोडर का उपयोग करें और क्लास को तत्काल करें:

 ClassWriter cw = SVGenerator.generateClass(); AsmClassLoader classLoader = new AsmClassLoader(); Class<?> generatedClazz = classLoader.defineAsmClass(SVGenerator.SV_FQCN, cw); Object o = generatedClazz.newInstance(); 

चूँकि हमारी कक्षा रनटाइम पर जेनरेट होती है, इसलिए हम इसका उपयोग सोर्स कोड में नहीं कर सकते। लेकिन हम इसके प्रकार को लागू किए गए इंटरफेस में डाल सकते हैं। प्रतिबिंब के बिना कॉल इस तरह किया जा सकता है:

 ((S)o).m(1); ((V)o).m(1); 

कोड निष्पादित करते समय, हमें निम्न आउटपुट मिलते हैं:

 String void 

कुछ के लिए, यह निष्कर्ष अप्रत्याशित लग सकता है: हम कक्षा में उसी (जावा बिंदु के दृष्टिकोण से) विधि का संदर्भ देते हैं, लेकिन परिणाम उस इंटरफ़ेस के आधार पर भिन्न होते हैं जिसके लिए हम ऑब्जेक्ट लाए थे। तेजस्वी, सही?

यदि हम अंतर्निहित बायोटेक को ध्यान में रखते हैं तो सब कुछ स्पष्ट हो जाएगा। हमारे कॉल के लिए, कंपाइलर एक INVOKEINTERFACE स्टेटमेंट जेनरेट करता है, और मेथड हैंडल क्लास से नहीं, बल्कि इंटरफेस से आता है।

इस प्रकार, हमें मिलने वाली पहली कॉल:

 INVOKEINTERFACE edio/java/experiments/Sm (I)Ljava/lang/String; 

और दूसरे में:

 INVOKEINTERFACE edio/java/experiments/Vm (I)V 

जिस ऑब्जेक्ट पर हमने कॉल किया था वह स्टैक से प्राप्त किया जा सकता है। यह जावा में निहित बहुरूपता की शक्ति है।

उसका नाम सेतु विधि है

कोई पूछेगा: "तो इस सब का क्या मतलब है? क्या यह कभी काम आएगा?"

मुद्दा यह है कि हम नियमित जावा कोड लिखते समय एक ही चीज (अंतर्निहित) का उपयोग करते हैं। उदाहरण के लिए, सहसंयोजक वापसी प्रकार, जेनेरिक, और आंतरिक कक्षाओं से निजी क्षेत्रों तक पहुंच को बायटेकोड के एक ही जादू का उपयोग करके लागू किया जाता है।

इस इंटरफ़ेस पर एक नज़र डालें:

 public interface ZeroProvider { Number getZero(); } 

और सहसंयोजक प्रकार की वापसी के साथ इसका कार्यान्वयन:

 public class IntegerZero implements ZeroProvider { public Integer getZero() { return 0; } } 

अब इस कोड के बारे में सोचते हैं:

 IntegerZero iz = new IntegerZero(); iz.getZero(); ZeroProvider zp = iz; zp.getZero(); 

iz.getZero() , कॉल कंपाइलर हैंडल विधि ()Ljava/lang/Integer; साथ INVOKEVIRTUAL उत्पन्न करेगा ()Ljava/lang/Integer; , जबकि zp.getZero() यह विधि डिस्क्रिप्टर ()Ljava/lang/Number; साथ INVOKEINTERFACE उत्पन्न करेगा ()Ljava/lang/Number; । हम पहले से ही जानते हैं कि जेवीएम नाम और विधि डिस्क्रिप्टर का उपयोग करके ऑब्जेक्ट कॉल भेजता है। चूंकि वर्णनकर्ता अलग-अलग हैं, इसलिए इन 2 कॉलों को IntegerZero उदाहरण में एक ही विधि में रूट नहीं किया जा सकता है।

वास्तव में, कंपाइलर एक अतिरिक्त विधि उत्पन्न करता है जो क्लास में निर्दिष्ट वास्तविक विधि और इंटरफ़ेस के माध्यम से कॉल करते समय उपयोग की जाने वाली विधि के बीच एक सेतु का काम करता है। इसलिए नाम पुल विधि है। यदि यह जावा में संभव था, तो अंतिम कोड इस तरह दिखाई देगा:

 public class IntegerZero implements ZeroProvider { public Integer getZero() { return 0; } // This is a synthetic bridge method, which is present only in bytecode. // Java compiler wouldn't permit it. public Number getZero() { return this.getZero(); } } 

अंतभाषण

जावा प्रोग्रामिंग भाषा और जावा वर्चुअल मशीन एक ही बात नहीं है: हालांकि उनके पास नाम में एक सामान्य शब्द है और जेवीएम के लिए जावा मुख्य भाषा है, उनकी क्षमता और सीमाएं हमेशा समान हैं। जेवीएम को जानने से आपको जावा या किसी अन्य जेवीएम-आधारित भाषा को बेहतर ढंग से समझने में मदद मिलती है, लेकिन दूसरी ओर, जावा और उसके इतिहास को जानने से जेवीएम डिजाइन में कुछ निर्णयों को समझने में मदद मिलती है।

अनुवादक से

संगतता समस्याएं जल्द या बाद में किसी भी डेवलपर को चिंतित करने लगती हैं। मूल लेख जावा संकलक के निहित व्यवहार और अनुप्रयोगों पर इसके जादू के प्रभाव के महत्वपूर्ण मुद्दे पर छुआ है, जिसे हम, सीयूबीए प्लेटफ़ॉर्म फ्रेमवर्क के डेवलपर्स के रूप में, काफी परवाह करते हैं, यह सीधे पुस्तकालयों की संगतता को प्रभावित करता है। हाल ही में, हमने रिपोर्ट में येकातेरिनबर्ग में JUG में वास्तविक जीवन के अनुप्रयोगों में संगतता के बारे में बात की थी "एपीआई क्रॉसिंग पर नहीं बदलते हैं - एक स्थिर एपीआई का निर्माण कैसे करें", बैठक का वीडियो यहां पाया जा सकता है।