Encadenamiento de constructores

Parte de la sección Programación Orientada a Objetos del Journey de Java de Coddy. Lección 23 de 87.

El encadenamiento de constructores es el proceso de llamar a un constructor desde otro. Esta técnica ayuda a evitar la duplicación de código cuando una clase tiene varios constructores o cuando se trabaja con jerarquías de herencia.

Dentro de la misma clase, puedes encadenar constructores usando this(). Esto te permite tener un constructor «principal» que hace todo el trabajo, mientras que los demás constructores simplemente delegan en él:

public class Rectangle {
    private int width;
    private int height;
    
    public Rectangle() {
        this(1, 1);  // Llama al constructor de dos parámetros
    }
    
    public Rectangle(int size) {
        this(size, size);  // Crea un cuadrado
    }
    
    public Rectangle(int width, int height) {
        this.width = width;
        this.height = height;
    }
}

En la herencia, el encadenamiento de constructores ocurre automáticamente. Cuando creas un objeto de una subclase, Java llama primero al constructor de la clase padre mediante super(). Si no llamas explícitamente a super(), Java inserta automáticamente super() (la versión sin argumentos):

public class Animal {
    private String name;
    
    public Animal(String name) {
        this.name = name;
        System.out.println("Animal constructor");
    }
}

public class Dog extends Animal {
    private String breed;
    
    public Dog(String name, String breed) {
        super(name);  // Debe ser la primera línea
        this.breed = breed;
        System.out.println("Dog constructor");
    }
}

Crear new Dog("Buddy", "Labrador") imprime primero "Animal constructor" y después "Dog constructor". Esto garantiza que las clases padre siempre se inicialicen correctamente antes de que la clase hija agregue su propia configuración.

Desafío

Fácil

Construyamos un sistema de pedidos de productos que demuestre el encadenamiento de constructores tanto dentro de una clase como a través de una jerarquía de herencia. Verás cómo this() encadena constructores en la misma clase, mientras que super() encadena constructores de la clase padre.

Crearás tres archivos para organizar tu código:

Product.java: Crea una clase padre que represente cualquier producto de una tienda. Debe tener:
- Campos privados para name (String) y price (double)
- Un constructor principal que acepte name y price, inicialice los campos e imprima: Product constructor: [name]
- Un segundo constructor que acepte únicamente name y se encadene al constructor principal mediante this(name, 0.0) para establecer un precio predeterminado de 0.0
- Métodos getName() y getPrice() para acceder a los campos
Electronics.java: Crea una subclase que extienda Product y añada información sobre la garantía:
- Un campo privado para warrantyYears (int)
- Un constructor principal que acepte name, price y warrantyYears; usa super(name, price) para inicializar la clase padre, luego establece la garantía e imprime: Electronics constructor: [warrantyYears] year warranty
- Un segundo constructor que acepte únicamente name y price, encadenándose al constructor principal mediante this(name, price, 1) para proporcionar una garantía predeterminada de 1 año
- Un tercer constructor que acepte únicamente name y se encadene al segundo constructor mediante this(name, 0.0)
- Un método getDetails() que devuelva: [name] - $[price] ([warrantyYears] year warranty)
Main.java: Demuestra el encadenamiento de constructores en acción. Recibirás tres entradas: un nombre de producto (String), un precio (double) y los años de garantía (int). Crea un objeto Electronics usando los tres parámetros y luego imprime el resultado de getDetails().

Recibirás tres entradas: el nombre del producto, el precio y los años de garantía.

Da formato al precio en getDetails() para mostrar 2 decimales usando String.format("%.2f", price). Observa atentamente la salida: verás que los mensajes de los constructores aparecen en orden, mostrando cómo fluye la cadena desde la clase padre hasta la hija.

Pruébalo tú mismo

import java.util.Scanner;

class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        
        // Leer entradas
        String name = scanner.nextLine();
        double price = scanner.nextDouble();
        int warrantyYears = scanner.nextInt();
        
        // TODO: Crear un objeto Electronics usando los tres parámetros
        
        // TODO: Imprimir el resultado de getDetails()
    }
}