Konstruktorüberladung in Java

Was Konstruktor-Überladung in Java?

Java Konstruktorüberladung ist eine Technik, bei der eine Klasse eine beliebige Anzahl von Konstruktoren haben kann, die sich in der Parameterliste unterscheiden. Der Compiler unterscheidet diese Konstruktoren, indem er die Anzahl der Parameter in der Liste und ihren Typ berücksichtigt.

Beispiele für gültige Konstruktoren für die Klasse „Account“ sind

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

Beispiel 2: Um Konstruktor-Überladung zu verstehen in Java

Schritt 1) Geben Sie den Code in den Editor ein.

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

Schritt 2) Speichern, kompilieren und führen Sie den Code aus.

Schritt 3) Fehler = ?. Versuchen Sie, den Fehler zu beheben, bevor Sie mit dem nächsten Schritt fortfahren. Java Konstruktorüberladung

Schritt 4) Jede Klasse hat einen Standardwert Konstrukteur in Java. Standardmäßig überladener Konstruktor Java für Klasse Demo is Demo(). Falls Sie diesen Konstruktor nicht bereitstellen, erstellt der Compiler ihn für Sie und initialisiert die Variablen mit Standardwerten. Sie können diesen Standardkonstruktor überschreiben und Variablen mit Ihren gewünschten Werten initialisieren, wie in Beispiel 1 gezeigt.

Wenn Sie jedoch einen parametrisierten Konstruktor wie Demo(int a) angeben und den Standardkonstruktor verwenden möchten Java Demo(), Sie müssen es zwingend angeben.

Mit anderen Worten, falls Ihr überladener Konstruktor in Java überschrieben wird und Sie den Standardkonstruktor verwenden möchten Java, es muss angegeben werden.

Schritt 5) Kommentieren Sie Zeile Nr. 4-8 aus. Speichern, kompilieren und führen Sie den Code aus.

Warum brauchen wir Konstruktor-Überladung in Java?

Konstruktorüberladung in Java ermöglicht mehrere Konstruktoren in einer Klasse, von denen jeder unterschiedliche Parameterlisten hat. Dies erhöht die Flexibilität und verbessert die Codeeffizienz.

• Flexibilität bei der Objekterstellung: Durch die Konstruktorüberladung können Sie Objekte je nach Anzahl oder Typ der Parameter auf verschiedene Weise initialisieren.
• Code-Wiederverwendbarkeit: Sie können die Konstruktorlogik wiederverwenden, indem Sie mit dem Schlüsselwort this() einen Konstruktor von einem anderen aus aufrufen.
• Verbesserte Lesbarkeit: Überladene Konstruktoren tragen dazu bei, den Code intuitiver zu gestalten, indem sie spezifische Konstruktoroptionen für unterschiedliche Initialisierungsanforderungen anbieten.
• Standard- und benutzerdefinierte Initialisierung: Durch die Konstruktorüberladung können Sie problemlos sowohl standardmäßige als auch benutzerdefiniert initialisierte Objekte erstellen.

FAQs

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