freeCodeCamp/guide/portuguese/java/constructors/index.md

---
title: Constructors
localeTitle: Construtores
---
Se um objeto copia de uma classe, qual é o objetivo? Eu deveria ser capaz de armazenar os dados, certo?

É quando usamos métodos **getter** (por exemplo, getName ()) / **setter** (por exemplo, setName ()) ou, neste caso, construtores, para inicializar uma classe. Basicamente, toda classe Java possui um construtor que é o método chamado primeiro quando qualquer objeto da classe é inicializado. Pense nisso como um pouco de código inicial.

Quando você escreve uma classe sem nenhum construtor, o compilador Java cria um construtor padrão:

```java
public class Car { 
    private String name; 
 } 
 
 Car modelS = new Car(); 
```

Esta inicialização sem parâmetros é uma maneira de chamar o construtor padrão. Você também pode ter um construtor padrão escrito desta maneira:

```java
public class Car { 
    private String name; 
 
    // User Specified Default Constructor 
    public Car() { 
        name = "Tesla"; 
    } 
 } 
```

Em seguida, ao chamar `new Car()` , o `name` da variável será inicializado automaticamente como "Tesla" para essa instância do objeto Car.

Claramente, os construtores são exatamente como soam: eles são usados ​​para `construct` , isto é, instanciar um objeto de uma classe particular.  
Os construtores são semelhantes às declarações de método, mas são ligeiramente diferentes no sentido de que eles:

1.  São nomeados exatamente da mesma maneira que a classe.
2.  Não tem um tipo de retorno.

Portanto, o propósito de usar `constructors` é fornecer:

1.  Uma maneira de instanciar um objeto.
2.  Forneça valores iniciais para as propriedades de um objeto.
3.  Controle como um objeto é criado.

Vamos ver outro exemplo. Digamos, a Honda (fabricante de automóveis), quer que todos os seus carros sejam chamados `Honda <a name>` . Para reforçar isso, podemos representar isso usando uma classe da seguinte maneira:

```java
public class Car { 
 
    private String name; 
 
    // Constructor. 
    public Car(String model){ 
        this.name = "Honda " + model; 
    } 
 
    public String getName(){ 
        return this.name; 
    } 
 
    public static void main(String args[]){ 
        Car car = new Car("Civic"); 
        System.out.println( car.getName() ); 
    } 
 } 
```

![:rocket:](//forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=2 ":foguete:") [Executar código](https://repl.it/CTJ4/1)

Observe que, quando escrevemos um construtor dessa maneira, ou seja, fornecendo um parâmetro, estamos controlando (ponto no. 3) a maneira como uma instância de `Car` é criada. Resumindo, estamos dizendo neste exemplo que **você DEVE fornecer um nome de modelo para obter uma instância da classe Car** .

Por que isso é importante? Há momentos em que você deseja `one and only one` instância de uma classe para uso em todo o aplicativo. Uma maneira de conseguir isso é usando um construtor `private` .

Suponha que você precise de uma aula para representar um banco. Você não gostaria que as pessoas criassem uma instância do `Bank` . Então, você projeta sua classe:

```java
public class Bank { 
 
    private static Bank instance; 
 
    private Bank(){ 
    } 
 
    public static Bank getInstance(){ 
        if(null == instance){ 
            instance = new Bank(); 
        } 
        return instance; 
    } 
 } 
```

![:rocket:](//forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=2 ":foguete:") [Executar código](https://repl.it/CTJz/0)

Observe que o construtor é `private` . Isso impõe o fato de que ninguém mais tem permissão para criar uma instância do Banco.  
De fato, se em outra classe, você tentar:

```java
Bank account = new Bank(); // Throws a compilation error: Bank() has private access in Bank. 
```

Assim, a única maneira de obter acesso à instância é usando `Bank.getInstance()` . Essas instâncias são chamadas `Singleton` pois você obtém exatamente uma instância (por VM, para ser mais precisa) durante a vida útil do seu aplicativo.

Pode haver muitos números de construtores em uma classe. Mas eles devem diferir nos parâmetros do método. Isto é Sobrecarga de Construtor. Para ser preciso, dizemos que a sobrecarga do construtor ocorreu quando há dois ou mais construtores com o mesmo nome, mas diferentes parâmetros de método. Como resultado, as duas funções possuem assinaturas de métodos diferentes e são tratadas por Java como construtores diferentes inteiramente. Por exemplo:

```java
public class Car { 
 
    private String name; 
    private String carType; 
 
    // Constructor. 
    public Car(){ 
        this.name = "No Name"; 
        this.carType = "No Type"; 
    } 
    public Car(String model){ 
        this.name = "Honda " + model; 
    } 
 
    public Car(String model, String carType){ 
        this.name = model; 
        this.carType = carType; 
    } 
 
    public String getName(){ 
        return this.name; 
    } 
 
    public String getCarType(){ 
        return this.name; 
    } 
 
    public static void main(String args[]){ 
        Car car = new Car("Civic"); 
        System.out.println( car.getName() ); 
 
        // Other Way To Initialize 
        Car car = new Car("Civic","Sedan"); 
        System.out.println( car.getName() + " "+ car.getCarType() ); 
 
    } 
 } 
```

Assim, a única maneira de obter acesso à instância é usando `Bank.getInstance()` . Essas instâncias são chamadas `Singleton` pois você obtém exatamente uma instância (por VM, para ser mais precisa) durante a vida útil do seu aplicativo.

## Construtor de cópia

O construtor de cópia é um construtor que cria um objeto, inicializando-o com um objeto da mesma classe, que foi criada anteriormente. O construtor de cópia é usado para

1.  Inicialize um objeto de outro do mesmo tipo.
2.  Copie um objeto para passá-lo como um argumento para uma função.
3.  Copie um objeto para retorná-lo de uma função. Aqui está um programa que mostra um uso simples do construtor de cópia:

```Java
class Complex { 
 
    private double re, im; 
 
    // A normal parametrized constructor 
    public Complex(double re, double im) { 
        this.re = re; 
        this.im = im; 
    } 
 
    // Copy constructor 
    Complex(Complex c) { 
        System.out.println("Copy constructor called"); 
        re = c.re; 
        im = c.im; 
    } 
 
    } 
 } 
```

[execute o código completo](https://repl.it/MwnJ)

// ## Constructor Chaining