Overbelasting van de constructeur Java

Welke constructoroverbelasting in Java?

Java Constructoroverbelasting is een techniek waarbij een klasse een willekeurig aantal constructors kan hebben die qua parameterlijst verschillen. De compiler onderscheidt deze constructors door rekening te houden met het aantal parameters in de lijst en hun type.

Voorbeelden van geldige constructoren voor de klasse Account zijn:

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

Voorbeeld 2: Om Constructor-overbelasting te begrijpen Java

Stap 1) Typ de code in de 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();
 }
}

Stap 2) Bewaar, compileer en voer de code uit.

Stap 3) Fout =?. Probeer de fout op te lossen voordat u doorgaat naar de volgende stap Java overbelasting van de constructeur

Stap 4) Elke klasse heeft een standaard Constructeur binnen Java. Standaard overbelaste constructor Java voor betere klasse demo is Demonstratie(). Als u deze constructor niet opgeeft, maakt de compiler deze voor u en initialiseert de variabelen naar standaardwaarden. U kunt ervoor kiezen om deze standaardconstructor te overschrijven en variabelen te initialiseren naar de gewenste waarden, zoals weergegeven in voorbeeld 1.

Maar als u een geparametriseerde constructor zoals Demo(int a) opgeeft en de standaardconstructor wilt gebruiken Java Demo(), het is verplicht dat u dit specificeert.

Met andere woorden, voor het geval uw overbelastende constructor in Java wordt overschreven en u wilt de standaardconstructor gebruiken Java, het moet worden gespecificeerd.

Stap 5) Verwijder commentaarregel # 4-8. Bewaar, compileer en voer de code uit.

Waarom hebben we Constructor Overloading nodig in Java?

Constructor overbelasting in Java staat meerdere constructors toe in een klasse, elk met verschillende parameterlijsten. Het vergroot de flexibiliteit en verbetert de code-efficiëntie.

• Flexibiliteit bij het maken van objecten: Met constructoroverloading kunt u objecten op verschillende manieren initialiseren, afhankelijk van het aantal of type parameters.
• Herbruikbaarheid van code: U kunt constructorlogica hergebruiken door de ene constructor vanuit de andere aan te roepen met behulp van het trefwoord this().
• Verbeterde leesbaarheid: Overbelaste constructors maken de code intuïtiever door specifieke constructoropties te bieden voor verschillende initialisatiebehoeften.
• Standaard- en aangepaste initialisatie: Dankzij constructoroverloading kunt u eenvoudig zowel standaardobjecten als aangepaste geïnitialiseerde objecten maken.

Veelgestelde vragen

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