अंतर वास्तविक समय उदाहरण

Question

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

मैं उलझन में हूँ, इसलिए किसी को समझाने क्या परावर्तन और लेट बाइंडिंग जावा में हैं कृपया कर सकते हैं, और यदि posible, मुझे दोनों में से कुछ वास्तविक दुनिया उदाहरण दे कृपया।

धन्यवाद ..

Answer 1

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

जब प्रतिबिंब कर रही है, आप भी नहीं जानते कि जो सदस्य आप उपयोग कर रहे (भी नहीं नाम संकलन समय पर जाना जाता है, अकेले हस्ताक्षर) - सब कुछ रन पर होता है समय, तो यह बहुत धीमी है।

Answer 2

जावा बहुरूपता समर्थन करने के लिए देर से बाध्यकारी उपयोग करता है; जिसका अर्थ है कि कई तरीकों का उपयोग किया जाना चाहिए, रनटाइम तक स्थगित कर दिया गया है।

एन कक्षाएं एक अंतरफलक के एक अमूर्त विधि (या एक अमूर्त वर्ग, Fwiw) को लागू करने के मामले हैं।

public interface IMyInterface { 

    public void doSomething();  
} 

public class MyClassA implements IMyInterface { 

    public void doSomething(){ ... } 
} 

public class MyClassB implements IMyInterface { 

    public void doSomething(){ ... } 
} 

public class Caller { 

    public void doCall(IMyInterface i){ 
     // which implementation of doSomething is called? 
     // it depends on the type of i: this is late binding 
     i.doSomething(); 
    } 
} 

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

प्रतिबिंब का एक बहुत अच्छा explaination यहाँ है: What is reflection and why is it useful?

Answer 3

रियल दुनिया उदाहरण:

आप jdesktop 0.9 के साथ jdesktop 0.8 के साथ अपनी परियोजना है, लेकिन जहाज निर्माण, तो अपने कोड अभी भी 0.9 सुविधाओं का उपयोग करेगा, क्योंकि यह देर से बाध्यकारी का लाभ लेता है, यानी कोड जो आपका कोड कॉल करता है वह संस्करण है जो क्लास लोडर द्वारा लोड किया गया है, चाहे वह संस्करण जिसे संकलित किया गया हो। (यह लिंकर्स के विपरीत है, जो एप्लिकेशन में कॉल किए गए कोड के संकलन-समय संस्करण को एम्बेड करते हैं।)

प्रतिबिंब के लिए, मान लें कि आप जावा 1.5 और 1.6 को लक्षित करने का प्रयास कर रहे हैं, लेकिन टैब घटक का उपयोग करना चाहते हैं 1.6 यदि वे उपलब्ध हैं, तो आप setTabComponentAt विधि खोजने के लिए JTabbedPane क्लास पर प्रतिबिंब का उपयोग कर अपनी उपस्थिति की जांच करेंगे। इस मामले में आप जावा 1.5 के खिलाफ निर्माण कर रहे हैं, जिसमें उन सुविधाओं को बिल्कुल नहीं है, इसलिए आप उन्हें सीधे कॉल नहीं कर सकते हैं या संकलन विफल हो जाएगा। हालांकि अगर अंत उपयोगकर्ता के सिस्टम पर आप 1.6 के खिलाफ दौड़ते हैं (देर से बाध्यकारी यहां खेलता है) तो आप कॉल विधियों के प्रति प्रतिबिंब का उपयोग कर सकते हैं जो 1.5 में मौजूद नहीं थे।

वे संबंधित हैं; प्रतिबिंब के कई उपयोग उपयोगी होने के लिए देर से बाध्यकारी पर भरोसा करते हैं, लेकिन वे मूल रूप से भाषा के विभिन्न पहलुओं और इसके कार्यान्वयन हैं।

Answer 4

