Desconstruindo os Construtores

No artigo sobre classes em Java, mencionei os construtores e prometi escrever um artigo dedicado a eles. Isso porque uma classe não pode existir sem um construtor. Assim como Julius, em Todo Mundo Odeia o Chris, os construtores sempre “estarão lá”.

Optei por abordar esse tema separadamente por dois motivos:

1. O artigo sobre classes ficaria muito extenso e denso, o que foge do objetivo dos textos publicados aqui.
2. Aproveitarei a introdução aos construtores para explicar a sobrecarga, um conceito importante na programação orientada a objetos.

Quando disse que uma classe é composta por propriedades e métodos, eu… menti. Ou melhor, omiti um detalhe essencial: os construtores. Vamos explorar esse conceito em profundidade.

Toda classe tem um construtor

“Mas minha classe tem apenas métodos e propriedades!”

Não importa. Toda classe possui um construtor, ainda que não seja explicitamente declarado.

Considere a seguinte classe:

public class Person {
    public String name;
    public char gender;
    public byte age;
}

Ao olhar para esse código, pode parecer que não há um construtor. No entanto, quando o Java compila essa classe e gera o bytecode (.class), um construtor padrão é criado automaticamente.

Se quiser comprovar, compile o código e verifique a pasta out. Você verá algo assim:

public class Person {
    public String name;
    public char gender;
    public byte age;

    public Person() {}
}J

Mesmo sem declará-lo, o construtor está presente. Isso acontece porque toda classe em Java sempre tem um construtor.

📌 Caso não saiba como funciona o processo de compilação do Java, recomendo este artigo: Java: Write Once, Run Anywhere

Para que serve um construtor?

O próprio nome já dá uma pista: Construtor == construir.

Ele auxilia na criação de objetos, garantindo que uma instância da classe seja inicializada corretamente.

Veja um exemplo simples de como um iniciante provavelmente criaria um objeto Person:

public static void main(String[] args) {
    Person scarlett = new Person();
    scarlett.name = "Scarlett";
    scarlett.gender = 'F';
    scarlett.age = 26;
}

Esse código tem dois problemas:

1. Excesso de linhas — a inicialização poderia ser mais direta.
2. Nenhuma obrigatoriedade — as propriedades poderiam ficar vazias e assumir valores padrão: null para String, um espaço em branco para char e 0 para números.

O construtor resolve isso, tornando o preenchimento obrigatório.

Criando um construtor

A sintaxe de um construtor é parecida com a de um método, mas sem retorno (nem mesmo void).

public Person() {}

Agora, preencha o construtor para assegurar que os atributos sejam inicializados ao instanciar um objeto:

public Person(String name, char gender, byte age) {
    this.name = name;
    this.gender = gender;
    this.age = age;
}

O uso de this diferencia os parâmetros recebidos das propriedades da classe.

Agora, ao criar uma instância, os valores precisarão ser informados:

Person scarlett = new Person("Scarlett", 'F', (byte) 26);

Isso reduz o código e evita inicializações incompletas.

E se eu precisar adicionar um novo atributo?

Imagine que, durante o desenvolvimento, surge a necessidade de incluir a data de nascimento (birthday). Alterar o construtor original pode gerar erros em partes do código que já usam a classe.

A solução? Sobrecarga de construtores.

Criamos um novo construtor, incluindo a nova propriedade:

public Person(String name, char gender, byte age) {
    this.name = name;
    this.gender = gender;
    this.age = age;
}

public Person(String name, char gender, byte age, Date birthday) {
    this.name = name;
    this.gender = gender;
    this.age = age;
    this.birthday = birthday;
}

Isso funciona, mas ainda há uma má prática presente: a repetição de código. Para evitá-la, podemos chamar um construtor dentro do outro utilizando this():

public Person(String name, char gender, byte age) {
    this.name = name;
    this.gender = gender;
    this.age = age;
}

public Person(String name, char gender, byte age, Date birthday) {
    this(name, gender, age);
    this.birthday = birthday;
}

📌 Lembre-se: o uso de this() para invocar outro construtor deve ser sempre a primeira instrução dentro do construtor.

Agora, dependendo do número de parâmetros informados, o Java seleciona o construtor adequado.

Person p1 = new Person("Scarlett", 'F', (byte) 26);   // Chama o primeiro construtor
Person p2 = new Person("Scarlett", 'F', (byte) 26, new Date()); // Chama o segundo

Isso torna o código mais limpo, reutilizável e flexível.

Conclusão

Os construtores são fundamentais para garantir que os objetos sejam instanciados corretamente. Eles permitem inicializar valores obrigatórios e evitam inconsistências. Além disso, a sobrecarga possibilita a criação de múltiplos construtores, tornando a classe mais adaptável.

Ou seja, desconstruímos os construtores! 😆

Espero que este artigo tenha sido útil. Até a próxima! 🚀