X'inhi l-ittipati tal-klassijiet nested f'Java?

Question

Accepted Answer

A **nested class** hija klassi definita ġewwa klassi oħra. Java għandha erba' ittipati — **static nested**, **inner (non-static)**, **local**, u **anonymous** — kull waħda b'aċċess differenti għall-klassi li jinkludu u cirkustanzi ta' użu differenti.

## 1. Static nested class — indipendenti minn istanza

```java
public class Outer {
    private static int data = 10;

static class Nested {            // static → no reference to an Outer INSTANCE
        void show() {
            System.out.println(data);  // can access static members of Outer only
        }
    }
}
Outer.Nested n = new Outer.Nested();   // created without an Outer instance
```

A `static` nested class titħabbat bhal klassi top-level iżda hija namespaced ġewwa l-waħda ta' barra. Ma żamnx referenza għal istanza ta' barra — użata għall-grouping ta' helpers (es. a `Builder`, `Node` f'struttura tad-data).

## 2. Inner (non-static) class — marbuta ma' istanza

```java
public class Outer {
    private int value = 5;

class Inner {                     // non-static → has an implicit reference to Outer
        void show() {
            System.out.println(value); // can access Outer's INSTANCE members (even private)
        }
    }
}
Outer outer = new Outer();
Outer.Inner inner = outer.new Inner();   // needs an Outer instance to create
```

A non-static **inner** class żamn referenza implisita għall-istanza li jinkludaha, għalhekk tista' taċċessa l-inqas tal-oġġett ta' barra. (Avviz: ir-referenza din tista' tikkawża **memory leaks** jekk l-istanza inner toqgħod iżjed mil-oġġett ta' barra.)

## 3. Local class — definita ġewwa metodu

```java
void process() {
    class Helper {                    // local to this method
        void run() { ... }
    }
    new Helper().run();
}
```

Raramente użata; scoped għall-metodu.

## 4. Anonymous class — implementazzjoni one-off, mingħajr isem

```java
// implement an interface/abstract class inline, for single use
button.addActionListener(new ActionListener() {
    public void actionPerformed(ActionEvent e) { handleClick(); }
});

Runnable task = new Runnable() {
    public void run() { System.out.println("running"); }
};
```

An **anonymous** class hija implementazzjoni one-shot ta' interface jew klassi, definita u instantjata immedjatament — storikament komuni għal event handlers u callbacks. Modern Java spiss tirplaza dawn mal-**lambdas** meta l-target huwa functional interface:

```java
button.addActionListener(e -> handleClick());   // ✅ lambda — much cleaner
Runnable task = () -> System.out.println("running");
```

## Għaliex imbari

Nested classes huma għodda utli għall-**grouping loġiku** tal-klassijiet li jintużaw biss f'kontests waħdh, li jtikkber l-encapsulation u r-readability.

L-fhim tal-ittipati — speċjalment id-distinzjoni **static-vs-inner** (static = indipendenti, inner = żamn referenza enclosing-instance) — imbari għad-disinn u evitazzjoni ta' bugs: ir-referenza implisita ta' outer tal-inner classes tista' tikkawża memory leaks, u l-għażla tal-static meta m'għandekx bżonn l-istanza ta' barra hija d-default aktar nadif.

Anonymous classes kienu l-mod klassiku biex tipprovdi implementazzjonijiet inline (event handlers, comparators), u l-għarfien li b'mod sostanzjali huma sustitwiti minn lambdas għal functional interfaces jirrifletti modern Java fluency.

Dawk jidher f'tul il-biblioteka standard (es. `Map.Entry` hija nested interface, builders huma static nested classes), li tagħmelhom prattika, għarfien li jiltaqgħu ta' spiss.