Sovraccarico del costruttore in entrata Java

Che cos'è il sovraccarico del costruttore in Java?

Sovraccarico del costruttore in entrata Java È una tecnica in cui una classe dichiara più costruttori che differiscono per l'elenco dei parametri. Il compilatore distingue questi costruttori analizzando il numero di parametri e i loro tipi di dati.

Esempi di costruttori validi per la classe Account sono mostrati di seguito:

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

Perché abbiamo bisogno del sovraccarico del costruttore in Java?

Sovraccarico del costruttore in entrata Java Migliora la flessibilità e l'efficienza del codice consentendo la presenza di più costruttori in una classe, ognuno con un elenco di parametri differente.

• Flessibilità nella creazione di oggetti: L'overloading del costruttore consente di inizializzare gli oggetti in vari modi, a seconda del numero o del tipo di parametri.
• Code Riusabilità: È possibile riutilizzare la logica del costruttore richiamando un costruttore da un altro utilizzando il Questo() parola chiave.
• Leggibilità migliorata: I costruttori sovraccaricati rendono il codice più intuitivo offrendo opzioni specifiche per diverse esigenze di inizializzazione.
• Inizializzazione predefinita e personalizzata: L'overloading del costruttore consente di creare facilmente oggetti sia predefiniti che con inizializzazione personalizzata.

Esempio: Sovraccarico del costruttore in Java

L'esempio seguente dimostra l'overloading del costruttore in Java utilizzando una classe denominata Demo.

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) Si è verificato un errore. Prova a eseguire il debug dell'errore prima di procedere al passaggio successivo del sovraccarico del costruttore in Java.

Passo 4) Ogni classe ha un valore predefinito Costruttore dentro Java. Il costruttore predefinito per classe Demo is dimostrazione()Se non lo si specifica, il compilatore lo crea automaticamente e inizializza le variabili con i valori predefiniti.

Tuttavia, se si specifica un costruttore parametrizzato come Demo(int a) e voglio usare quello predefinito dimostrazione(), è obbligatorio dichiararlo esplicitamente.

Passo 5) Rimuovi il commento dalle righe 4-8 del codice, quindi salva, compila ed esegui nuovamente il programma per osservare la modifica del comportamento.

Concatenamento dei costruttori in Java

Considera uno scenario in cui una classe base viene estesa da un figlio. Ogni volta che viene creato un oggetto della classe figlia, viene invocato per primo il costruttore della classe genitore. Questo è chiamato Concatenamento dei costruttori.

Esempio: Per comprendere il concatenamento dei costruttori con l'overloading dei costruttori in Java

Passo 1) Copiare il seguente codice nell'editor.

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

Passo 2) Esegui il codice. A causa del concatenamento dei costruttori, quando l'oggetto della classe figlia DemoChild viene creato il costruttore dimostrazione() della classe padre viene invocato per primo e il costruttore DemoChild() del bambino corre accanto.

Uscita prevista:

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

Passo 3) Potresti osservare che il costruttore padre dimostrazione() viene eseguito per impostazione predefinita. Per chiamare il costruttore sovraccaricato Demo(int a) invece, usa la parola chiave "super".

Sintassi:

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

Esempio: Se il costruttore del tuo genitore è come Demo(String Name, int a), specificherai super("Java”,5). Se utilizzata, la parola chiave grande deve essere la prima riga di codice nel costruttore della classe figlia.

Passo 4) Rimuovi il commento dalla riga 26 ed esegui il codice. Osserva l'output.

Produzione:

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

DOMANDE FREQUENTI