Costruttori in Java: inizializzare oggetti con new

Perché esistono i costruttori

Nella pagina precedente hai costruito classi e creato oggetti con new. Un costruttore è il codice che viene eseguito proprio durante quella chiamata a new. Il suo unico scopo è restituire un oggetto pronto all'uso: tutti i campi necessari impostati, nessuno stato inizializzato a metà.

Un costruttore assomiglia a un metodo, con due differenze: ha lo stesso nome della classe e nessun tipo di ritorno, nemmeno void.

class Point {
    int x;
    int y;

    Point(int x, int y) {     // costruttore: stesso nome della classe, nessun tipo di ritorno
        this.x = x;
        this.y = y;
    }
}

public class Main {
    public static void main(String[] args) {
        Point p = new Point(3, 4);   // qui viene eseguito il costruttore
        System.out.println(p.x + ", " + p.y);
    }
}

new Point(3, 4) alloca l'oggetto e poi esegue il corpo del costruttore con x = 3 e y = 4. Quando new restituisce il controllo, p è completamente inizializzato.

La parola chiave this

Nel costruttore qui sopra, i parametri si chiamano x e y, come i campi. this.x significa "il campo x di questo oggetto", mentre x da solo si riferisce al parametro. Senza this, x = x assegnerebbe il parametro a se stesso e lascerebbe il campo invariato.

class Account {
    String owner;
    double balance;

    Account(String owner, double balance) {
        this.owner = owner;       // campo = parametro
        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);
    }
}

this è necessario solo quando un parametro nasconde un campo, ma molti lo usano ovunque per chiarezza. L'errore comune è dimenticarlo quando i nomi coincidono: il codice compila, gira e lascia in silenzio i campi ai loro valori predefiniti (null, 0, false).

Il costruttore di default

Se non scrivi mai un costruttore, Java ne fornisce silenziosamente uno di default: un costruttore public, senza argomenti, che non fa niente di speciale. Ecco perché new funzionava su classi che non avevano alcun costruttore.

Il problema: appena scrivi un qualsiasi costruttore, quello gratuito sparisce.

class Box {
    int size;

    Box(int size) {       // ora NON esiste un costruttore senza argomenti
        this.size = size;
    }
}

new Box();   // errore di compilazione: il costruttore Box() non esiste

Se vuoi ancora che new Box() funzioni, dichiara tu il costruttore senza argomenti:

class Box {
    int size;

    Box() {               // costruttore esplicito senza argomenti
        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
    }
}

Overloading dei costruttori

Una classe può avere più costruttori, purché le liste di parametri siano diverse: è semplicemente l'overloading dei metodi applicato ai costruttori. Ognuno offre un modo diverso di costruire l'oggetto.

class Rectangle {
    int width;
    int height;

    Rectangle() {                 // un quadrato 1x1 di default
        this.width = 1;
        this.height = 1;
    }

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

    Rectangle(int width, int height) {   // un rettangolo 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 sceglie il costruttore corrispondente in base al numero e ai tipi degli argomenti che passi a new.

Concatenare con this()

Nota la ripetizione qui sopra: ogni costruttore assegna i campi per conto suo. Puoi evitarlo facendo in modo che un costruttore ne chiami un altro con this(...). La chiamata deve essere la prima istruzione del costruttore.

class Rectangle {
    int width;
    int height;

    Rectangle() {
        this(1, 1);          // delega al costruttore con due argomenti
    }

    Rectangle(int side) {
        this(side, side);    // delega anche questo
    }

    Rectangle(int width, int height) {   // l'unico costruttore "vero"
        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
    }
}

Ora l'inizializzazione vera e propria sta in un unico punto. I costruttori più piccoli si limitano a fornire valori predefiniti e passare il lavoro. Se provi a mettere un'istruzione prima di this(...), il compilatore la rifiuta.

I costruttori e super()

Ogni costruttore chiama implicitamente per primo il costruttore della sua superclasse. Se non scrivi nulla, Java inserisce un super() nascosto (il costruttore senza argomenti della superclasse) all'inizio del corpo. Lo userai direttamente quando inizierai a creare sottoclassi, che è il prossimo argomento.

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

class Dog extends Animal {
    Dog(String name) {
        super(name);   // qui bisogna chiamare esplicitamente il costruttore del padre
    }
}

Dato che Animal non ha un costruttore senza argomenti, Dog deve chiamare esplicitamente super(name): non c'è un super() gratuito su cui ripiegare. Come this(), anche una chiamata a super(...) deve essere la prima istruzione del costruttore.

Prossimo passo: l'ereditarietà

I costruttori inizializzano un singolo oggetto, ma super() ha già accennato a qualcosa di più grande: le classi possono basarsi su altre classi, riutilizzandone campi, metodi e costruttori. Questa relazione, in cui una classe ne estende un'altra, si chiama ereditarietà, ed è l'argomento della prossima pagina.