Sobrecargar un constructor en Java

Mohammad Irfan 12 octubre 2023

Java Java Constructor

Constructor predeterminado en Java
Constructor parametrizado en Java
Código sin sobrecarga de constructor
Sobrecarga de constructores en Java
Prácticas recomendadas de sobrecarga de constructores
Sobrecargar un constructor

Este tutorial presenta cómo sobrecargar constructores en Java. También hemos enumerado algunos códigos de ejemplo que puede seguir para comprender mejor este tema.

Un constructor es un método llamado para asignar memoria para un objeto de clase e inicializar los atributos de clase para ese objeto. Si no se ha creado ningún constructor para una clase, Java proporciona un constructor predeterminado.

Por ejemplo, no se ha definido ningún constructor en la clase siguiente. Aún así, podemos crear un objeto de esa clase mientras los atributos se inicializan a sus valores predeterminados (nulo, en este caso).

Constructor predeterminado en 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);
  }
}

Producción :

null	null

El concepto de sobrecarga de constructores es similar a la sobrecarga de métodos, lo que significa que tenemos más de un constructor para una sola clase. La sobrecarga del constructor se realiza para inicializar las variables miembro de la clase de diferentes formas.

Podemos crear tantos constructores sobrecargados como queramos. La única condición es que los constructores sobrecargados deben diferir en el número y el tipo de parámetros que toman.

Por ejemplo, considere la clase Student que se muestra a continuación con dos atributos: nombre del estudiante y GPA. Se define un constructor para la clase, que toma un nombre de cadena y un doble GPA como parámetros e inicializa los atributos correspondientes para el nuevo objeto.

Constructor parametrizado en 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);
  }
}

Producción :

Justin	9.75

Código sin sobrecarga de constructor

Considere un escenario en el que solo se pasa el nombre del estudiante al constructor al crear un nuevo objeto; el GPA debe establecerse automáticamente en null en este caso. Si no sobrecargamos el constructor y simplemente pasamos el nombre, obtenemos el siguiente error de compilación.

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

Producción :

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

	at ConstructorOverloading.main(ConstructorOverloading.java:18)

Sobrecarga de constructores en Java

Podemos crear un constructor sobrecargado con solo el nombre del estudiante como parámetro para abordar la situación anterior. Estableceremos el GPA en null cuando se llame a este constructor.

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

Producción :

Justin	null
Jessica	9.23

Considere otra situación en la que se crea un objeto Student, pero no se ha mencionado ni el nombre ni el GPA. Podemos hacer otro constructor sobrecargado que no tome argumentos (constructor predeterminado) y establezca los atributos name y GPA en null.

Recuerde que Java proporciona un constructor predeterminado solo cuando no se crea ningún otro constructor para una clase. Pero para nuestra clase, los constructores ya existen, por lo que necesitamos crear un constructor predeterminado.

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

Producción :

null	null
Justin	null
Jessica	9.23

Prácticas recomendadas de sobrecarga de constructores

No hay pautas establecidas a seguir al sobrecargar constructores. Sin embargo, existen algunas mejores prácticas recomendadas que podemos seguir para evitar confusiones y reducir el alcance del error.

Se debe usar la palabra clave this para hacer referencia a las variables miembro de la clase. Evita confusiones y hace que nuestro código sea más legible.
También podemos pasar nombres de parámetros más intuitivos al constructor. Por ejemplo, si un constructor inicializa el campo de nombre, entonces la firma del constructor podría ser Student(String name) en lugar de Student(String s). Usando la palabra clave this, podemos diferenciar entre el parámetro, llamado name, y el atributo de clase, también llamado name.

Continuemos con el ejemplo de la clase Student y usemos la palabra clave this dentro de los constructores.

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

También es una buena práctica que una clase solo tenga un constructor primario único, y todos los constructores restantes deben llamar a este constructor primario para inicializar los atributos.
Podemos llamar a un constructor desde otro constructor usando la función this(). El número y tipo de atributos que le pasemos a this() decidirá qué constructor se llamará.
Reducirá la redundancia de código y solo necesitamos escribir la lógica para un solo constructor.
En la clase Student, necesitamos tres constructores sobrecargados. El constructor principal será el parametrizado que toma como parámetros tanto name como GPA. Los otros dos constructores sobrecargados simplemente llamarán al constructor principal y pasarán los valores de los parámetros como 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
  }
}