Konstruktör Överbelastning in Java

Vad är konstruktoröverbelastning i Java?

Konstruktör Överbelastning in Java är en teknik där en klass deklarerar flera konstruktorer som skiljer sig åt i parameterlistan. Kompilatorn differentierar dessa konstruktorer genom att analysera antalet parametrar och deras datatyper.

Exempel på giltiga konstruktorer för klassen Min sida visas nedan:

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

Varför behöver vi konstruktoröverbelastning i Java?

Konstruktör Överbelastning in Java förbättrar flexibiliteten och kodeffektiviteten genom att tillåta flera konstruktörer i en klass, var och en med en annan parameterlista.

• Flexibilitet vid objektskapande: Med konstruktoröverbelastning kan du initiera objekt på olika sätt, beroende på antalet eller typen av parametrar.
• Code Återanvändbarhet: Du kan återanvända konstruktorlogik genom att anropa en konstruktor från en annan med hjälp av detta() nyckelord.
• Förbättrad läsbarhet: Överbelastade konstruktörer gör kod mer intuitiv genom att erbjuda specifika alternativ för olika initialiseringsbehov.
• Standard och anpassad initiering: Med Constructor Overloading kan du enkelt skapa både standard- och anpassade initialiserade objekt.

Exempel: Konstruktoröverbelastning i Java

Följande exempel demonstrerar konstruktoröverbelastning i Java med hjälp av en klass som heter .

Steg 1) Skriv in koden i editorn.

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

Steg 2) Spara, kompilera och kör koden.

Steg 3) Ett fel visas. Försök att felsöka felet innan du fortsätter till nästa steg i Konstruktoröverbelastning i Java.

Steg 4) Varje klass har en standard Konstruktör i JavaStandardkonstruktorn för klass Demo is Demo()Om du inte anger den skapar kompilatorn den åt dig och initierar variablerna till standardvärdena.

Om du däremot anger en parametriserad konstruktor som Demo(int a) och vill använda standardinställningen Demo(), är det obligatoriskt att deklarera det uttryckligen.

Steg 5) Avkommentera raderna 4–8 i koden, spara, kompilera och kör sedan programmet igen för att observera beteendeförändringen.

Konstruktorkedja in Java

Tänk på ett scenario där en basklass utökas med ett barn. Närhelst ett objekt i den underordnade klassen skapas, anropas först den överordnade klassens konstruktor. Det här kallas Konstruktorkedja.

Exempel: För att förstå konstruktorkedja med konstruktoröverbelastning i Java

Steg 1) Kopiera följande kod till editorn.

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

Steg 2) Kör koden. På grund av konstruktorkedjan, när objektet för underklassen DemoChild skapas, konstruktorn Demo() av förälderklassen anropas först och konstruktorn DemoChild() av barnet springer härnäst.

Förväntad produktion:

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

Steg 3) Du kan observera att föräldrakonstruktorn Demo() körs som standard. För att anropa den överbelastade konstruktorn Demo(int a) använd istället nyckelordet "super".

Syntax:

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

Exempel: Om din föräldrakonstruktor är som Demo(Strängnamn, int a), kommer du att ange super("Java”,5). Om det används, nyckelordet super måste vara den första kodraden i konstruktorn för barnklassen.

Steg 4) Avkommentera rad 26 och kör koden. Observera utdata.

Produktion:

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

Vanliga frågor