कन्स्ट्रक्टर ओवरलोडिंग Java

कंस्ट्रक्टर ओवरलोडिंग क्या है? Java?

कन्स्ट्रक्टर ओवरलोडिंग Java यह एक ऐसी तकनीक है जिसमें एक क्लास कई कंस्ट्रक्टर घोषित करती है जो पैरामीटर सूची में भिन्न होते हैं। कंपाइलर पैरामीटरों की संख्या और उनके डेटा प्रकारों का विश्लेषण करके इन कंस्ट्रक्टरों में अंतर करता है।

क्लास के लिए मान्य कंस्ट्रक्टरों के उदाहरण लेखा नीचे दिखाए गए हैं:

Account(int a);
Account (int a,int b);
Account (String a,int b);

हमें कंस्ट्रक्टर ओवरलोडिंग की आवश्यकता क्यों है? Java?

कन्स्ट्रक्टर ओवरलोडिंग Java यह एक क्लास में कई कंस्ट्रक्टरों की अनुमति देकर लचीलापन और कोड दक्षता में सुधार करता है, जिनमें से प्रत्येक में एक अलग पैरामीटर सूची होती है।

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

उदाहरण: कंस्ट्रक्टर ओवरलोडिंग Java

निम्नलिखित उदाहरण में कंस्ट्रक्टर ओवरलोडिंग को दर्शाया गया है। Java एक क्लास का उपयोग करते हुए जिसका नाम है डेमो.

चरण 1) संपादक में कोड टाइप करें.

class Demo{
      int  value1;
      int  value2;
      /*Demo(){
       value1 = 10;
       value2 = 20;
       System.out.println("Inside 1st Constructor");
     }*/
     Demo(int a){
      value1 = a;
      System.out.println("Inside 2nd Constructor");
    }
    Demo(int a,int b){
    value1 = a;
    value2 = b;
    System.out.println("Inside 3rd Constructor");
   }
   public void display(){
      System.out.println("Value1 === "+value1);
      System.out.println("Value2 === "+value2);
  }
  public static void main(String args[]){
    Demo d1 = new Demo();
    Demo d2 = new Demo(30);
    Demo d3 = new Demo(30,40);
    d1.display();
    d2.display();
    d3.display();
 }
}

चरण 2) कोड को सेव करें, कंपाइल करें और रन करें।

चरण 3) एक त्रुटि दिखाई दे रही है। कंस्ट्रक्टर ओवरलोडिंग के अगले चरण पर आगे बढ़ने से पहले त्रुटि को ठीक करने का प्रयास करें। Java.

चरण 4) हर क्लास का एक डिफ़ॉल्ट होता है कंस्ट्रक्टर इन Java. डिफ़ॉल्ट कंस्ट्रक्टर क्लास डेमो is डेमो()यदि आप इसे प्रदान नहीं करते हैं, तो कंपाइलर इसे आपके लिए बनाता है और वेरिएबल्स को डिफ़ॉल्ट मानों से इनिशियलाइज़ करता है।

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

चरण 5) कोड की लाइन 4-8 से कमेंट हटा दें, फिर प्रोग्राम को सेव करें, कंपाइल करें और दोबारा चलाकर व्यवहार में बदलाव देखें।

कंस्ट्रक्टर चेनिंग में Java

एक परिदृश्य पर विचार करें जहां एक बेस क्लास को चाइल्ड द्वारा विस्तारित किया जाता है। जब भी चाइल्ड क्लास का कोई ऑब्जेक्ट बनाया जाता है, तो पैरेंट क्लास का कंस्ट्रक्टर सबसे पहले बुलाया जाता है। इसे कहा जाता है कंस्ट्रक्टर चेनिंग.

उदाहरण: कंस्ट्रक्टर ओवरलोडिंग के साथ कंस्ट्रक्टर चेनिंग को समझने के लिए Java

चरण 1) निम्नलिखित कोड को संपादक में कॉपी करें।

class Demo{
   int  value1;
   int  value2;
    Demo(){
      value1 = 1;
      value2 = 2;
      System.out.println("Inside 1st Parent Constructor");
   }
   Demo(int a){
      value1 = a;
      System.out.println("Inside 2nd Parent Constructor");
   }
  public void display(){
     System.out.println("Value1 === "+value1);
     System.out.println("Value2 === "+value2);
  }
  public static void main(String args[]){
     DemoChild d1 = new DemoChild();
     d1.display();
  }
}
class DemoChild extends Demo{
    int value3;
    int value4;
    DemoChild(){
    //super(5);
     value3 = 3;
     value4 = 4;
    System.out.println("Inside the Constructor of Child");
    }
    public void display(){
      System.out.println("Value1 === "+value1);
      System.out.println("Value2 === "+value2);
      System.out.println("Value1 === "+value3);
      System.out.println("Value2 === "+value4);
   }
}

चरण 2) कोड चलाएँ। कंस्ट्रक्टर चेनिंग के कारण, जब चाइल्ड क्लास का ऑब्जेक्ट डेमोचाइल्ड बनाया जाता है, कंस्ट्रक्टर डेमो() पैरेंट क्लास का कंस्ट्रक्टर पहले कॉल किया जाता है। डेमोचाइल्ड() बच्चा आगे दौड़ता है।

अपेक्षित उत्पादन:

Inside 1st Parent Constructor
Inside the Constructor of Child
Value1 === 1
Value2 === 2
Value1 === 3
Value2 === 4

चरण 3) आप देख सकते हैं कि पैरेंट कंस्ट्रक्टर डेमो() यह डिफ़ॉल्ट रूप से चलता है। ओवरलोडेड कंस्ट्रक्टर को कॉल करने के लिए। डेमो(इंट ए) इसके बजाय, कीवर्ड का उपयोग करें "उत्तम".

सिंटेक्स:

super();
--or--
super(parameter list);

उदाहरण: यदि आपका पैरेंट कंस्ट्रक्टर इस प्रकार है डेमो(स्ट्रिंग नाम, इंट ए), आप निर्दिष्ट करेंगे बहुत अच्छा("Java”,5)यदि उपयोग किया जाता है, तो कीवर्ड सुपर यह चाइल्ड क्लास के कंस्ट्रक्टर में कोड की पहली पंक्ति होनी चाहिए।

चरण 4) पंक्ति 26 से टिप्पणी हटाएँ और कोड चलाएँ। आउटपुट देखें।

आउटपुट:

Inside 2nd Parent Constructor
Inside the Constructor of Child
Value1 === 5
Value2 === 0
Value1 === 3
Value2 === 4

अक्सर पूछे जाने वाले प्रश्न