Constructoroverbelasting 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 voor 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 codeur om een ​​constructor voor een klasse te schrijven.

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

• numerieke gegevenstypen zijn ingesteld op 0
• char datatypes zijn ingesteld op null character(‘\0’)
• referentievariabelen zijn ingesteld op null

In deze tutorial leer je-

• Regels voor het maken van een constructor
• Constructor overbelasting in Java
• Constructor Chaining

Regels voor het maken van een Java Constructor

1. Het heeft de dezelfde naam als de klas
2. Het mag geen waarde retourneren, zelfs niet void

Voorbeeld 1 :Maak uw eerste constructor in Java

Stap 1) Typ het volgende constructorprogramma in de 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 observeer de uitvoer.

Uitvoer:

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

Constructor overbelasting in Java

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

Voorbeelden van geldige constructors voor klasse Account zijn

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

Voorbeeld 2 :Constructor Overloading in Java 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 te debuggen voordat u doorgaat naar de volgende stap van Java-constructor overbelasting

Stap 4) Elke klasse heeft een standaard Constructor in Java. Standaard overbelaste constructor Java voor class Demo is Demo() . Als u deze constructor niet opgeeft, maakt de compiler deze voor u aan en initialiseert de variabelen naar de standaardwaarden. U kunt ervoor kiezen om deze standaardconstructor te negeren en variabelen te initialiseren naar uw gewenste waarden, zoals weergegeven in voorbeeld 1.

Maar als u een geparametriseerde constructor zoals Demo(int a) opgeeft en de standaardconstructor Java Demo() wilt gebruiken, moet u deze specificeren.

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) Uncomment regel # 4-8. Bewaar, compileer en voer de code uit.

Constructor Chaining

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

Voorbeeld 3: Constructor chaining begrijpen

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. Als gevolg van constructor chaining, wanneer het object van de onderliggende klasse DemoChild wordt gemaakt, wordt eerst de constructor Demo() van de bovenliggende klasse aangeroepen en later de constructor DemoChild() van de onderliggende klasse.

Verwachte output =

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

Stap 3) U kunt zien 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 “super” . gebruiken om overschreven constructors van de bovenliggende klasse aan te roepen.

Syntaxis:-

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

Voorbeeld: Als uw constructor is zoals Demo(String Name,int a) , specificeert u super(“Java”,5) . Indien gebruikt, moet het zoekwoord super de eerste regel code zijn in de constructor van de onderliggende klasse.

Stap 4) Uncomment regel # 26 en voer de code uit. Observeer de output.

Uitvoer:

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