Hva er konstruktører og destruktører?

Question

Accepted Answer

En **konstruktor** er en spesiell metode som kjører når et objekt opprettes, brukt til å **initialisere** tilstanden til en gyldig starttilstand. En **destruktor** (eller finalizer) kjører når et objekt destrueres, brukt til å **rydde opp** ressurser.

## Konstruksjon

```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
    }
}
```

En god konstruktor sikrer at objektet **aldri er observerbart i en ugyldig tilstand**.

## Opprydding varierer etter språk

```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
```

| Språk | Oppryddingsmekanisme |
|---|---|
| C++ | Destruktor `~T()`, kjører deterministisk |
| Java/C# | GC + `finalize`/`Dispose` (ikke-deterministisk; bruk try-with-resources / `using`) |
| Python | `__del__` (upålitelig timing); foretrekk context managers |

## Fallgrube

I garbage-collected språk, **stol aldri på finalizers** for å frigjøre filer, sockets eller låser — deres timing er udefinert. Bruk eksplisitt `close`/`Dispose`/context managers.

## Hvorfor det betyr noe

Konstruktører er din garanti for at hvert objekt starter gyldig — det eneste beste stedet for å håndheve påkrevde argumenter og invarianter.

Opprydding betyr noe fordi endelige ressurser (filhåndtaker, forbindelser) lekker hvis de ikke frigjøres, og å stole på GC for dem forårsaker intermitterende, vanskelig-å-debugge utmattelse.

Språk	Oppryddingsmekanisme
C++	Destruktor `~T()`, kjører deterministisk
Java/C#	GC + `finalize`/`Dispose` (ikke-deterministisk; bruk try-with-resources / `using`)
Python	`__del__` (upålitelig timing); foretrekk context managers