Private Konstruktoren in Java

1. Privaten Konstruktor in Java definieren
2. Privater Konstruktor mit Singleton-Muster in Java
3. Privater Konstruktor mit Builder-Muster in Java

Der Konstruktor ist einer der wichtigsten Teile einer Klasse, da er als erster ausgeführt wird und es uns ermöglicht, Argumente zu übergeben, die vor allem in einer Klasse initialisiert werden müssen.

Normalerweise erstellen wir einen Konstruktor mit einem öffentlichen Modifikator, sodass ein Objekt in jeder Funktion erstellt werden kann, aber es gibt einige Szenarien, in denen wir es privat machen möchten, und das werden wir uns in den folgenden Abschnitten ansehen.

Privaten Konstruktor in Java definieren

In diesem Abschnitt versuchen wir, ein Objekt einer Klasse mit einem privaten Konstruktor zu erstellen.

Das Programm hat zwei Klassen, ExampleClass2 und AnotherClass. Die AnotherClass hat einen Konstruktor mit einem privaten Modifikator und einer print-Anweisung.

Wenn wir ein Objekt dieser Klasse in der Klasse ExampleClass2 erstellen, erhalten wir eine Fehlermeldung, die besagt, dass AnotherClass privaten Zugriff hat.

Es schränkt den Zugriff auf den Konstruktor ein und kann auf bestimmte Weise nützlich sein, die wir in den nächsten Abschnitten dieses Tutorials sehen werden.

public class ExampleClass2 {
  public static void main(String[] args) {
    AnotherClass anotherClass = new AnotherClass();
  }
}

class AnotherClass {
  private AnotherClass() {
    System.out.println("This is a private constructor.");
  }
}

Ausgabe:

java: AnotherClass() has private access in com.tutorial.AnotherClass

Privater Konstruktor mit Singleton-Muster in Java

Wir verwenden das Singleton-Muster, um im gesamten Programm nur eine einzige Klasseninstanz zu erstellen. Da auf einen öffentlichen Konstruktor von fast überall im Projekt aus zugegriffen werden kann, verwenden wir einen privaten Konstruktor.

Wir erstellen eine Klasse AnotherClass mit einem privaten Konstruktor, der eine Nachricht im Programm unten anzeigt. Wir brauchen eine Funktion, die eine Instanz der Klasse zurückgibt, also erstellen wir eine Funktion namens getInstance(), die öffentlich und statisch ist und aufgerufen werden kann, ohne ein Objekt zu erstellen.

Innerhalb der Methode getInstance() geben wir new AnotherClass() zurück und setzen den Rückgabetyp auf AnotherClass. Wir erstellen eine weitere Funktion, um zu testen, ob wir die Methode der Instanz aufrufen können.

Nun rufen wir die Funktion getInstance() auf, die eine Instanz von AnotherClass zurückgibt, und mit dieser Instanz rufen wir die dummyMethod() auf.

public class ExampleClass2 {
  public static void main(String[] args) {
    AnotherClass anotherClass = AnotherClass.getInstance();
    anotherClass.dummyMethod();
  }
}

class AnotherClass {
  private AnotherClass() {
    System.out.println("This is a private constructor.");
  }

  public static AnotherClass getInstance() {
    return new AnotherClass();
  }

  public void dummyMethod() {
    System.out.println("This is just a dummy method");
  }
}

Ausgabe:

This is a private constructor.
This is just a dummy method

Privater Konstruktor mit Builder-Muster in Java

Ein weiterer Anwendungsfall eines privaten Konstruktors ist die Verwendung eines Builder-Musters in unserem Programm. Wir erstellen im folgenden Code eine Klasse User mit drei Klassenvariablen firstName, lastName und age.

Wir initialisieren alle diese Variablen im Konstruktor und machen den Konstruktor privat.

Wir machen auch eine Methode, um die Werte zu drucken. Wir erstellen eine innere Klasse namens BuilderClass, um das Objekt innerhalb der Klasse User zu bauen.

BuilderClass ist öffentlich, da eine andere Klasse darauf zugreifen kann.

Wir erstellen drei Variablen in der Klasse BuilderClass, um die Variablen der Klasse User zu setzen. Wir erstellen Setter-Methoden, um die Werte zu setzen und geben dann this mit den Werten zurück.

Wir geben ein Objekt mit den Werten zurück, indem wir die Methode buildObject() erstellen, die das Objekt User mit den neu eingestellten Werten zurückgibt.

Jetzt erhalten wir in der Klasse ExampleClass2 die Klasse BuilderClass(), da sie öffentlich ist. Dann verwenden wir das UserBuilder-Objekt, um die Werte mit seinen Setter-Methoden festzulegen, und rufen dann die buildObject()-Methode auf, die das User-Objekt zurückgibt.

Wir drucken die Werte, indem wir die Funktion getUserDetails() aufrufen.

public class ExampleClass2 {
  public static void main(String[] args) {
    User.BuilderClass userBuilder = new User.BuilderClass();
    User getUser = userBuilder.setFirstName("Micheal").setLastName("Fisk").setAge(26).buildObject();

    getUser.getUserDetails();
  }
}

class User {
  private final String firstName;
  private final String lastName;
  private final int age;

  private User(String firstName, String lastName, int age) {
    this.firstName = firstName;
    this.lastName = lastName;
    this.age = age;
  }

  public void getUserDetails() {
    System.out.println("First Name: " + firstName);
    System.out.println("Last Name: " + lastName);
    System.out.println("Age: " + age);
  }

  public static class BuilderClass {
    private String firstName;
    private String lastName;
    private int age;

    BuilderClass setFirstName(String firstName) {
      this.firstName = firstName;
      return this;
    }

    BuilderClass setLastName(String lastName) {
      this.lastName = lastName;
      return this;
    }

    BuilderClass setAge(int age) {
      this.age = age;
      return this;
    }

    public User buildObject() {
      return new User(firstName, lastName, age);
    }
  }
}

Ausgabe:

First Name: Micheal
Last Name: Fisk
Age: 26