Constructores en Java: inicializar objetos con new

Por qué existen los constructores

En la página anterior creaste clases y objetos con new. Un constructor es el código que realmente se ejecuta durante esa llamada a new. Su único propósito es devolverte un objeto listo para usar: con todos sus campos obligatorios establecidos y sin estados a medio inicializar.

Un constructor se parece a un método, pero con dos diferencias: tiene el mismo nombre que la clase y no tiene tipo de retorno, ni siquiera void.

class Point {
    int x;
    int y;

    Point(int x, int y) {     // constructor: mismo nombre que la clase, sin tipo de retorno
        this.x = x;
        this.y = y;
    }
}

public class Main {
    public static void main(String[] args) {
        Point p = new Point(3, 4);   // el constructor se ejecuta aquí
        System.out.println(p.x + ", " + p.y);
    }
}

new Point(3, 4) reserva el objeto y luego ejecuta el cuerpo del constructor con x = 3 e y = 4. Para cuando new retorna, p está completamente inicializado.

La palabra clave this

Dentro del constructor de arriba, los parámetros se llaman x e y, igual que los campos. this.x significa "el campo x que pertenece a este objeto", mientras que x a secas se refiere al parámetro. Sin this, x = x se asignaría el parámetro a sí mismo y dejaría el campo intacto.

class Account {
    String owner;
    double balance;

    Account(String owner, double balance) {
        this.owner = owner;       // campo = parámetro
        this.balance = balance;
    }
}

public class Main {
    public static void main(String[] args) {
        Account a = new Account("Sam", 100.0);
        System.out.println(a.owner + " has " + a.balance);
    }
}

Solo necesitas this cuando un parámetro oculta un campo, pero mucha gente lo usa en todas partes por claridad. El error habitual es olvidarlo cuando los nombres coinciden: el código compila, se ejecuta y deja silenciosamente tus campos en sus valores por defecto (null, 0, false).

El constructor por defecto

Si nunca escribes un constructor, Java proporciona discretamente un constructor por defecto: un constructor público, sin argumentos, que no hace nada adicional. Por eso new funcionaba en clases que no tenían ningún constructor.

La trampa: en cuanto escribes cualquier constructor, el gratuito desaparece.

class Box {
    int size;

    Box(int size) {       // ahora NO hay constructor sin argumentos
        this.size = size;
    }
}

new Box();   // error de compilación: no existe el constructor Box()

Si aún quieres que new Box() funcione, declara tú mismo el constructor sin argumentos:

class Box {
    int size;

    Box() {               // constructor sin argumentos explícito
        this.size = 1;
    }

    Box(int size) {
        this.size = size;
    }
}

public class Main {
    public static void main(String[] args) {
        System.out.println(new Box().size);     // 1
        System.out.println(new Box(10).size);   // 10
    }
}

Sobrecarga de constructores

Una clase puede tener varios constructores siempre que sus listas de parámetros difieran: esto no es más que la sobrecarga de métodos aplicada a los constructores. Cada uno ofrece una forma distinta de construir el objeto.

class Rectangle {
    int width;
    int height;

    Rectangle() {                 // un cuadrado 1x1 por defecto
        this.width = 1;
        this.height = 1;
    }

    Rectangle(int side) {         // un cuadrado
        this.width = side;
        this.height = side;
    }

    Rectangle(int width, int height) {   // un rectángulo completo
        this.width = width;
        this.height = height;
    }

    int area() { return width * height; }
}

public class Main {
    public static void main(String[] args) {
        System.out.println(new Rectangle().area());        // 1
        System.out.println(new Rectangle(5).area());       // 25
        System.out.println(new Rectangle(2, 3).area());    // 6
    }
}

Java elige el constructor que coincide según el número y los tipos de argumentos que le pasas a new.

Encadenamiento con this()

Fíjate en la duplicación de arriba: cada constructor asigna los campos por sí mismo. Puedes evitarlo haciendo que un constructor llame a otro con this(...). La llamada debe ser la primera instrucción del constructor.

class Rectangle {
    int width;
    int height;

    Rectangle() {
        this(1, 1);          // delega en el constructor de dos argumentos
    }

    Rectangle(int side) {
        this(side, side);    // también delega
    }

    Rectangle(int width, int height) {   // el único constructor "real"
        this.width = width;
        this.height = height;
    }
}

public class Main {
    public static void main(String[] args) {
        Rectangle r = new Rectangle(4);
        System.out.println(r.width + "x" + r.height);   // 4x4
    }
}

Ahora la inicialización real vive en un solo sitio. Los constructores más pequeños solo rellenan los valores por defecto y delegan el trabajo. Si alguna vez intentas poner una instrucción antes de this(...), el compilador la rechaza.

Los constructores y super()

Cada constructor llama implícitamente primero al constructor de su superclase. Si no escribes nada, Java inserta un super() oculto (el constructor sin argumentos de la superclase) al principio del cuerpo. Trabajarás con esto directamente en cuanto empieces a crear subclases, que es el próximo tema.

class Animal {
    String name;
    Animal(String name) { this.name = name; }
}

class Dog extends Animal {
    Dog(String name) {
        super(name);   // aquí hay que llamar al constructor del padre explícitamente
    }
}

Como Animal no tiene constructor sin argumentos, Dog debe llamar a super(name) explícitamente: no hay un super() gratuito al que recurrir. Igual que this(), una llamada a super(...) tiene que ser la primera instrucción del constructor.

Próximo: Herencia

Los constructores inicializan un único objeto, pero super() ya insinuó algo más grande: las clases pueden construirse sobre otras clases, reutilizando sus campos, métodos y constructores. Esa relación, una clase que extiende a otra, es la herencia, y es la próxima página.