Sobrecarga de constructores (Constructor Overloading)

Un constructor es útil para la creación de objetos con un valor inicial por defecto. Cuándo quieres inicializar objetos con diferentes valores en diferentes instancias, puedes pasarles argumentos a los constructores. Y si, puedes tener diferentes constructores en una clase, esto es conocido como sobrecarga de constructores o constructor overloading. En una clase, el constructor por defecto puede inicializar el objeto con valores predefinidos, mientras otro constructor puede aceptar argumentos que son necesarios para ser usados al instanciar.

public class Circle {

    private int xPos;
    private int yPos;
    private int radius;

    // three overloaded constructors for Circle
    public Circle(int x, int y, int r) {
        xPos = x;
        yPos = y;
        radius = r;
    }

    public Circle(int x, int y) {
        xPos = x;
        yPos = y;
        radius = 10; // default radius
    }

    public Circle() {
        xPos = 20; // assume some default values for xPos and yPos
        yPos = 20;
        radius = 10; // default radius
    }

    public String toString() {
        return "center = (" + xPos + "," + yPos + ") and radius = " + radius;
    }

    public static void main(String[] s) {
        System.out.println(new Circle());
        System.out.println(new Circle(50, 100));
        System.out.println(new Circle(25, 50, 5));
    }
}

Esto imprime

center = (20,20) and radius = 10
center = (50,100) and radius = 10
center = (25,50) and radius = 5

Como puedes ver el compilador ha resuelto cuál constructor llamar dependiendo del número de argumentos. El constructor por defecto no toma argumentos por lo que nosotros asignamos los valores para xPos, yPos y radius (con valores 20,20, y 10 respectivamente). El constructor que recibe dos argumentos, asigna y a yPos, x a xPos y define el valor 10 para radius. Por último el constructor que recibe tres argumentos asigna respectivamente y a yPos, x a xPos y r a radius.

¿Notaste que el código dentro de los constructores fue duplicado?. Puedes evitar esto llamando a los constructores del más general al más específico, como se muestra a continuación:

public Circle(int x, int y, int r) {
    xPos = x;
    yPos = y;
    radius = r;
}

public Circle(int x, int y) {
    this(x, y, 10); // passing default radius 10
}

public Circle() {
    this(20, 20, 10);
    // assume some default values for xPos, yPos and radius
}

La salida es la misma que del programa anterior pero el código es más corto. En este caso, usamos la palabra reservada this para llamar un constructor dentro de otro en la misma clase.