Construtores do Java

Neste tutorial, você aprenderá sobre os construtores do Java, como criar e usá-los e os diferentes tipos de construtores, com a ajuda de exemplos.

O que é um construtor?

No Java, cada classe tem seu construtor, que é automaticamente chamado quando o objeto da classe é criado. O construtor é semelhante a um método, mas na verdade não é um método.

umJava MethodsE os construtores do Java são distinguidos por seu nome e tipo de retorno. O construtor tem o mesmo nome da classe e não retorna nenhum valor. Por exemplo,

class Test {
　　　　Test() {
　　　　　　　　//corpo do construtor
　　　　}
}

Aqui, Test() é um construtor. Ele tem o mesmo nome da classe e não tem tipo de retorno.

class Test {
　　　　void Test() {
　　　　　　　　//　Corpo do método
　　　　}
}

　Aqui, Test() tem o mesmo nome da classe, mas tem um tipo de retorno void. Portanto, é um método e não um construtor.

Exemplo: Construtores do Java

class Main {
　　　private int x;
　　　//　corpo do construtor
　　　private Main(){
　　　　　　　System.out.println("O construtor foi chamado");
　　　　　　　x =　5;
　　　}
　　　public static void main(String[] args){
　　　　　　　//Chamada do construtor ao criar o objeto
　　　　　　　Main obj = new Main();
　　　　　　　System.out.println("O valor de x = ")　+　obj.x);
　　　}
}

saída:

O construtor foi chamado
O valor de x =　5

　No exemplo acima, temos um construtor privado chamado Main(). No método main, estamos criando um objeto da classe chamado obj.

Main obj = new Main();

　Durante este processo, será chamado o construtor. Portanto, execute a instrução print e inicialize a variável x.

Tipos de construtores

No Java, os construtores podem ser divididos em3Tipo:

• Parameterless Constructor

• Default Constructor

• Construtor com parâmetros

Parameterless Constructor

Os construtores do Java podem ter ou não ter qualquer parâmetro. Se o construtor não aceita nenhum parâmetro, é chamado de construtor sem parâmetros. Por exemplo,

private Constructor() {
　　　//　corpo do construtor
}

Exemplo de construtor sem parâmetros

class Main {
　　　int i;
　　　//construtor sem parâmetros
　　　private Main(){
　　　　　　　i =　5;
　　　　　　　System.out.println("Objeto criado e i = ")　+　i);
　　　}
　　　public　static　void　main(String[]　args)　{
　　　　　　　//Chamada do construtor sem parâmetros
　　　　　　　Main obj = new Main();
　　　}
}

saída:

Objeto criado e i =　5

Aqui, a função Main() não aceita nenhum parâmetro.

Você notou que o modificador de acesso do construtor Main() é privado (private)?

Isso é porque o objeto foi instanciado a partir da mesma classe. Portanto, ele pode acessar o construtor.

Mas, se o objeto for criado fora da classe, deve declarar o construtor como public para acessá-lo. Por exemplo:

class　Company　{
　　　　String　domainName;
　　　　//　Construtor público
　　　　public　Company(){
　　　　　　　　domainName = "oldtoolbag.com";
　　　　}
}
public class Main {
　　　　
　　　　public　static　void　main(String[]　args)　{
　　　　　　　　//　Criar objetos em outra classe
　　　　　　　　Company companyObj = new Company();
　　　　　　　　System.out.println("Domain name = ",+　companyObj.domainName);
　　　　}
}

saída:

Domain name = oldtoolbag.com

Leia mais: Java Access Modifiers

Default Constructor

Se não criar nenhum construtor, o compilador Java criará automaticamente um construtor sem parâmetros durante a execução. Este construtor é chamado construtor padrão. O construtor padrão inicializa todos os campos de instância não inicializados com valores padrão.

Exemplo: Construtor padrão

class DefaultConstructor {
　　　　int a;
　　　　boolean b;
　　　　public　static　void　main(String[]　args)　{
　　　　　　　　//Chamada do construtor padrão
　　　　　　　　DefaultConstructor obj = new DefaultConstructor();
　　　　　　　　System.out.println("a = ",　+　obj.a);
　　　　　　　　System.out.println("b = ",　+　obj.b);
　　　　}
}

saída:

a = 0
b = false

No programa acima, ainda não inicializamos os valores das variáveis a e b. Mas, quando criamos um objeto da classe, podemos ver que esses valores já foram inicializados com alguns valores em saída.

