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

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

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

क्लास अकाउंट के लिए वैध कंस्ट्रक्टर के उदाहरण हैं

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

उदाहरण 2: कंस्ट्रक्टर ओवरलोडिंग को समझने के लिए 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. डिफ़ॉल्ट ओवरलोडेड कन्स्ट्रक्टर Java एसटी क्लास डेमो is डेमो()यदि आप यह कन्स्ट्रक्टर प्रदान नहीं करते हैं तो कंपाइलर इसे आपके लिए बनाता है और वैरिएबल को डिफ़ॉल्ट मानों पर आरंभीकृत करता है। आप इस डिफ़ॉल्ट कन्स्ट्रक्टर को ओवरराइड करना चुन सकते हैं और वैरिएबल को अपने इच्छित मानों पर आरंभीकृत कर सकते हैं जैसा कि उदाहरण 1 में दिखाया गया है।

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

दूसरे शब्दों में, यदि आपका कन्स्ट्रक्टर ओवरलोड हो रहा है Java ओवरराइड किया गया है, और आप डिफ़ॉल्ट कन्स्ट्रक्टर का उपयोग करना चाहते हैं Java, इसकी आवश्यकता को निर्दिष्ट किया जाना चाहिए।

चरण 5) पंक्ति # 4-8 को अनकमेंट करें। कोड को सेव करें, संकलित करें और चलाएं।

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

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

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

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

class Demo{
      int  value1;
      int  value2;
      Demo(){
         value1 = 10;
         value2 = 20;
         System.out.println("Inside Constructor");
     }
 
     public void display(){
        System.out.println("Value1 === "+value1);
        System.out.println("Value2 === "+value2);
    }
 
   public static void main(String args[]){
       Demo d1 = new Demo();
      d1.display();
  }
}

Inside Constructor
Value1 === 10
Value2 === 20

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);
   }
}

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

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

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