Konstruktør Overbelastning inn Java

Hva er konstruktøroverbelastning i Java?

Konstruktør Overbelastning inn Java er en teknikk der en klasse deklarerer flere konstruktører som har forskjellige parameterlister. Kompilatoren differensierer disse konstruktørene ved å analysere antall parametere 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 trenger vi konstruktøroverbelastning i Java?

Konstruktør Overbelastning inn Java forbedrer fleksibilitet og kodeeffektivitet ved å tillate flere konstruktører i en klasse, hver med en annen parameterliste.

• Fleksibilitet i objektoppretting: Med konstruktøroverbelastning kan du initialisere objekter på forskjellige måter, avhengig av antall eller type parametere.
• Code gjenbruk: Du kan gjenbruke konstruktørlogikk ved å kalle én konstruktør fra en annen ved hjelp av dette() søkeord.
• Forbedret lesbarhet: Overbelastede konstruktører gjør kode mer intuitiv ved å tilby spesifikke alternativer for ulike initialiseringsbehov.
• Standard og tilpasset initialisering: Med Constructor Overloading kan du enkelt opprette både standard og tilpassede initialiserte objekter.

Eksempel: Konstruktøroverbelastning i Java

Følgende eksempel demonstrerer konstruktøroverbelastning i Java bruker en klasse som heter demo.

Trinn 1) Skriv inn 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();
 }
}

Trinn 2) Lagre, kompiler og kjør koden.

Trinn 3) Det oppstår en feil. Prøv å feilsøke feilen før du går videre til neste trinn i Konstruktøroverbelastning i Java.

Trinn 4) Hver klasse har en standard Konstruktør i JavaStandardkonstruktøren for klasse Demo is Demo()Hvis du ikke oppgir den, oppretter kompilatoren den for deg og initialiserer variablene til standardverdier.

Men hvis du spesifiserer en parameterisert konstruktør som Demo(int a) og ønsker å bruke standardinnstillingen Demo(), er det obligatorisk å erklære det eksplisitt.

Trinn 5) Fjern kommenteringen fra linje 4–8 i koden, lagre, kompiler og kjør programmet på nytt for å observere endringen i virkemåte.

Konstruktørkjede inn Java

Tenk på et scenario der en grunnklasse utvides med et barn. Hver gang et objekt av den underordnede klassen opprettes, blir konstruktøren til den overordnede klassen påkalt først. Dette kalles Konstruktørkjede.

Eksempel: For å forstå konstruktørkjede med konstruktøroverbelastning i Java

Trinn 1) Kopier følgende kode inn 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);
   }
}

Trinn 2) Kjør koden. På grunn av konstruktørkjeden, når objektet til barneklassen DemoChild opprettes, konstruktøren Demo() av foreldreklassen kalles først, og konstruktøren DemoChild() av barnet løper neste gang.

Forventet utgang:

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

Trinn 3) Du kan observere at foreldrekonstruktøren Demo() kjører som standard. For å kalle den overbelastede konstruktøren Demo(int a) bruk heller nøkkelordet "super".

Syntaks:

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

Eksempel: Hvis foreldrekonstruktøren din er som Demo(Stringnavn, int a), vil du spesifisere super("Java”,5). Hvis brukt, søkeordet super må være den første kodelinjen i konstruktøren til barneklassen.

Trinn 4) Fjern kommentaren fra linje 26 og kjør koden. Observer resultatet.

Utgang:

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

Spørsmål og svar