प्रारंभिक और देर बाध्यकारी के बीच क्या अंतर है?

संकलित भाषाओं में, अंतर स्थिर है।

जावा:

//early binding:
public create_a_foo(*args) {
 return new Foo(args)
}
my_foo = create_a_foo();

//late binding:
public create_something(Class klass, *args) {
  klass.new_instance(args)
}
my_foo = create_something(Foo);

In the first example, the compiler can do all sorts of neat stuff at compile time. In the second, you just have to hope that whoever uses the method does so responsibly. (Of course, newer JVMs support the Class<? extends Foo> klass structure, which can greatly reduce this risk.)

एक अन्य लाभ यह है कि आईडीई कक्षा परिभाषा को हॉटलिंक कर सकते हैं, क्योंकि इसे विधि में सही घोषित किया गया है। Create_something (Foo) के लिए कॉल विधि परिभाषा से बहुत दूर बहुत हो सकता है, और यदि आप विधि परिभाषा को देख रहे हैं, तो कार्यान्वयन को देखना अच्छा लगेगा।

देर से बाध्यकारी का मुख्य लाभ यह है कि यह चीजों को नियंत्रण में आसान बनाता है, साथ ही पॉलिमॉर्फिज्म और बतख-टाइपिंग के कुछ अन्य उपयोग (यदि आपकी भाषा ऐसी चीजों का समर्थन करती है) बनाता है।

व्याख्या की गई भाषाओं में, अंतर थोड़ा और सूक्ष्म है।

माणिक:

# early binding:
def create_a_foo(*args)
  Foo.new(*args)
end
my_foo = create_a_foo

# late binding:
def create_something(klass, *args)
  klass.new(*args)
end
my_foo = create_something(Foo)

चूंकि रूबी (आमतौर पर) संकलित नहीं होती है, इसलिए निफ्टी अप-फ्रंट सामान करने के लिए एक कंपाइलर नहीं होता है। JRuby की वृद्धि का मतलब है कि इन दिनों अधिक रूबी संकलित किया गया है, हालांकि, यह ऊपर जावा की तरह अधिक कार्य करता है।

आईडीई के साथ समस्या अभी भी खड़ी है: ग्रहण की तरह एक प्लेटफॉर्म क्लास परिभाषाओं को देख सकता है यदि आप उन्हें हार्ड-कोड करते हैं, लेकिन यदि आप उन्हें कॉलर तक नहीं छोड़ सकते हैं।

रूबी में उलटा नियंत्रण बहुत लोकप्रिय नहीं है, संभवतः इसकी अत्यधिक रनटाइम लचीलापन के कारण, लेकिन रेल आपके आवेदन को प्राप्त करने के लिए आवश्यक कॉन्फ़िगरेशन की मात्रा को कम करने के लिए देर से बाध्यकारी का बहुत अच्छा उपयोग करता है।

Taken directly from http://word.mvps.org/fAQs/InterDev/EarlyvsLateBinding.htm

स्वचालन (या ओएलई स्वचालन) का उपयोग करने के दो तरीके हैं   प्रोग्रामेटिक रूप से दूसरे एप्लिकेशन को नियंत्रित करें।

     

लेट बाध्यकारी CreateObject का निर्माण और उदाहरण बनाने के लिए उपयोग करता है   एप्लिकेशन ऑब्जेक्ट, जिसे आप तब नियंत्रित कर सकते हैं। उदाहरण के लिए, बनाने के लिए   देर से बाध्यकारी का उपयोग कर एक्सेल का एक नया उदाहरण:

ऑब्जेक्ट के रूप में

  Dim oXL
 ओएक्सएल = CreateObject सेट करें ("एक्सेल। अनुप्रयोग")
 

     

दूसरी ओर, एक्सेल के मौजूदा उदाहरण में हस्तक्षेप करने के लिए (यदि   एक्सेल पहले से ही खुला है) आप GetObject का उपयोग करेंगे (भले ही   आप जल्दी या देर से बाइंडिंग का उपयोग कर रहे हैं):

ऑब्जेक्ट के रूप में

  Dim oXL
 ओएक्सएल = GetObject सेट करें (, "एक्सेल। आवेदन")
 

     

प्रारंभिक बाध्यकारी का उपयोग करने के लिए, आपको पहले अपने संदर्भ में एक सेट सेट करने की आवश्यकता है   उस एप्लिकेशन को प्रोजेक्ट करें जिसमें आप हेरफेर करना चाहते हैं। वीबी संपादक में   कोई भी कार्यालय अनुप्रयोग, या वीबी में, आप इसे चुनकर ऐसा करते हैं   उपकरण + संदर्भ, और उस एप्लिकेशन का चयन करना जिसे आप चाहते हैं   सूची (उदा।? माइक्रोसॉफ्ट एक्सेल 8.0 ऑब्जेक्ट लाइब्रेरी?)।

     

प्रारंभिक बाध्यकारी का उपयोग करके एक्सेल का नया उदाहरण बनाने के लिए:

  Dim oXL Excel के रूप में। अनुप्रयोग
 ओएक्सएल = नया एक्सेल सेट करें। आवेदन
 

     

किसी भी मामले में, आकस्मिक रूप से, आप पहले एक मौजूदा प्राप्त करने का प्रयास कर सकते हैं   एक्सेल का उदाहरण, और यदि यह कोई त्रुटि देता है, तो आप एक नया बना सकते हैं   उदाहरण आपके त्रुटि हैंडलर में।

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

हर्बर्ट शिलल्ट सी ++ पुस्तक से समान लेकिन अधिक विस्तृत उत्तर: -

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

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

public class child()
{    public void method1()
     {     System.out.println("child1");
     }
    public void method2()
     {     System.out.println("child2");
     }

}
public class teenager extends child()
{    public void method3()
     {      System.out.println("teenager3");
     }
}
public class adult extends teenager()
{     
    public void method1()
    {    System.out.println("adult1);
         super.method1();
     }
}


//In java
public static void main(String []args)
{    ((teenager)var).method1();
}

यह प्रिंट करेगा

adult1
child1

प्रारंभिक बाध्यकारी में कंपाइलर के पास सभी विधियों तक पहुंच होगी बच्चे और किशोरी में लेकिन देर से बाध्यकारी (रनटाइम पर) में, यह उन तरीकों की जांच करेगा जो ओवरराइड हैं चलने के समय पर।

इसलिए विधि 1 (बच्चे से - प्रारंभिक बाध्यकारी) रनटाइम पर वयस्क से विधि 1 द्वारा ओवरराइड किया जाएगा (देर से बाध्यकारी) फिर यह बच्चे से विधि 1 को लागू करेगा क्योंकि किशोरी में विधि 1 में कोई विधि 1 नहीं है।

ध्यान दें कि अगर बच्चे के पास कोई विधि नहीं है तो मुख्य में कोड संकलित नहीं होगा।

संकलन समय polymorphism को ओवरलोडिंग या प्रारंभिक बाध्यकारी या स्थैतिक बाध्यकारी भी कहा जाता है जब हमारे पास अलग-अलग व्यवहार के साथ एक ही विधि का नाम होता है। उसी विधि के एकाधिक प्रोटोटाइप को लागू करके और इसमें विभिन्न व्यवहार होते हैं। प्रारंभिक बाध्यकारी कार्यक्रम के पहले संकलन को संदर्भित करता है। लेकिन देर से बाइंडिंग ऑब्जेक्ट में रनटाइम प्रोग्राम में होता है। इसे गतिशील बाध्यकारी या ओवरराइडिंग या रनटाइम पॉलीमोर्फिज्म भी कहा जाता है।