Sobrecarregar um construtor em Java

Mohammad Irfan 12 outubro 2023

Java Java Constructor

Construtor padrão em Java
Construtor parametrizado em Java
Código sem sobrecarga do construtor
Sobrecarga de construtor em Java
Práticas recomendadas de sobrecarga de construtor
Sobrecarregar um construtor

Este tutorial apresenta como sobrecarregar construtores em Java. Também listamos alguns códigos de exemplo que você pode seguir para entender melhor este tópico.

Um construtor é um método chamado para alocar memória para um objeto de classe e inicializar os atributos de classe para esse objeto. Se nenhum construtor foi criado para uma classe, Java fornece um construtor padrão.

Por exemplo, nenhum construtor foi definido na classe abaixo. Ainda assim, podemos criar um objeto dessa classe enquanto os atributos são inicializados com seus valores padrão (nulo, neste caso).

Construtor padrão em Java

class Student {
  String name;
  Double gpa;
}
public class Main {
  public static void main(String[] args) {
    Student s = new Student();
    System.out.println(s.name + "\t" + s.gpa);
  }
}

Produção:

null	null

O conceito de sobrecarga do construtor é semelhante à sobrecarga do método, o que significa que temos mais de um construtor para uma única classe. A sobrecarga do construtor é feita para inicializar as variáveis de membro da classe de maneiras diferentes.

Podemos criar quantos construtores sobrecarregados quisermos. A única condição é que os construtores sobrecarregados sejam diferentes no número e no tipo de parâmetros que assumem.

Por exemplo, considere a classe Student mostrada abaixo com dois atributos: nome do aluno e GPA. Um construtor é definido para a classe, que leva um nome de string e um duplo GPA como parâmetros e inicializa os atributos correspondentes para o novo objeto.

Construtor parametrizado em Java

class Student {
  String name;
  Double gpa;
  Student(String s, Double g) {
    name = s;
    gpa = g;
  }
}
public class Main {
  public static void main(String[] args) {
    Student s = new Student("Justin", 9.75);
    System.out.println(s.name + "\t" + s.gpa);
  }
}

Produção:

Justin	9.75

Código sem sobrecarga do construtor

Considere um cenário onde apenas o nome do aluno é passado para o construtor ao criar um novo objeto; o GPA deve ser automaticamente definido como null neste caso. Se não sobrecarregarmos o construtor e apenas passarmos o nome, obteremos o seguinte erro de compilação.

class Student {
  String name;
  Double gpa;
  Student(String s, Double g) {
    name = s;
    gpa = g;
  }
}
public class Main {
  public static void main(String[] args) {
    Student s = new Student("Justin");
    System.out.println(s.name + "\t" + s.gpa);
  }
}

Produção:

Exception in thread "main" java.lang.Error: Unresolved compilation problem: 
	The constructor Student(String) is undefined

	at ConstructorOverloading.main(ConstructorOverloading.java:18)

Sobrecarga de construtor em Java

Podemos criar um construtor sobrecarregado com apenas o nome do aluno como parâmetro para lidar com a situação acima. Vamos definir o GPA como null quando este construtor for chamado.

class Student {
  String name;
  Double gpa;
  Student(String s, Double g) {
    name = s;
    this.gpa = g;
  }
  Student(String s) {
    name = s;
    gpa = null; // Setting GPA to null
  }
}
public class Main {
  public static void main(String[] args) {
    Student s1 = new Student("Justin");
    Student s2 = new Student("Jessica", 9.23);
    System.out.println(s1.name + "\t" + s1.gpa);
    System.out.println(s2.name + "\t" + s2.gpa);
  }
}

Produção:

Justin	null
Jessica	9.23

Considere outra situação em que um objeto Student é criado, mas nem o nome nem o GPA foram mencionados. Podemos fazer outro construtor sobrecarregado que não receba argumentos (construtor padrão) e defina os atributos name e GPA como null.

Lembre-se de que Java fornece um construtor padrão apenas quando nenhum outro construtor é criado para uma classe. Mas, para nossa classe, já existem construtores e, portanto, precisamos criar um construtor padrão.

class Student {
  String name;
  Double gpa;
  Student(String s, Double g) {
    name = s;
    gpa = g;
  }
  Student(String s) {
    name = s;
    gpa = null;
  }
  Student() {
    name = null;
    gpa = null;
  }
}
public class Main {
  public static void main(String[] args) {
    Student s1 = new Student();
    Student s2 = new Student("Justin");
    Student s3 = new Student("Jessica", 9.23);
    System.out.println(s1.name + "\t" + s1.gpa);
    System.out.println(s2.name + "\t" + s2.gpa);
    System.out.println(s3.name + "\t" + s3.gpa);
  }
}

Produção:

null	null
Justin	null
Jessica	9.23

Práticas recomendadas de sobrecarga de construtor

Não há diretrizes definidas a serem seguidas ao sobrecarregar os construtores. No entanto, existem algumas práticas recomendadas que podemos seguir para evitar confusão e reduzir o escopo do erro.

Deve-se usar a palavra-chave this para fazer referência às variáveis de membro da classe. Isso evita confusão e torna nosso código mais legível.
Também podemos passar nomes de parâmetros mais intuitivos para o construtor. Por exemplo, se um construtor inicializar o campo de nome, a assinatura do construtor poderia ser Student(String name) em vez de Student(String s). Usando a palavra-chave this, podemos diferenciar entre o parâmetro, denominado name, e o atributo de classe, também denominado name.

Vamos continuar com o exemplo da classe Student e usar a palavra-chave this dentro dos construtores.

class Student {
  String name;
  Double gpa;
  Student(String name, Double gpa) // passing more intuitive parameter names
  {
    this.name = name; // using this keyword to avoid confusion
    this.gpa = gpa;
  }
  Student(String name) {
    this.name = name;
    this.gpa = null;

    Student()

        this.name = null;
    this.gpa = null;
  }
}

Também é uma boa prática para uma classe ter apenas um único construtor primário, e todos os construtores restantes devem chamar esse construtor primário para inicializar os atributos.
Podemos chamar um construtor de outro construtor usando a função this(). O número e os tipos de atributos que passamos para this() decidirão qual construtor será chamado.
Isso reduzirá a redundância de código e só precisamos escrever a lógica para um único construtor.
Na classe Student, precisamos de três construtores sobrecarregados. O construtor primário será aquele parametrizado que leva name e GPA como parâmetros. Os outros dois construtores sobrecarregados simplesmente chamarão o construtor primário e passarão os valores dos parâmetros como null.

class Student {
  String name;
  Double gpa;
  Student(String name, Double gpa) // Primary Constructor that sets the attribute values
  {
    this.name = name;
    this.gpa = gpa;
  }
  Student(String name) {
    this(name, null); // Calling the primary constructor with GPA as null
  }
  Student() {
    this(null, null); // Calling the primary constructor with both parameters as null
  }
}