Konstruktorüberladung in Java

Was ist Konstruktorüberladung in Java?

Konstruktorüberladung in Java Dies ist eine Technik, bei der eine Klasse mehrere Konstruktoren deklariert, die sich in ihrer Parameterliste unterscheiden. Der Compiler unterscheidet diese Konstruktoren, indem er die Anzahl der Parameter und deren Datentypen analysiert.

Beispiele für gültige Konstruktoren für die Klasse Konto sind unten abgebildet:

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

Warum benötigen wir Konstruktorüberladung in Java?

Konstruktorüberladung in Java Verbessert die Flexibilität und Codeeffizienz, indem mehrere Konstruktoren in einer Klasse ermöglicht werden, von denen jeder eine andere Parameterliste hat.

• Flexibilität bei der Objekterstellung: Durch Konstruktorüberladung können Objekte auf verschiedene Arten initialisiert werden, abhängig von der Anzahl oder Art der Parameter.
• Code Wiederverwendbarkeit: Sie können die Logik von Konstruktoren wiederverwenden, indem Sie einen Konstruktor aus einem anderen aufrufen. diese() Stichwort.
• Verbesserte Lesbarkeit: Überladene Konstruktoren machen den Code intuitiver, indem sie spezifische Optionen für unterschiedliche Initialisierungsanforderungen bieten.
• Standard- und benutzerdefinierte Initialisierung: Durch Konstruktorüberladung lassen sich sowohl standardmäßig als auch benutzerdefiniert initialisierte Objekte einfach erstellen.

Beispiel: Konstruktorüberladung in Java

Das folgende Beispiel veranschaulicht die Konstruktorüberladung in Java mit einer Klasse namens Demo.

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) Den Code speichern, kompilieren und ausführen.

Schritt 3) Es ist ein Fehler aufgetreten. Versuchen Sie, den Fehler zu beheben, bevor Sie mit dem nächsten Schritt der Konstruktorüberladung fortfahren. Java.

Schritt 4) Jede Klasse hat einen Standardwert Konstrukteur in JavaDer Standardkonstruktor für Klasse Demo is Demo()Wenn Sie diese nicht angeben, erstellt der Compiler sie für Sie und initialisiert die Variablen mit Standardwerten.

Wenn Sie jedoch einen parametrisierten Konstruktor wie beispielsweise angeben Demo(int a) und möchten die Standardeinstellung verwenden Demo()Es ist zwingend erforderlich, dies explizit anzugeben.

Schritt 5) Entfernen Sie die Kommentarzeichen in den Zeilen 4-8 des Codes, speichern Sie das Programm, kompilieren Sie es und führen Sie es erneut aus, um die Verhaltensänderung zu beobachten.

Konstruktorverkettung in Java

Stellen Sie sich ein Szenario vor, in dem eine Basisklasse um ein untergeordnetes Element erweitert wird. Immer wenn ein Objekt der untergeordneten Klasse erstellt wird, wird zuerst der Konstruktor der übergeordneten Klasse aufgerufen. Das nennt man Konstruktorverkettung.

Ejemplo: Um die Konstruktorverkettung mit Konstruktorüberladung zu verstehen, Java

Schritt 1) Kopieren Sie den folgenden Code in den 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);
   }
}

Schritt 2) Führen Sie den Code aus. Aufgrund der Konstruktorverkettung wird beim Objekt der Kindklasse DemoChild wird erstellt, der Konstruktor Demo() Die Klasse der Elternklasse wird zuerst aufgerufen und der Konstruktor DemoChild() Das Kind läuft als nächstes.

Erwartete Ausgabe:

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

Schritt 3) Sie können feststellen, dass der übergeordnete Konstruktor Demo() Wird standardmäßig ausgeführt. Um den überladenen Konstruktor aufzurufen Demo(int a) Verwenden Sie stattdessen das Schlüsselwort "Super".

Syntax:

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

Ejemplo: Wenn Ihr Elternkonstruktor wie folgt aussieht Demo(String Name, int a), Sie werden angeben super("Java”,5). Falls verwendet, das Schlüsselwort super muss die erste Codezeile im Konstruktor der Kindklasse sein.

Schritt 4) Entfernen Sie die Kommentarzeichen in Zeile 26 und führen Sie den Code aus. Beobachten Sie die Ausgabe.

Ausgang:

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

Häufig gestellte Fragen