Überladen eines Konstruktors in Java

1. Standardkonstruktor in Java
2. Parametrisierter Konstruktor in Java
3. Code ohne Konstruktor-Überladung
4. Konstruktor-Überladung in Java
5. Best Practices für das Überladen von Konstruktoren
6. Einen Konstruktor überladen

In diesem Tutorial wird erläutert, wie Konstruktoren in Java überladen werden. Wir haben auch einige Beispielcodes aufgelistet, denen Sie folgen können, um dieses Thema besser zu verstehen.

Ein Konstruktor ist eine Methode, die aufgerufen wird, um einem Klassenobjekt Speicher zuzuweisen und die Klassenattribute für dieses Objekt zu initialisieren. Wenn für eine Klasse kein Konstruktor erstellt wurde, stellt Java einen Standardkonstruktor bereit.

In der folgenden Klasse wurde beispielsweise kein Konstruktor definiert. Dennoch können wir ein Objekt dieser Klasse erstellen, während die Attribute auf ihre Standardwerte (in diesem Fall null) initialisiert werden.

Standardkonstruktor in Java

class Student {
  String name;
  Double gpa;
}
public class Main {
  public static void main(String[] args) {
    Student s = new Student();
    System.out.println(s.name + "\t" + s.gpa);
  }
}

Ausgabe:

null	null

Das Konzept des Überladens von Konstruktoren ähnelt dem Überladen von Methoden, was bedeutet, dass wir mehr als einen Konstruktor für eine einzelne Klasse haben. Das Überladen von Konstruktoren wird durchgeführt, um die Membervariablen der Klasse auf unterschiedliche Weise zu initialisieren.

Wir können beliebig viele überladene Konstruktoren erstellen. Die einzige Bedingung ist, dass sich die überladenen Konstruktoren in der Anzahl und Art der Parameter unterscheiden, die sie verwenden.

Betrachten Sie zum Beispiel die unten abgebildete Klasse Student mit zwei Attributen: Schülername und GPA. Für die Klasse wird ein Konstruktor definiert, der als Parameter einen Stringnamen und ein doppeltes GPA nimmt und die entsprechenden Attribute für das neue Objekt initialisiert.

Parametrisierter Konstruktor in Java

class Student {
  String name;
  Double gpa;
  Student(String s, Double g) {
    name = s;
    gpa = g;
  }
}
public class Main {
  public static void main(String[] args) {
    Student s = new Student("Justin", 9.75);
    System.out.println(s.name + "\t" + s.gpa);
  }
}

Ausgabe:

Justin	9.75

Code ohne Konstruktor-Überladung

Stellen Sie sich ein Szenario vor, in dem beim Erstellen eines neuen Objekts nur der Schülername an den Konstruktor übergeben wird. der GPA sollte in diesem Fall automatisch auf null gesetzt werden. Wenn wir den Konstruktor nicht überladen und nur den Namen übergeben, erhalten wir den folgenden Kompilierungsfehler.

class Student {
  String name;
  Double gpa;
  Student(String s, Double g) {
    name = s;
    gpa = g;
  }
}
public class Main {
  public static void main(String[] args) {
    Student s = new Student("Justin");
    System.out.println(s.name + "\t" + s.gpa);
  }
}

Ausgabe:

Exception in thread "main" java.lang.Error: Unresolved compilation problem: 
	The constructor Student(String) is undefined

	at ConstructorOverloading.main(ConstructorOverloading.java:18)

Konstruktor-Überladung in Java

Wir können einen überladenen Konstruktor mit nur dem Studentennamen als Parameter erstellen, um die obige Situation zu lösen. Wir werden den GPA auf null setzen, wenn dieser Konstruktor aufgerufen wird.

class Student {
  String name;
  Double gpa;
  Student(String s, Double g) {
    name = s;
    this.gpa = g;
  }
  Student(String s) {
    name = s;
    gpa = null; // Setting GPA to null
  }
}
public class Main {
  public static void main(String[] args) {
    Student s1 = new Student("Justin");
    Student s2 = new Student("Jessica", 9.23);
    System.out.println(s1.name + "\t" + s1.gpa);
    System.out.println(s2.name + "\t" + s2.gpa);
  }
}

Ausgabe:

Justin	null
Jessica	9.23

