Konstruktør Overbelastning ind Java

Hvad er konstruktøroverbelastning i Java?

Konstruktør Overbelastning ind Java er en teknik, hvor en klasse deklarerer flere konstruktører, der adskiller sig i parameterlisten. Compileren differentierer disse konstruktører ved at analysere antallet af parametre og deres datatyper.

Eksempler på gyldige konstruktører for klassen Konto er vist nedenfor:

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

Hvorfor har vi brug for konstruktøroverbelastning i Java?

Konstruktør Overbelastning ind Java forbedrer fleksibilitet og kodeeffektivitet ved at tillade flere konstruktører i en klasse, hver med en forskellig parameterliste.

• Fleksibilitet i objektoprettelse: Constructor Overloading giver dig mulighed for at initialisere objekter på forskellige måder, afhængigt af antallet eller typen af ​​parametre.
• Code Genanvendelighed: Du kan genbruge konstruktørlogik ved at kalde en konstruktør fra en anden ved hjælp af det her() nøgleord.
• Forbedret læsbarhed: Overbelastede konstruktører gør kode mere intuitiv ved at tilbyde specifikke muligheder for forskellige initialiseringsbehov.
• Standard og tilpasset initialisering: Med Constructor Overloading kan du nemt oprette både standard- og brugerdefinerede initialiserede objekter.

Eksempel: Konstruktøroverbelastning i Java

Følgende eksempel demonstrerer Constructor Overloading i Java ved hjælp af en klasse ved navn Demo.

Trin 1) Indtast koden i editoren.

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

Trin 2) Gem, kompiler og kør koden.

Trin 3) Der opstår en fejl. Prøv at foretage en fejlfinding, før du fortsætter til næste trin i Constructor Overloading i Java.

Trin 4) Hver klasse har en standard Konstruktør i JavaStandardkonstruktøren for klasse demo is Demo()Hvis du ikke angiver den, opretter compileren den for dig og initialiserer variablerne til standardværdier.

Men hvis du angiver en parameteriseret konstruktør som Demo(int a) og ønsker at bruge standardindstillingen Demo(), er det obligatorisk at deklarere det eksplicit.

Trin 5) Fjern kommentaren fra linje 4-8 i koden, gem, kompiler og kør derefter programmet igen for at observere ændringen i adfærd.

Konstruktørkæde i Java

Overvej et scenario, hvor en basisklasse udvides med et barn. Når et objekt af den underordnede klasse er oprettet, kaldes konstruktøren af ​​den overordnede klasse først. Dette kaldes Konstruktørkæde.

Eksempel: Forstå konstruktørkæde med konstruktøroverbelastning i Java

Trin 1) Kopier følgende kode ind i editoren.

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

Trin 2) Kør koden. På grund af konstruktørkæden, når objektet til den underordnede klasse DemoChild oprettes, konstruktøren Demo() af forældreklassen kaldes først, og konstruktøren DemoChild() af barnet løber derefter.

Forventet output:

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

Trin 3) Du kan observere, at den overordnede konstruktør Demo() kører som standard. For at kalde den overbelastede konstruktør Demo(int a) brug i stedet nøgleordet "super".

Syntaks:

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

Eksempel: Hvis din forældrekonstruktør er som Demo(Stringnavn, int a), vil du angive super(“Java”,5). Hvis det bruges, søgeordet super skal være den første kodelinje i konstruktøren af ​​​​underklassen.

Trin 4) Fjern kommentaren fra linje 26, og kør koden. Observer outputtet.

Output:

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

Ofte Stillede Spørgsmål