Supraîncărcarea constructorului în Java

Ce este supraîncărcarea constructorului în Java?

Supraîncărcarea constructorului în Java este o tehnică în care o clasă declară mai mulți constructori care diferă în lista de parametri. Compilatorul diferențiază acești constructori analizând numărul de parametri și tipurile lor de date.

Exemple de constructori validi pentru clasă Cont sunt prezentate mai jos:

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

De ce avem nevoie de supraîncărcarea constructorilor în Java?

Supraîncărcarea constructorului în Java îmbunătățește flexibilitatea și eficiența codului permițând mai mulți constructori într-o clasă, fiecare cu o listă de parametri diferită.

• Flexibilitate în crearea obiectelor: Supraîncărcarea constructorului vă permite să inițializați obiecte în diverse moduri, în funcție de numărul sau tipul parametrilor.
• Code Reutilizabilitate: Puteți reutiliza logica constructorului invocând un constructor din altul folosind acest() cuvinte cheie.
• Lizibilitate îmbunătățită: Constructorii supraîncărcați fac codul mai intuitiv oferind opțiuni specifice pentru diferite nevoi de inițializare.
• Inițializare implicită și personalizată: Supraîncărcarea constructorului vă permite să creați cu ușurință atât obiecte implicite, cât și obiecte inițializate personalizat.

Exemplu: Supraîncărcarea constructorului în Java

Următorul exemplu demonstrează supraîncărcarea constructorului în Java folosind o clasă numită Demo.

Pas 1) Tastați codul în 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();
 }
}

Pas 2) Salvați, compilați și rulați codul.

Pas 3) Apare o eroare. Încercați să depanați eroarea înainte de a trece la pasul următor al supraîncărcării constructorului în Java.

Pas 4) Fiecare clasă are o valoare implicită Constructor în JavaConstructorul implicit pentru clasa Demo is Demo()Dacă nu îl furnizați, compilatorul îl creează automat și inițializează variabilele la valorile implicite.

Totuși, dacă specificați un constructor parametrizat, cum ar fi Demo(int a) și doriți să utilizați implicit Demo(), este obligatorie declararea acestuia în mod explicit.

Pas 5) Decomentați liniile 4-8 din cod, apoi salvați, compilați și rulați din nou programul pentru a observa schimbarea de comportament.

Înlănțuirea constructorilor în Java

Luați în considerare un scenariu în care o clasă de bază este extinsă de un copil. Ori de câte ori este creat un obiect al clasei copil, constructorul clasei părinte este invocat mai întâi. Aceasta se numește Înlănțuirea constructorilor.

Exemplu: Pentru a înțelege înlănțuirea constructorilor cu supraîncărcarea constructorilor în Java

Pas 1) Copiați următorul cod în 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);
   }
}

Pas 2) Executați codul. Datorită înlănțuirii constructorilor, când obiectul clasei copil DemoChild este creat, constructorul Demo() din clasa părinte este invocat primul, iar constructorul DemoChild() al copilului aleargă următorul.

Ieșire preconizată:

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

Pas 3) Puteți observa că constructorul părinte Demo() rulează în mod implicit. Pentru a apela constructorul supraîncărcat Demo(int a) în schimb, folosește cuvântul cheie "super".

Sintaxă:

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

Exemplu: Dacă constructorul părinte este ca Demo(Nume șir, int a), vei specifica super("Java”,5). Dacă este utilizat, cuvântul cheie super trebuie să fie prima linie de cod din constructorul clasei copil.

Pas 4) Eliminați comentariile liniei 26 și rulați codul. Observați rezultatul.

ieșire:

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

Întrebări frecvente