Supraîncărcarea constructorului în Java

În ce supraîncărcare constructor Java?

Java Supraîncărcarea constructorului este o tehnică în care o clasă poate avea orice număr de constructori care diferă în lista de parametri. Compilatorul diferențiază acești constructori ținând cont de numărul de parametri din listă și de tipul acestora.

Exemple de constructori validi pentru clasa Account sunt

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

Exemplu 2: Pentru a înțelege supraîncărcarea constructorului în Java

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) Eroare = ?. Încercați să remediați eroarea înainte de a trece la pasul următor Java supraîncărcarea constructorului

Pas 4) Fiecare clasă are o valoare implicită Constructor în Java. Constructor implicit supraîncărcat Java pentru clasa Demo is Demo(). În cazul în care nu furnizați acest constructor, compilatorul îl creează pentru dvs. și inițializează variabilele la valorile implicite. Puteți alege să înlocuiți acest constructor implicit și să inițializați variabilele la valorile dorite, așa cum se arată în Exemplul 1.

Dar dacă specificați un constructor parametrizat precum Demo(int a) și doriți să utilizați constructorul implicit Java Demo(), este obligatoriu să-l specificați.

Cu alte cuvinte, în cazul în care constructorul dvs. de supraîncărcare în Java este suprascris și doriți să utilizați constructorul implicit Java, trebuie specificată.

Pas 5) Descomentați rândul # 4-8. Salvați, compilați și rulați codul.

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

Supraîncărcarea constructorului în Java permite mai mulți constructori într-o clasă, fiecare având liste de parametri diferite. Îmbunătățește flexibilitatea și îmbunătățește eficiența codului.

• Flexibilitate în crearea obiectelor: Supraîncărcarea constructorului vă permite să inițializați obiecte în diferite moduri, în funcție de numărul sau tipul de parametri.
• Reutilizarea codului: Puteți reutiliza logica constructorului apelând un constructor de la altul folosind cuvântul cheie this().
• Lizibilitate îmbunătățită: Constructorii supraîncărcați ajută la creșterea intuitivă a codului, oferind opțiuni specifice de constructor 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 personalizate inițiale.

Întrebări frecvente

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