"लेट बाइंडिंग" द्वारा संबोधित एक महत्वपूर्ण मुद्दा पॉलीमोर्फिज्म है, यानी कि आपके वर्ग पदानुक्रम के साथ उचित ओवर्रिडेन विधि का कॉल रन-टाइम के दौरान निर्धारित किया जाता है, संकलन के दौरान नहीं।प्रतिबिंब रन-टाइम के दौरान आपकी ऑब्जेक्ट्स के बारे में जानकारी इकट्ठा करने और उसका उपयोग करने की सुविधा है। जैसे आप रनटाइम के दौरान अपनी 'क्लास' विशेषता का उपयोग करके किसी ऑब्जेक्ट के सभी विशेषताओं या विधि नाम प्राप्त कर सकते हैं और उन विधियों को कॉल कर सकते हैं या इसके गुणों का उपयोग कर सकते हैं।

निम्नलिखित कोड में आप प्रतिबिंब के माध्यम से गतिशील रूप से एक नई वस्तु बना सकते हैं (देखें कि ऑब्जेक्ट obj = new MyClass ("MyInstance") जैसे कुछ का उपयोग करने के बजाय, कन्स्ट्रक्टर को पुनर्प्राप्त किया गया है और कक्षा का उपयोग करके कैसे पहुंचा जा सकता है। इसी तरह अन्य कन्स्ट्रक्टर फॉर्म, विधियों और विशेषताओं तक पहुंच बनाना संभव है। जावा यात्रा में प्रतिबिंब के बारे में अधिक जानकारी के लिए: -

हर कोई जावा देर के रूप में कार्यावधि में एक विधि कार्यान्वयन पर में शून्यीकरण के मामले में क्या करता है कॉल http://java.sun.com/developer/technicalArticles/ALT/Reflection/

 

... in some method of some class ... 
Class c = getClass(); 
Constructor ctor = c.getConstructor(String.class); 
Object obj = ctor.newInstance("MyInstance"); 
 

Answer 5

मैं यहाँ प्रतिक्रियाओं से अधिकांश के साथ सहमत नहीं है बाध्यकारी, लेकिन मेरी राय में यह जावा के लिए देर से बाध्यकारी शब्द का उपयोग करने के लिए सही नहीं है।

देर बाध्यकारी का मतलब संकलन समय पर विधि कॉल पर बिल्कुल कोई जांच नहीं है और विधि मौजूद नहीं होने पर कोई संकलन त्रुटियां नहीं हैं।

जावा हालांकि संकलन त्रुटि फेंक देगा यदि विधि विधि कॉल योग्यता के प्रकार के प्रकार पदानुक्रम में कहीं मौजूद नहीं है (यहां व्यवहार का वर्णन करते समय कुछ हद तक अनुमानित है)। यह शुद्ध पारंपरिक देर से बाध्यकारी नहीं है। सामान्य गैर-निजी गैर-स्थैतिक गैर-स्थिर विधि कॉल में जावा क्या करता है जिसे गतिशील प्रेषण के रूप में बेहतर माना जाएगा।
हालांकि अगर हम जावा में प्रतिबिंब का उपयोग करते हैं, तो जावा शुद्ध देर से बाध्यकारी करता है क्योंकि संकलक बस सत्यापित नहीं कर सकता है कि बुलाया गया तरीका मौजूद है या नहीं। यहाँ एक उदाहरण है:

class A 
{ 
    public void foo() 
    { 
     System.out.println("Foo from A"); 
    } 
} 

class B extends A 
{ 
    public void foo() 
    { 
     System.out.println("Foo from B"); 
    } 
} 
public class C 
{ 
    public static void main(String [] args) 
    { 
     A a=new A(); 
     B b=new B(); 
     A ref=null; 
     Class ref1 = null; 
     ref1 = b.getClass(); 
     ref.foo1();//will not compile because Java in this normal method 
     //call does some compile time checks for method and method 
     //signature existence. NOT late binding in its pure form. 
     try { 
      ref1.getMethod("foo1").invoke(null); //will throw a 
      //NoSuchMethodException at runtime, but compiles perfectly even 
      //though foo1 does not exist. This is pure late binding. 
     } catch (Exception e) { 
      // TODO Auto-generated catch block 
      e.printStackTrace(); 
     } 
     } 
}