Overbelasting van constructor in Java: wat is en programmavoorbeelden

Wat is Constructor in Java?

Constructeur is een speciale methode die wordt gebruikt om een ​​nieuw gemaakt object te initialiseren en wordt aangeroepen net nadat het geheugen aan het object is toegewezen. Het kan worden gebruikt om de objecten te initialiseren naar de gewenste waarden of standaardwaarden op het moment dat het object wordt gemaakt. Het is niet verplicht voor de codeerder om een ​​constructor voor een klasse te schrijven.

Als er geen door de gebruiker gedefinieerde constructor voor een klasse is opgegeven, initialiseert de compiler de lidvariabelen naar de standaardwaarden.

  • numerieke gegevenstypen zijn ingesteld op 0
  • char-gegevenstypen zijn ingesteld op nulteken('\0')
  • referentievariabelen zijn ingesteld op nul

In deze tutorial leer je-

Regels voor het maken van een Java-constructor

  1. Het heeft de zelfde naam als de klas
  2. Het mag geen waarde retourneren, zelfs niet komen te vervallen

Voorbeeld 1: Creëer uw eerste constructor in Java

Stap 1) Typ het volgendewing constructorprogramma in Java-editor.

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

Stap 2) Bewaar, voer en compileer het constructorprogramma in Java en bekijk de uitvoer.

Verwachte resultaten:

Inside Constructor
Value1 === 10
Value2 === 20

Constructor-overbelasting in Java

Overbelasting van Java Constructor 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 constructors voor de klasse Account zijn

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

Voorbeeld 2: Om Constructor-overbelasting in Java te begrijpen

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 van overbelasting van de Java-constructor

Stap 4) Elke klasse heeft een standaard Constructeur in Java. Standaard overbelaste constructor Java voor 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) specificeert en de standaardconstructor Java Demo() wilt gebruiken, is het verplicht dat u deze specificeert.

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

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

Constructeur ketenen

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 aaneenschakeling.

Voorbeeld 3: Constructor-chaining begrijpen

Stap 1) Kopieer het volgendewing 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. Owing voor het koppelen van constructors: wanneer het object van de onderliggende klasse DemoChild wordt gemaakt, wordt eerst de constructor Demo() van de bovenliggende klasse aangeroepen en later constructor DemoChild() van het kind wordt gemaakt.

Verwachte resultaten:

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

Stap 3) Het kan zijn dat de constructor van de bovenliggende klasse Demo wordt overschreven. Wat als u de overschreven constructor Demo(int a) wilt aanroepen in plaats van de standaardconstructor Demo() wanneer uw onderliggende object wordt gemaakt?

In dergelijke gevallen kunt u het trefwoord gebruiken "super" om overschreven constructors van de bovenliggende klasse aan te roepen.

Syntaxis:-

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

Voorbeeld: Als uw constructor zo is Demo(Stringnaam,int a), zult u specificeren super(“Java”,5). Indien gebruikt: het trefwoord super moet de eerste regel code zijn in de constructor van de onderliggende klasse.

Stap 4) Verwijder commentaar op regel # 26 en voer de code uit. Observeer de uitvoer.

Output:

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