　Isso é porque o compilador Java cria automaticamente um construtor padrão. O construtor usará os valores padrão 0 e false para inicializar os valores das variáveis a e b.

O programa acima é equivalente a:

class DefaultConstructor {
　　　　int a;
　　　　boolean b;
　　　　//Construtor privado　
　　　　private DefaultConstructor() {
　　　　　　　　a = 0;
　　　　　　　　b = false;
　　　　}
　　　　public　static　void　main(String[]　args)　{
　　　　　　　　//Chamada do construtor
　　　　　　　　DefaultConstructor obj = new DefaultConstructor();
　　　　　　　　System.out.println("a = ",　+　obj.a);
　　　　　　　　System.out.println("b = ",　+　obj.b);
　　　　}
}

saída:

a = 0
b = false

Parameterized constructors

Muito parecido com métodos, podemos passar parâmetros para o construtor. Este construtor chamado construtor parametrizado. Por exemplo,

private Constructor (arg1, arg2, ..., argn) {
　　　　//　corpo do construtor
}

Exemplo: construtor parametrizado

class　Vehicle　{
　　　　int　wheels;
　　　　//construtor aceitando um único valor
　　　　private　Vehicle(int　wheels){
　　　　　　　　this.wheels　=　wheels;
　　　　　　　　System.out.println(wheels　+　"veículo com rodas criado.");
　　　　}
　　　　public　static　void　main(String[]　args)　{
　　　　　　　　//chamada do construtor passando um único valor
　　　　　　　　Vehicle　v1　=　new　Vehicle(2);
　　　　　　　　Vehicle　v2　=　new　Vehicle(3);
　　　　　　　　Vehicle　v3　=　new　Vehicle(4);
　　　　}
}

saída:

2　veículo com rodas criado.
3　veículo com rodas criado.
4　veículo com rodas criado.

No exemplo acima, temos um construtor chamado Vehicle(). O construtor aceita um parâmetro chamado wheels.

Aqui, ao criar objetos, passamos parâmetros para os construtores. E, com base nos parâmetros, ele está gerando a saída.

sobre a sobrecarga de construtores em Java

　Da mesma forma que o sobrecarga de métodos, também podemos sobrecarregar construtores em Java. Se você não está familiarizado com a sobrecarga de métodos, acesseJava Method Overloading.

No sobrecarga do construtor, há dois ou mais construtores com parâmetros diferentes. Por exemplo:

class　Company　{
　　　　String　domainName;
　　　　//construtor sem parâmetros
　　　　public　Company(){
　　　　　　　　this.domainName　=　"default";
　　　　}
　　　　//construtor com um único parâmetro
　　　　public　Company(String　domainName){
　　　　　　　　this.domainName　=　domainName;
　　　　}
　　　　public　void　getName(){
　　　　　　　　System.out.println(this.domainName);
　　　　}
　　　　public　static　void　main(String[]　args)　{
　　　　　　　　//chamada do construtor sem parâmetros
　　　　　　　　Company　defaultObj　=　new　Company();
　　　　　　　　//chamada do construtor com um único parâmetro
　　　　　　　　Company　w3codeboxObj　=　new　Company("oldtoolbag.com");
　　　　　　　　defaultObj.getName();
　　　　　　　　w3codeboxObj.getName();
　　　　}
}

saída:

default
oldtoolbag.com

No exemplo acima, temos dois construtores: public Company() e public Company(String domainName).

Aqui, os dois construtores inicializam as variáveis domainName com valores diferentes.Therefore, based on the values we need, we can call the constructor from the main() method.

Note that we use the this keyword to specify class variables. For more information about the this keyword, please visitJava This Keyword.

Important Note

• 　Constructors are implicitly called when instantiating objects.
  

• The two rules for creating constructors are:

• The name of the constructor should be the same as the name of the class.

• Java constructors may not have a return type.

• If the class does not have a constructor, the Java compiler will automatically create one at runtimeDefault Constructor. The default constructor initializes instance variables with default values. For example, an int variable will be initialized to 0

• Constructor Types:

• Parameterless Constructor　 - Constructors that do not accept any parameters

• Default Constructor　 - If no constructor is explicitly defined, the Java compiler will automatically create one.

• Parameterized constructors　 - Constructors that accept parameters

• Constructors cannot be abstract, static, or final.
  

• Constructors can be overloaded but cannot be overridden.