O que são construtores e destrutores?

Question

IT Interview Practice · Accepted Answer

Um **construtor** é um método especial que é executado quando um objeto é criado, usado para **inicializar** seu estado em uma condição inicial válida. Um **destrutor** (ou finalizador) é executado quando um objeto é destruído, usado para **limpar** recursos.

## Construção

```java
public class Connection {
    private final String host;
    public Connection(String host) {   // constructor
        if (host == null)              // enforce a valid object from birth
            throw new IllegalArgumentException("host required");
        this.host = host;              // initialize state
    }
}
```

Um bom construtor garante que o objeto **nunca seja observado em um estado inválido**.

## A limpeza diferencia-se por linguagem

```python
class FileWriter:
    def __init__(self, path):
        self.f = open(path, "w")       # acquire resource
    def close(self):
        self.f.close()                 # explicit cleanup
    def __enter__(self): return self
    def __exit__(self, *a): self.close()  # deterministic cleanup

with FileWriter("out.txt") as w:       # closed automatically at block end
    pass
```

| Linguagem | Mecanismo de limpeza |
|---|---|
| C++ | Destrutor `~T()`, executa determinístiamente |
| Java/C# | GC + `finalize`/`Dispose` (não-determinístico; use try-with-resources / `using`) |
| Python | `__del__` (timing não confiável); prefira context managers |

## Armadilha

Em linguagens coletoras de lixo, **nunca confie em finalizadores** para liberar arquivos, sockets ou locks — seu timing é indefinido. Use `close`/`Dispose`/context managers explícitos.

## Por que isso importa

Construtores são sua garantia de que cada objeto começa válido — o único melhor lugar para impor argumentos obrigatórios e invariantes.

A limpeza é importante porque recursos finitos (identificadores de arquivo, conexões) vazam se não forem liberados, e confiar em GC para isso causa esgotamento intermitente e difícil de debugar.

Linguagem	Mecanismo de limpeza
C++	Destrutor `~T()`, executa determinístiamente
Java/C#	GC + `finalize`/`Dispose` (não-determinístico; use try-with-resources / `using`)
Python	`__del__` (timing não confiável); prefira context managers

Construção

A limpeza diferencia-se por linguagem

Armadilha

Por que isso importa

Perguntas relacionadas