Jaké druhy vnořených tříd existují v jazyce Java?

Question

Accepted Answer

**Vnořená třída** je třída definovaná uvnitř jiné třídy. Java má čtyři druhy — **static vnořená**, **inner (non-static)**, **lokální** a **anonymní** — každá s různým přístupem k vnější třídě a různými use cases. ## 1. Static vnořená třída — nezávislá na instanci ```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 ``` Třída `static` vnořená se chová jako top-level třída, ale je namespace-ována uvnitř vnější třídy. **Neobsahuje** referenci na vnější instanci — používá se pro seskupování pomocných tříd (např. `Builder`, `Node` v datové struktuře). ## 2. Inner (non-static) třída — vázaná na instanci ```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 ``` Non-static **inner** třída obsahuje implicitní referenci na svou vnější instanci, takže může přistupovat k polím vnější instance. (Pozor: tato reference může způsobit **memory leaky**, pokud vnitřní instance přežije vnější.) ## 3. Lokální třída — definovaná uvnitř metody ```java void process() { class Helper { // local to this method void run() { ... } } new Helper().run(); } ``` Rzídce používáno; rozsah je omezen na metodu. ## 4. Anonymní třída — jednorázová implementace bez názvu ```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"); } }; ``` **Anonymní** třída je jednorázová implementace interfacu nebo třídy, definovaná a instanciovaná najednou — historicky často používána pro event handlery a callbacky. Moderní Java tyto často nahrazuje **lambdami**, když je cíl funkční interface: ```java button.addActionListener(e -> handleClick()); // ✅ lambda — much cleaner Runnable task = () -> System.out.println("running"); ``` ## Proč je to důležité Vnořené třídy jsou užitečný nástroj pro **logické seskupování** tříd, které se používají jen v jednom kontextu, zvyšují zapouzdření a čitelnost. ">
Pochopení druhů — zejména rozdílu **static vs. inner** (static = nezávislá, inner = obsahuje referenci na vnější instanci) — je důležité jak pro návrh tak pro vyhýbání se chybám: implicitní vnější reference vnitřních tříd mohou způsobit memory leaky, a výběr static v případě, kdy nepotřebujete vnější instanci, je čistší výchozí volba. Anonymní třídy byly klasickým způsobem, jak poskytnout inline implementace (event handlery, comparatory), a vědění, že jsou do značné míry nahrazeny lambdami pro funkční interfacy, odráží moderní znalost jazyka Java. Tyto se vyskytují v celé standardní knihovně (např. `Map.Entry` je vnořený interface, buildery jsou static vnořené třídy), což z nich dělá praktické, často se vyskytující znalosti.