Sobrecarga de constructores en Java – Explicado con ejemplos de código prácticos

¿Qué es un constructor en Java?

Un constructor es un método especial que inicializa un objeto recién creado inmediatamente después de la asignación de memoria. Establece los campos del objeto a los valores deseados o, si se omite, a sus valores por defecto. Definir un constructor es opcional; si no se proporciona, el compilador suministra uno por defecto que asigna los valores estándar:

• Primitivos numéricos (int, double, etc.) → 0
• char → '\0'
• Referencias a objetos → null

Este tutorial cubre:

• Reglas para crear constructores
• Sobrecarga de constructores
• Encadenamiento de constructores

Reglas para crear un constructor en Java

1. El nombre del constructor debe coincidir exactamente con el nombre de la clase.
2. No puede tener tipo de retorno, ni siquiera void.

Ejemplo 1 – Primer Constructor

Paso 1: Ingresa el siguiente código en tu editor de Java.

class Demo {
    int valor1;
    int valor2;
    Demo() {
        valor1 = 10;
        valor2 = 20;
        System.out.println("Dentro del Constructor");
    }
    public void display() {
        System.out.println("Valor1 === " + valor1);
        System.out.println("Valor2 === " + valor2);
    }
    public static void main(String[] args) {
        Demo d1 = new Demo();
        d1.display();
    }
}

Paso 2: Compila y ejecuta el programa. Salida:

Dentro del Constructor
Valor1 === 10
Valor2 === 20

Sobrecarga de constructores en Java

Java permite que una clase defina múltiples constructores con diferentes listas de parámetros. El compilador los distingue por el número y tipos de parámetros.

Constructores válidos para una clase llamada Cuenta podrían verse así:

Cuenta(int a);
Cuenta(int a, int b);
Cuenta(String a, int b);

Ejemplo 2 – Constructores sobrecargados

Paso 1: Inserta el siguiente código.

class Demo {
    int valor1;
    int valor2;
    /* Demo() {
        valor1 = 10;
        valor2 = 20;
        System.out.println("Dentro del 1er Constructor");
    } */
    Demo(int a) {
        valor1 = a;
        System.out.println("Dentro del 2do Constructor");
    }
    Demo(int a, int b) {
        valor1 = a;
        valor2 = b;
        System.out.println("Dentro del 3er Constructor");
    }
    public void display() {
        System.out.println("Valor1 === " + valor1);
        System.out.println("Valor2 === " + valor2);
    }
    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();
    }
}

Paso 2: Compila y ejecuta. Encontrarás un error porque el constructor por defecto Demo() falta después de agregar un constructor parametrizado. Para usar el constructor por defecto, decláralo explícitamente:

Demo() {
    // inicialización por defecto o lógica personalizada
}

Tras descomentar el bloque comentado y recompilar, el programa se ejecuta correctamente.

Encadenamiento de constructores

Cuando se instancia una subclase, su constructor de superclase se ejecuta primero — esto se conoce como encadenamiento de constructores.

Ejemplo 3 – Encadenamiento entre Padre e Hijo

Paso 1: Copia el código siguiente.

class Demo {
    int valor1;
    int valor2;
    Demo() {
        valor1 = 1;
        valor2 = 2;
        System.out.println("Dentro del 1er Constructor Padre");
    }
    Demo(int a) {
        valor1 = a;
        System.out.println("Dentro del 2do Constructor Padre");
    }
    public void display() {
        System.out.println("Valor1 === " + valor1);
        System.out.println("Valor2 === " + valor2);
    }
    public static void main(String[] args) {
        DemoHijo d1 = new DemoHijo();
        d1.display();
    }
}
class DemoHijo extends Demo {
    int valor3;
    int valor4;
    DemoHijo() {
        // super(5); // Descomenta para llamar al constructor padre sobrecargado
        valor3 = 3;
        valor4 = 4;
        System.out.println("Dentro del Constructor del Hijo");
    }
    public void display() {
        System.out.println("Valor1 === " + valor1);
        System.out.println("Valor2 === " + valor2);
        System.out.println("Valor3 === " + valor3);
        System.out.println("Valor4 === " + valor4);
    }
}

Paso 2: Ejecuta el programa. Como el constructor del hijo no llama explícitamente a super(), se ejecuta primero el constructor por defecto Demo(). Salida esperada:

Dentro del 1er Constructor Padre
Dentro del Constructor del Hijo
Valor1 === 1
Valor2 === 2
Valor3 === 3
Valor4 === 4

Paso 3: Para invocar el constructor padre sobrecargado Demo(int a), coloca super(5); como primera línea en el constructor del hijo. Tras descomentar la línea y volver a ejecutar:

Dentro del 2do Constructor Padre
Dentro del Constructor del Hijo
Valor1 === 5
Valor2 === 0
Valor3 === 3
Valor4 === 4

Usar super(...) es obligatorio cuando necesitas que un constructor específico de la superclase se ejecute antes de la lógica de la subclase.