Konstruktorüberladung in Java:Was ist &Programmbeispiele

Was ist Konstruktor in Java?

Konstruktor ist eine spezielle Methode, die zum Initialisieren eines neu erstellten Objekts verwendet wird und aufgerufen wird, nachdem der Speicher für das Objekt zugewiesen wurde. Es kann verwendet werden, um die Objekte zum Zeitpunkt der Objekterstellung auf gewünschte Werte oder Standardwerte zu initialisieren. Es ist für den Programmierer nicht zwingend erforderlich, einen Konstruktor für eine Klasse zu schreiben.

Wenn für eine Klasse kein benutzerdefinierter Konstruktor bereitgestellt wird, initialisiert der Compiler Mitgliedsvariablen auf ihre Standardwerte.

• Numerische Datentypen werden auf 0 gesetzt
• char-Datentypen werden auf Nullzeichen ('\0') gesetzt
• Referenzvariablen werden auf null gesetzt

In diesem Tutorial lernen Sie-

• Regeln zum Erstellen eines Konstruktors
• Konstruktorüberladung in Java
• Konstruktorverkettung

Regeln zum Erstellen eines Java-Konstruktors

1. Es hat den gleichen Namen als Klasse
2. Es sollte keinen Wert zurückgeben, nicht einmal void

Beispiel 1 :Erstellen Sie Ihren ersten Konstruktor in Java

Schritt 1) Geben Sie das folgende Konstruktorprogramm in den Java-Editor ein.

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

Schritt 2) Speichern, ausführen und kompilieren Sie das Konstruktorprogramm in Java und beobachten Sie die Ausgabe.

Ausgabe:

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

Konstruktorüberladung in Java

Das Überladen von Java-Konstruktoren 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 :Konstruktorüberladung in Java verstehen

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

Schritt 3) Fehler =?. Versuchen Sie, den Fehler zu beheben, bevor Sie mit dem nächsten Schritt des Überladens des Java-Konstruktors fortfahren

Schritt 4) Jede Klasse hat einen Standardkonstruktor in Java. Überladener Standardkonstruktor Java für Klasse Demo ist Demo() . Falls Sie diesen Konstruktor nicht bereitstellen, erstellt ihn der Compiler für Sie und initialisiert die Variablen auf Standardwerte. 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 Java Demo() verwenden möchten, müssen Sie ihn unbedingt angeben.

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

Schritt 5) Entkommentieren Sie Zeile 4-8. Code speichern, kompilieren und ausführen.

Konstruktorverkettung

Stellen Sie sich ein Szenario vor, in dem eine Basisklasse um ein untergeordnetes Element erweitert wird. Immer wenn ein Objekt der Kindklasse erstellt wird, wird zuerst der Konstruktor der Elternklasse aufgerufen. Dies wird als Konstruktorverkettung. bezeichnet

Beispiel 3: Konstruktorverkettung verstehen

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 Erstellen des Objekts der untergeordneten Klasse DemoChild zuerst der Konstruktor Demo() der übergeordneten Klasse aufgerufen und später der Konstruktor DemoChild() des untergeordneten Elements.

Erwartete Ausgabe =

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

Schritt 3) Sie können beobachten, dass der Konstruktor der übergeordneten Klasse Demo überschrieben wird. Was ist, wenn Sie den überschriebenen Konstruktor Demo(int a) anstelle des Standardkonstruktors Demo() aufrufen möchten, wenn Ihr untergeordnetes Objekt erstellt wird?

In solchen Fällen können Sie das Schlüsselwort „super“ verwenden um überschriebene Konstruktoren der Elternklasse aufzurufen.

Syntax:-

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

Beispiel: Wenn Ihr Konstruktor wie Demo(String Name,int a) ist , geben Sie super(“Java”,5) an . Falls verwendet, muss das Schlüsselwort super in der ersten Codezeile stehen im Konstruktor der untergeordneten Klasse.

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

Ausgabe:

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