Konstruktør Overbelastning ind Java

Hvilken Constructor Overloading i Java?

Java Konstruktøroverbelastning er en teknik, hvor en klasse kan have et hvilket som helst antal konstruktører, der adskiller sig i parameterlisten. Compileren differentierer disse konstruktører ved at tage højde for antallet af parametre i listen og deres type.

Eksempler på gyldige konstruktører til klassekonto er

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

Eksempel 2: For at forstå Constructor Overloading i Java

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, kompilér og kør koden.

Trin 3) Fejl = ?. Prøv at fejlfinde fejlen, før du fortsætter til næste trin af Java konstruktør overbelastning

Trin 4) Hver klasse har en standard Konstruktør i Java. Standard overbelastet konstruktør Java forum klasse demo is Demo(). Hvis du ikke leverer denne konstruktør, opretter compileren den for dig og initialiserer variablerne til standardværdier. Du kan vælge at tilsidesætte denne standardkonstruktør og initialisere variabler til dine ønskede værdier som vist i eksempel 1.

Men hvis du angiver en parametriseret konstruktør som Demo(int a), og vil bruge standardkonstruktøren Java Demo(), det er obligatorisk for dig at angive det.

Med andre ord, i tilfælde af at din overbelastende konstruktør ind Java er tilsidesat, og du vil bruge standardkonstruktøren Java, det skal specificeres.

Trin 5) Fjern kommentar linje #4-8. Gem, kompilér og kør koden.

Hvorfor har vi brug for Constructor Overloading Java?

Konstruktør overbelaster ind Java tillader flere konstruktører i en klasse, der hver har forskellige parameterlister. Det øger fleksibiliteten og forbedrer kodeeffektiviteten.

• Fleksibilitet i objektoprettelse: Konstruktøroverbelastning giver dig mulighed for at initialisere objekter på forskellige måder, afhængigt af antallet eller typen af ​​parametre.
• Genanvendelighed af kode: Du kan genbruge konstruktørlogik ved at kalde en konstruktør fra en anden ved at bruge dette() nøgleordet.
• Forbedret læsbarhed: Overbelastede konstruktører hjælper med at gøre koden mere intuitiv ved at tilbyde specifikke konstruktørmuligheder til forskellige initialiseringsbehov.
• Standard og tilpasset initialisering: Constructor-overbelastning giver dig mulighed for nemt at oprette både standard- og brugerdefinerede initialiserede objekter.

Ofte Stillede Spørgsmål

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