Construtores em Java: inicializando objetos com new

Por que os construtores existem

Na página anterior, você criou classes e objetos com new. Um construtor é o código que de fato é executado durante essa chamada a new. Seu único objetivo é devolver um objeto pronto para uso: com todos os campos obrigatórios definidos e sem nenhum estado pela metade.

Um construtor se parece com um método, mas com duas diferenças: ele tem o mesmo nome da classe e não tem tipo de retorno, nem mesmo void.

class Point {
    int x;
    int y;

    Point(int x, int y) {     // construtor: mesmo nome da classe, sem tipo de retorno
        this.x = x;
        this.y = y;
    }
}

public class Main {
    public static void main(String[] args) {
        Point p = new Point(3, 4);   // o construtor é executado aqui
        System.out.println(p.x + ", " + p.y);
    }
}

new Point(3, 4) aloca o objeto e depois executa o corpo do construtor com x = 3 e y = 4. Quando new retorna, p já está totalmente inicializado.

A palavra-chave this

Dentro do construtor acima, os parâmetros se chamam x e y, os mesmos nomes dos campos. this.x significa "o campo x que pertence a este objeto", enquanto x puro se refere ao parâmetro. Sem this, x = x apenas atribuiria o parâmetro a si mesmo e deixaria o campo intocado.

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);
    }
}

Você só precisa de this quando um parâmetro oculta um campo, mas muita gente o usa em todo lugar por clareza. O erro comum é esquecê-lo quando os nomes coincidem: o código compila, executa e silenciosamente deixa seus campos com os valores padrão (null, 0, false).

O construtor padrão

Se você nunca escrever um construtor, o Java fornece discretamente um construtor padrão: um construtor público, sem argumentos, que não faz nada a mais. Por isso new funcionava em classes que não tinham construtor algum.

A pegadinha: assim que você escreve qualquer construtor, o gratuito some.

class Box {
    int size;

    Box(int size) {       // agora NÃO há construtor sem argumentos
        this.size = size;
    }
}

new Box();   // erro de compilação: o construtor Box() não existe

Se você ainda quiser que new Box() funcione, declare você mesmo o construtor sem argumentos:

class Box {
    int size;

    Box() {               // construtor sem 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 construtores

Uma classe pode ter vários construtores desde que suas listas de parâmetros sejam diferentes: isso é apenas a sobrecarga de métodos aplicada aos construtores. Cada um oferece uma maneira diferente de construir o objeto.

class Rectangle {
    int width;
    int height;

    Rectangle() {                 // um quadrado 1x1 padrão
        this.width = 1;
        this.height = 1;
    }

    Rectangle(int side) {         // um quadrado
        this.width = side;
        this.height = side;
    }

    Rectangle(int width, int height) {   // um retâ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
    }
}

O Java escolhe o construtor correspondente pelo número e pelos tipos dos argumentos que você passa para new.

Encadeamento com this()

Repare na duplicação acima: cada construtor atribui os campos por conta própria. Você pode evitar isso fazendo um construtor chamar outro com this(...). A chamada deve ser a primeira instrução do construtor.

class Rectangle {
    int width;
    int height;

    Rectangle() {
        this(1, 1);          // delega ao construtor de dois argumentos
    }

    Rectangle(int side) {
        this(side, side);    // também delega
    }

    Rectangle(int width, int height) {   // o único construtor "de verdade"
        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
    }
}

Agora a inicialização de fato fica em um só lugar. Os construtores menores apenas preenchem os valores padrão e repassam o trabalho. Se você algum dia tentar colocar uma instrução antes de this(...), o compilador a rejeita.

Construtores e super()

Todo construtor chama implicitamente o construtor da superclasse primeiro. Se você não escrever nada, o Java insere um super() oculto (o construtor sem argumentos da superclasse) no topo do corpo. Você trabalhará com isso diretamente assim que começar a criar subclasses, que é o próximo tópico.

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

class Dog extends Animal {
    Dog(String name) {
        super(name);   // aqui é preciso chamar o construtor do pai explicitamente
    }
}

Como Animal não tem construtor sem argumentos, Dog precisa chamar super(name) explicitamente: não há um super() gratuito para recorrer. Assim como this(), uma chamada a super(...) tem que ser a primeira instrução do construtor.

Próximo: Herança

Os construtores inicializam um único objeto, mas super() já deu uma pista de algo maior: as classes podem se basear em outras classes, reutilizando seus campos, métodos e construtores. Essa relação, uma classe estendendo outra, é a herança, e é a próxima página.