Sovraccarico del costruttore in entrata Java

In cosa consiste il sovraccarico del costruttore Java?

Java L'overload del costruttore è una tecnica in cui una classe può avere un numero qualsiasi di costruttori che differiscono nell'elenco dei parametri. Il compilatore differenzia questi costruttori tenendo conto del numero di parametri nell'elenco e del loro tipo.

Esempi di costruttori validi per la classe Account sono

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

esempio 2: Per comprendere il sovraccarico del costruttore Java

Passo 1) Digita il codice nell'editor.

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

Passo 2) Salva, compila ed esegui il codice.

Passo 3) Errore =?. Prova ad eseguire il debug dell'errore prima di procedere al passaggio successivo Java sovraccarico del costruttore

Passo 4) Ogni classe ha un valore predefinito Costruttore dentro Java. Costruttore sovraccaricato predefinito Java da classe Demo is dimostrazione(). Nel caso in cui non fornisci questo costruttore, il compilatore lo crea per te e inizializza le variabili sui valori predefiniti. Puoi scegliere di sovrascrivere questo costruttore predefinito e inizializzare le variabili sui valori desiderati come mostrato nell'Esempio 1.

Ma se specifichi un costruttore parametrizzato come Demo(int a) e desideri utilizzare il costruttore predefinito Java Demo(), è obbligatorio specificarlo.

In altre parole, nel caso in cui il costruttore in sovraccarico sia in Java viene sovrascritto e si desidera utilizzare il costruttore predefinito Java, è necessario specificarlo.

Passo 5) Decommenta la riga n. 4-8. Salva, compila ed esegui il codice.

Perché abbiamo bisogno del sovraccarico del costruttore in Java?

Sovraccarico del costruttore in Java consente più costruttori in una classe, ognuno con diversi elenchi di parametri. Aumenta la flessibilità e migliora l'efficienza del codice.

• Flessibilità nella creazione di oggetti: Il sovraccarico del costruttore consente di inizializzare gli oggetti in vari modi, a seconda del numero o del tipo di parametri.
• Riutilizzabilità del codice: È possibile riutilizzare la logica del costruttore chiamando un costruttore da un altro tramite la parola chiave this().
• Leggibilità migliorata: I costruttori sovraccarichi contribuiscono a rendere il codice più intuitivo offrendo opzioni di costruttori specifiche per diverse esigenze di inizializzazione.
• Inizializzazione predefinita e personalizzata: Il sovraccarico del costruttore consente di creare facilmente sia oggetti predefiniti che personalizzati.

Domande Frequenti

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