Konstruktör Överbelastning in Java

Vilken Constructor Overloading i Java?

Java Konstruktörsöverbelastning är en teknik där en klass kan ha hur många konstruktörer som helst som skiljer sig åt i parameterlistan. Kompilatorn särskiljer dessa konstruktörer genom att ta hänsyn till antalet parametrar i listan och deras typ.

Exempel på giltiga konstruktörer för klasskonto är

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

Exempelvis 2: För att förstå Constructor Overloading in Java

Steg 1) Skriv in koden i editorn.

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

Steg 2) Spara, kompilera och kör koden.

Steg 3) Fel = ?. Försök att felsöka felet innan du fortsätter till nästa steg av Java konstruktör överbelastning

Steg 4) Varje klass har en standard Konstruktör i Java. Standard överbelastad konstruktör Java för klass Demo is Demo(). Om du inte tillhandahåller denna konstruktor skapar kompilatorn den åt dig och initierar variablerna till standardvärden. Du kan välja att åsidosätta denna standardkonstruktor och initiera variabler till önskade värden som visas i exempel 1.

Men om du anger en parametriserad konstruktor som Demo(int a), och vill använda standardkonstruktorn Java Demo(), det är obligatoriskt för dig att ange det.

Med andra ord, ifall din överbelastningskonstruktör in Java åsidosätts och du vill använda standardkonstruktorn Java, det måste specificeras.

Steg 5) Avkommentera rad #4-8. Spara, kompilera och kör koden.

Varför behöver vi Constructor Overloading in Java?

Konstruktör överbelastas Java tillåter flera konstruktörer i en klass, som var och en har olika parameterlistor. Det förbättrar flexibiliteten och förbättrar kodeffektiviteten.

• Flexibilitet vid objektskapande: Konstruktörsöverbelastning låter dig initiera objekt på olika sätt, beroende på antalet eller typen av parametrar.
• Kodåteranvändbarhet: Du kan återanvända konstruktorlogik genom att anropa en konstruktor från en annan med nyckelordet this().
• Förbättrad läsbarhet: Överbelastade konstruktörer hjälper till att göra koden mer intuitiv genom att erbjuda specifika konstruktoralternativ för olika initialiseringsbehov.
• Standard och anpassad initiering: Konstruktörsöverbelastning gör att du enkelt kan skapa både standard- och anpassade initierade objekt.

Vanliga frågor

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