Reglas esenciales

• El constructor debe llamarse exactamente igual que la clase.
• Se permite más de un constructor (sobrecarga).
• Puede recibir cero, uno o varios parámetros.
• No tiene tipo de retorno (ni siquiera void).
• Siempre se invoca junto con el operador new.

Constructores sin parámetros

Cuando no se define ningún constructor, el compilador provee uno por defecto sin argumentos. Si escribimos uno propio, se reemplaza ese comportamiento.

public class Vehiculo {
   public Vehiculo() {
       System.out.println("Constructor por defecto de Vehiculo");
   }
}

Al hacer new Vehiculo() se ejecuta el mensaje anterior.

Sobrecarga de constructores

Podemos ofrecer múltiples formas de inicializar un objeto variando la cantidad de parámetros. El siguiente ejemplo muestra una clase Persona con tres versiones del constructor:

public class Persona {
   private String nombre;
   private int edad;
   private String email;

   // Constructor con un parámetro
   public Persona(String nombre) {
       this.nombre = nombre;
       System.out.println("Constructor con nombre: " + nombre);
   }

   // Constructor con dos parámetros
   public Persona(String nombre, int edad) {
       this.nombre = nombre;
       this.edad = edad;
       System.out.println("Constructor con nombre y edad: " + nombre + ", " + edad);
   }

   // Constructor con tres parámetros
   public Persona(String nombre, int edad, String email) {
       this.nombre = nombre;
       this.edad = edad;
       this.email = email;
       System.out.println("Constructor con nombre, edad y email: " + nombre + ", " + edad + ", " + email);
   }
}

La clase de prueba llama a cada uno de ellos:

public class PruebaSobrecarga {
   public static void main(String[] args) {
       Persona p1 = new Persona("Carlos");
       Persona p2 = new Persona("Ana", 25);
       Persona p3 = new Persona("Luis", 30, "luis@email.com");
   }
}

Herencia y la llamada a super

Cuando una clase hija extiende a otra, su constructor debe invocar, directa o indirectamente, un constructor de la clase padre. La llamada super(...) debe ser la primera instrucción del constructor de la subclase.

Si no se escribe explícitamente, el compilador inserta super(), es decir, intenta llamar al constructor sin argumentos del padre. Si la clase padre no posee dicho constructor, se produce un error de compilación.

En el siguiente fragmetno, la clase Empleado no declara un constructor. Por ello, se invoca el constructor por defecto de Persona:

public class Persona {
   public Persona() {
       System.out.println("Constructor sin argumentos de Persona");
   }
}

public class Empleado extends Persona {
   // No se define ningún constructor explícito
}

public class PruebaHerencia {
   public static void main(String[] args) {
       Empleado e = new Empleado(); // Imprime el mensaje del constructor de Persona
   }
}

Si eliminamos el constructor sin argumentos de Persona y dejamos solo uno con parámetros, la subclase debe llamar a super con los argumentos adecuados:

public class Persona {
   private String nombre;

   public Persona(String nombre) {
       this.nombre = nombre;
       System.out.println("Constructor con nombre: " + nombre);
   }
}

public class Empleado extends Persona {
   public Empleado(String nombre, int edad, String email) {
       super(nombre); // Llamada obligatoria al constructor del padre
       // resto de inicialización
   }
}

Con esta estructura, la compilación es exitosa porque el constructor de Empleado proporciona explícitamente el argumento requerido por Persona.