X'inhu l-konstruttori u d-destruttori?

Question

Accepted Answer

**Konstruttore** huwa metodu speċjali li jitħarreġ meta oġġett jinħoloq, użat biex **jinittalizza** l-istat tiegħu f'kundizzjoni ta' bidu valida. **Destruttore** (jew finalizer) jitħarreġ meta oġġett jinqata', użat biex **naddaf** riżorsi.

## Kostruzzjoni

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

Konstruttore tajjeb jiggarantixxi li l-oġġett **qatt ma jkun osservabbli f'stat invalidu**.

## In-naddaf jiddifferixxi skond il-lingwa

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

| Lingwa | Mekkaniżmu tan-naddaf |
|---|---|
| C++ | Destruttore `~T()`, jitħarreġ b'mod deterministiku |
| Java/C# | GC + `finalize`/`Dispose` (mhux deterministiku; uża try-with-resources / `using`) |
| Python | `__del__` (ħin li ma jkunx affidabbli); preferibilment context manager |

## Inqabba'

F'lingwi b'garbage collection, **qatt ma tiddependu fuq finalizer** biex taħħalli file, socket, jew lock — il-ħin tiegħu huwa indefinitu. Uża `close`/`Dispose`/context manager espliċiti.

## Għaliex ikun importanti

Konstruttori huma garantija li kull oġġett jibda validu — il-post aħjar biex tinforzaargumenti meħtieġa u invarianti.

In-naddaf huwa importanti għaliex ir-riżorsi finiti (handles ta' file, konnessjonijiet) jikkubhdu jekk ma jinħallux, u d-dipendenza fuq GC għalihom jikkawża exhawstjoni intermittenti u diffiċli biex i-debug.

Lingwa	Mekkaniżmu tan-naddaf
C++	Destruttore `~T()`, jitħarreġ b'mod deterministiku
Java/C#	GC + `finalize`/`Dispose` (mhux deterministiku; uża try-with-resources / `using`)
Python	`__del__` (ħin li ma jkunx affidabbli); preferibilment context manager