Overbelasting van de constructeur Java

Wat is constructoroverloading in Java?

Overbelasting van de constructeur Java Dit is een techniek waarbij een klasse meerdere constructors declareert die verschillen in de parameterlijst. De compiler onderscheidt deze constructors door het aantal parameters en hun gegevenstypen te analyseren.

Voorbeelden van geldige constructors voor een klasse Account worden hieronder weergegeven:

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

Waarom hebben we constructor-overloading nodig? Java?

Overbelasting van de constructeur Java Verbetert de flexibiliteit en code-efficiëntie door meerdere constructors in een klasse toe te staan, elk met een andere parameterlijst.

• Flexibiliteit bij het maken van objecten: Constructor-overloading maakt het mogelijk om objecten op verschillende manieren te initialiseren, afhankelijk van het aantal of het type parameters.
• Code Herbruikbaarheid: Je kunt de logica van constructors hergebruiken door de ene constructor vanuit een andere aan te roepen. dit() trefwoord.
• Verbeterde leesbaarheid: Overloaded constructors maken code intuïtiever doordat ze specifieke opties bieden voor verschillende initialisatiebehoeften.
• Standaard- en aangepaste initialisatie: Constructor-overloading maakt het mogelijk om zowel standaardobjecten als objecten met aangepaste initialisatie eenvoudig te creëren.

Voorbeeld: Constructoroverloading in Java

Het volgende voorbeeld demonstreert constructoroverloading in Java met behulp van een klasse genaamd .

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) Sla de code op, compileer deze en voer hem uit.

Stap 3) Er is een fout opgetreden. Probeer de fout op te sporen voordat u verdergaat met de volgende stap van Constructor Overloading. Java.

Stap 4) Elke klasse heeft een standaard Constructeur binnen JavaDe standaardconstructor voor klasse demo is Demonstratie()Als u deze niet opgeeft, maakt de compiler deze voor u aan en initialiseert de variabelen met standaardwaarden.

Als u echter een geparameteriseerde constructor zoals deze specificeert, Demo(int a) en willen de standaardinstellingen gebruiken Demonstratie()Het is verplicht om dit expliciet te vermelden.

Stap 5) Verwijder de commentaartekens bij regel 4-8 van de code, sla het bestand op, compileer het programma en voer het opnieuw uit om de verandering in het gedrag te observeren.

Constructor Chaining in Java

Beschouw een scenario waarin een basisklasse wordt uitgebreid met een kind. Telkens wanneer een object van de onderliggende klasse wordt gemaakt, wordt eerst de constructor van de bovenliggende klasse aangeroepen. Dit heet Constructor chaining.

Voorbeeld: Om constructor chaining met constructor overloading te begrijpen in Java

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

Stap 2) Voer de code uit. Vanwege constructor chaining, wanneer het object van de subklasse DemoChild wordt gecreëerd, de constructor Demonstratie() de constructor van de ouderklasse wordt eerst aangeroepen DemoChild() het kind rent vervolgens weg.

Verwachte resultaten:

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

Stap 3) U kunt opmerken dat de ouderconstructor Demonstratie() wordt standaard uitgevoerd. Om de overbelaste constructor aan te roepen Demo(int a) Gebruik in plaats daarvan het trefwoord "super".

Syntax:

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

Voorbeeld: Als de constructor van je ouder er zo uitziet: Demo(String Name, int a), zult u specificeren super("Java”,5). Indien gebruikt: het trefwoord super Dit moet de eerste regel code zijn in de constructor van de afgeleide klasse.

Stap 4) Verwijder het commentaar bij regel 26 en voer de code uit. Bekijk de uitvoer.

Output:

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

Veelgestelde vragen