Constructores privados en Java

1. Definición de constructor privado en Java
2. Constructor privado usando patrón Singleton en Java
3. Constructor privado usando un patrón de constructor en Java

El constructor es una de las partes más importantes de una clase, ya que es el primero en ejecutarse y nos permite pasar argumentos que deben inicializarse antes que nada en una clase.

Por lo general, creamos un constructor con un modificador público para que se pueda crear un objeto en cualquier función, pero hay algunos escenarios en los que queremos hacerlo privado, y eso es lo que veremos en las siguientes secciones.

Definición de constructor privado en Java

En esta sección, tratamos de crear un objeto de una clase con un constructor privado.

El programa tiene dos clases, ExampleClass2 y AnotherClass. La AnotherClass tiene un constructor con un modificador privado y una declaración de print.

Cuando creamos un objeto de esta clase en la clase ExampleClass2, nos sale un error diciendo que AnotherClass tiene acceso privado.

Restringe el acceso al constructor y puede ser útil de ciertas maneras que veremos en las próximas secciones de este tutorial.

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.");
  }
}

Producción :

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

Constructor privado usando patrón Singleton en Java

Usamos el patrón singleton para crear una única instancia de clase en todo el programa. Como se puede acceder a un constructor público desde casi cualquier parte del proyecto, usamos un constructor privado.

Creamos una clase AnotherClass con un constructor privado que muestra un mensaje en el programa a continuación. Necesitamos una función que devuelva una instancia de la clase, por lo que creamos una función llamada getInstance() que es pública y estática para ser llamada sin crear un objeto.

Dentro del método getInstance() devolvemos new AnotherClass() y establecemos el tipo de devolución en AnotherClass. Creamos otra función para probar si podemos llamar al método de la instancia.

Ahora llamamos a la función getInstance() que devuelve una instancia de AnotherClass y usando esta instancia llamamos al dummyMethod().

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

Producción :

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

Constructor privado usando un patrón de constructor en Java

Otro caso de uso de un constructor privado es cuando usamos un patrón de constructor en nuestro programa. Creamos una clase de User con tres variables de clase firstName, lastName y age en el siguiente código.

Inicializamos todas estas variables en el constructor y hacemos que el constructor sea privado.

También hacemos un método para imprimir los valores. Creamos una clase interna llamada BuilderClass para construir el objeto dentro de la clase User.

BuilderClass es pública ya que otra clase puede acceder a ella.

Creamos tres variables en la clase BuilderClass para configurar las variables de la clase User. Creamos métodos setter para establecer los valores y luego devolvemos this con los valores.

Devolvemos un objeto con los valores creando el método buildObject() que devuelve el objeto User con los nuevos valores que se establecieron.

Ahora en la clase ExampleClass2, obtenemos la clase BuilderClass() ya que es pública. Luego, usamos el objeto UserBuilder para establecer los valores usando sus métodos de establecimiento y luego llamamos al método buildObject() que devuelve el objeto User.

Imprimimos los valores llamando a la función getUserDetails().

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

Producción :

First Name: Micheal
Last Name: Fisk
Age: 26