Construtores

###### << Anterior - Home - Próxima >>

São métodos especiais que servem para construir e inicializar instâncias de uma classe (novos objetos). Em geral os construtores são responsáveis por atribuir valores iniciais para os atributos do novo objeto que está sendo criado, mas eventualmente pode ser necessário algum processamento adicional que vai além da inicialização de atributos.

Toda classe **precisa** ter pelo menos um construtor para criar objetos. Se não for declarado nenhum construtor explicitamente na classe, o Java irá criar um construtor padrão implícito sem parâmetros e sem código. Então os atributos da classe irão manter o seu valor default que é zero para os atributos numéricos, false para os booleanos e nulo para strings e outros objetos. É importante notar que o Java só criará o construtor implícito padrão se não for definido nenhum construtor explícito para a classe.

Quando um construtor é implementado, tenha em mente que sua principal função é atribuir valores válidos para todos os atributos garantindo assim que o objeto já inicie com valores apropriados para seu correto funcionamento.

**Importante:**

* Todo construtor tem exatamente o mesmo nome que a classe.
* Faça construtores públicos. É possível a existência de construtores privados ou protegidos, mas são utilizados apenas em situações especiais.
* **Não tem retorno explícito (nem mesmo void).** Se for declarado algum tipo de retorno para o construtor, ele deixa de ser considerado um construtor pelo java.
* Para construir objetos, deve ser chamado através do operador **new**.

**Exemplo de construção de um novo objeto:**

```
UmaClasse vr; // vr é uma variável de referência

vr = new UmaClasse(); /* UmaClasse() é o construtor da classe UmaClasse*/
// A partir daqui, vr contém uma referência válida ao novo objeto.

```

No exemplo acima estamos construindo um novo objeto da classe **UmaClasse**. A primeira linha declara uma variável de referência (**vr**) para conter o novo objeto que será criado. Note que **UmaClasse** é o tipo dessa variável e também a classe que será instanciada.

A construção do objeto acontece realmente na segunda linha, na seguinte seqüência:

1. O operador **new** aloca memória suficiente para conter o objeto.
2. O construtor da classe ( **UmaClasse**() ) é chamado para inicializar os atributos do novo objeto.
3. Uma referência ao novo objeto (endereço de memória) é retornada e armazenada na variável de referencia (**vr**).

**Não confunda a variável de referência com o objeto em si.** O objeto existe na memória, não está dentro da variável, a variável apenas faz referência ao objeto, ou seja, essa variável é na verdade um ponteiro para o objeto, não o próprio objeto. Somente depois que o objeto foi construído é que é possível utilizar os métodos que ele tem disponíveis.

Um objeto sem referência, ou seja, que não tem nenhuma variável apontando para ele, será automaticamente destruído pelo Java.

**Exemplo de declaração do construtor na classe:**

```
public class UmaClasse {
    // Aqui os atributos são declarados.

    // Construtor da classe
    public UmaClasse (){
        // Aqui os atributos da classe são inicializados
    }

    // Um método oferecido pela classe
    public void UmMetodo () {
        // Aqui o código executado pelo método
    }

} // Encerra a declaração da classe

```

## Operador new

É o operador de instanciação do java, deve ser usado sempre que um novo objeto é criado. Exige um operando que é algum construtor da classe que está sendo instanciada. Na pratica o que este operador faz é alocar memória para o novo objeto e chamar o construtor da classe. O resultado retornado é uma referência para o novo objeto que foi criado.

Exemplo:

```
    Ponto pt; // variável de referência

    pt = new Ponto(10, 20);

```

## Sobrecarga de construtores

Sobrecarregar um método é criar duas ou mais versões do mesmo método. Isso também é possível com construtores. Uma classe pode ter dois ou mais construtores, desde que todos tenham assinaturas diferentes. Neste caso, qual construtor será usado depende dos parâmetros usados na construção do objeto. Note que todos os construtores têm sempre o mesmo nome (o nome da classe).

**Exemplo de classe com dois construtores**

```
public class Pessoa {
    private String nome, sobrenome;

    // Construtor padrão da classe
    public Pessoa() {
        nome = "";
        sobrenome = "";
    }

    // Construtor parametrizado
    public Pessoa(String psNome, String psSobrenome) {
        nome = psNome;
        sobrenome = psSobrenome;
    }

    // Outros métodos da classe...
}

```

**Exemplo de construção com os dois construtores.**

```
Pessoa ps1, ps2;  // duas variáveis de referência

ps1 = new Pessoa();  // usando o construtor padrão
ps2 = new Pessoa("Emerson",21);  // usando o construtor parametrizado

```

**Observações:**

1. Se a classe só precisa do construtor padrão, não é necessário declara-lo. Se só é necessário zerar os atributos, deixe o Java fazer isso. Mas se a classe tiver algum outro construtor, então o Java não irá criar o construtor padrão. O construtor padrão só é criado automaticamente pelo Java se não for definido nenhum construtor para a classe.
2. Por convenção, os construtores são declarados antes de todos os outros métodos, logo depois da declaração dos atributos.
3. **Não declare nenhum tipo de retorno para um construtor, nem mesmo o void.**

## Copy constructor (construtor clone)

É bastante comum que as classes definam um **copy constructor** (também chamado de construtor clone ou de cópia) como opção para a construção de objetos. Um copy constructor serve para construir um objeto copiando os valores dos atributos de outro objeto da mesma classe. Portanto um copy constructor sempre tem como único parâmetro um objeto da mesma classe.

Por exemplo, para a classe Pessoa usada no exemplo acima, o copy constructor seria:

```
public Pessoa(Pessoa ps) {
    nome = ps.nome;
    sobrenome = ps.sobrenome ;
}

```

**Observação**
Neste exemplo específico, o copy constructor poderia aproveitar o código já implementado no construtor parametrizado da classe chamando-o através da referência this, como mostrado abaixo:

```
public Pessoa(Pessoa ps) {
    this(ps.nome, ps.sobrenome);
}

```

**Links recomendados:**

* **Declaração de construtores em java**
* **Construtores - Java (Java com café)**
* **Construtores (Unicamp)**