Katere vrste gnezdenih razredov obstajajo v Javi?

Question

Accepted Answer

**Gnezdeni razred** je razred, definiran znotraj drugega razreda. Java ima štiri vrste — **statični gnezdeni**, **notranji (ne-statični)**, **lokalni** in **anonimni** — vsaka s pravicami dostopa do zunanjega razreda in različnimi primeri uporabe.

## 1. Statični gnezdeni razred — neodvisen od primerka

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

Statični gnezdeni razred se obnaša kot vrhnji razred, vendar je imenski prostori znotraj zunanjega. **Ne** drži reference na zunanji primerek — uporablja se za razvrščanje pomočnikov (npr. `Builder`, `Node` v podatkovni strukturi).

## 2. Notranji (ne-statični) razred — vezan na primerek

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

Ne-statični **notranji** razred drži implicitno referenco na svoj zunanji primerek, zato lahko dostopa do polj primerka zunanjega objekta. (Opozorilo: ta referenca lahko povzroči **puščanje pomnilnika**, če notranji primerek preživi zunanjega.)

## 3. Lokalni razred — definiran znotraj metode

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

Redko se uporablja; omejen na obseg metode.

## 4. Anonimni razred — enkratna implementacija brez imena

```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"); }
};
```

**Anonimni** razred je enkratna implementacija vmesnika ali razreda, definirana in instancirana hkrati — zgodovinsko pogosta pri obdelovalcih dogodkov in povratnih klicev. Moderna Java te pogosto nadomešča z **lambdami**, kadar je ciljna funkcijska vmesnik:

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

## Zakaj je to pomembno

Gnezdeni razredi so koristen instrument za **logično razvrščanje** razredov, ki se uporabljajo samo v enem kontekstu, kar povečuje zaprtost in berljivost.

Razumevanje vrst — posebej razlika **statični-proti-notranji** (statični = neodvisen, notranji = drži referenco na zunanji primerek) — je pomembno za oblikovanje in izogibanju napakam: implicitna zunanja referenca notranjih razredov lahko povzroči puščanje pomnilnika, in izbira statičnega, kadar ne potrebuješ zunanjega primerka, je čistejša privzeta možnost.

Anonimni razredi so bili klasičen način zagotavljanja vgrajena implementacij (obdelovalci dogodkov, comparatorji), in vedeti, da jih lambde večinoma nadomestijo pri funkcijskih vmesnikih, odraža moderno fluidnost Jave.

Se pojavljajo v celotni standardni knjižnici (npr. `Map.Entry` je gnezdeni vmesnik, graditelji so statični gnezdeni razredi), kar jih naredi praktično, pogosto srečano znanje.