Betrachten Sie eine andere Situation, in der ein Student-Objekt erstellt wird, aber weder der Name noch der GPA erwähnt wurden. Wir können einen anderen überladenen Konstruktor erstellen, der keine Argumente akzeptiert (Standardkonstruktor) und die Attribute name und GPA auf null setzt.

Denken Sie daran, dass Java nur dann einen Standardkonstruktor bereitstellt, wenn kein anderer Konstruktor für eine Klasse erstellt wird. Aber für unsere Klasse existieren bereits Konstruktoren, und daher müssen wir einen Standardkonstruktor erstellen.

class Student {
  String name;
  Double gpa;
  Student(String s, Double g) {
    name = s;
    gpa = g;
  }
  Student(String s) {
    name = s;
    gpa = null;
  }
  Student() {
    name = null;
    gpa = null;
  }
}
public class Main {
  public static void main(String[] args) {
    Student s1 = new Student();
    Student s2 = new Student("Justin");
    Student s3 = new Student("Jessica", 9.23);
    System.out.println(s1.name + "\t" + s1.gpa);
    System.out.println(s2.name + "\t" + s2.gpa);
    System.out.println(s3.name + "\t" + s3.gpa);
  }
}

Ausgabe:

null	null
Justin	null
Jessica	9.23

Best Practices für das Überladen von Konstruktoren

Beim Überladen von Konstruktoren gibt es keine festgelegten Richtlinien. Es gibt jedoch einige empfohlene Best Practices, die wir befolgen können, um Verwirrung zu vermeiden und den Fehlerumfang zu reduzieren.

• Man sollte das Schlüsselwort this verwenden, um auf die Member-Variablen der Klasse zu verweisen. Es vermeidet Verwirrung und macht unseren Code lesbarer.
• Wir können dem Konstruktor auch intuitivere Parameternamen übergeben. Wenn beispielsweise ein Konstruktor das Namensfeld initialisiert, könnte die Konstruktorsignatur Student(String name) anstelle von Student(String s) lauten. Mit dem Schlüsselwort this können wir zwischen dem Parameter, genannt name, und dem Klassenattribut, auch name genannt, unterscheiden.

Fahren wir mit dem Beispiel der Klasse Student fort und verwenden das Schlüsselwort this innerhalb der Konstruktoren.

class Student {
  String name;
  Double gpa;
  Student(String name, Double gpa) // passing more intuitive parameter names
  {
    this.name = name; // using this keyword to avoid confusion
    this.gpa = gpa;
  }
  Student(String name) {
    this.name = name;
    this.gpa = null;

    Student()

        this.name = null;
    this.gpa = null;
  }
}

• Es ist auch eine gute Praxis, dass eine Klasse nur einen einzigen primären Konstruktor hat, und alle verbleibenden Konstruktoren sollten diesen primären Konstruktor aufrufen, um die Attribute zu initialisieren.
• Wir können einen Konstruktor von einem anderen Konstruktor aufrufen, indem wir die Funktion this() verwenden. Die Anzahl und Art der Attribute, die wir an this() übergeben, entscheiden, welcher Konstruktor aufgerufen wird.
• Es reduziert die Coderedundanz und wir müssen nur die Logik für einen einzelnen Konstruktor schreiben.
• In der Klasse Student brauchen wir drei überladene Konstruktoren. Der primäre Konstruktor ist der parametrisierte Konstruktor, der sowohl name als auch GPA als Parameter verwendet. Die anderen beiden überladenen Konstruktoren rufen einfach den primären Konstruktor auf und übergeben die Werte der Parameter als null.

class Student {
  String name;
  Double gpa;
  Student(String name, Double gpa) // Primary Constructor that sets the attribute values
  {
    this.name = name;
    this.gpa = gpa;
  }
  Student(String name) {
    this(name, null); // Calling the primary constructor with GPA as null
  }
  Student() {
    this(null, null); // Calling the primary constructor with both parameters as null
  }
}

Einen Konstruktor überladen

Das Überladen von Konstruktoren wird durchgeführt, um die Attribute einer Klasse auf unterschiedliche Weise zu initialisieren. Überladene Konstruktoren sollten sich in der Anzahl der Parameter oder dem Datentyp der ihnen übergebenen Parameter unterscheiden.

Die Signatur jedes Konstruktors sollte sich von den anderen unterscheiden. Wir sollten das Schlüsselwort this verwenden, um auf die Klassenattribute und andere Konstruktoren zu verweisen, da es unseren Code weniger redundant und verständlicher macht.