Vorbește despre clasele imbricate și în ce cazuri…

Clasele înglobate (Nested Classes) în Java sunt clase definite în interiorul altei clase. Ele sunt împărțite în două tipuri: clase statice (Static Nested Classes) și clase interne (Inner Classes).

Clasele înglobate statice

Sunt declarate cu modificatorul static.
Au acces doar la membrii statici ai clasei exterioare (chiar și cei ascunși).
Nu au acces la membrii non-statice ai clasei exterioare.

Pentru a crea o instanță a unei clase înglobate statice, nu este nevoie de o instanță a clasei exterioare:

// Clasa exterioară
class Outer {
    static int outerStaticField;
    int outerInstanceField;

    // Clasă înglobată statică
    static class StaticNested {
        void accessOuter() {
            // Acces la câmpul static al clasei exterioare
            System.out.println(Outer.outerStaticField);
            // Nu are acces la outerInstanceField
            // System.out.println(outerInstanceField); // Eroare de compilare
        }
    }
}

// Utilizarea clasei înglobate statice
class Main {
    public static void main(String[] args) {
        Outer.StaticNested nestedObject = new Outer.StaticNested();
        nestedObject.accessOuter();
    }
}

Clasele interne

Nu sunt declarate cu modificatorul static.
Au acces complet la toți membrii clasei exterioare (statice și non-statice, chiar și cei ascunși).
O instanță a unei clase interne nu poate exista fără o instanță a clasei exterioare.

Pentru a crea o instanță a unei clase interne, este nevoie de o instanță a clasei exterioare:

// Clasa exterioară
class Outer {
    static int outerStaticField;
    int outerInstanceField;

    // Clasă internă
    class Inner {
        void accessOuter() {
            // Acces la câmpul static al clasei exterioare
            System.out.println(Outer.outerStaticField);
            // Acces la câmpul non-static al clasei exterioare
            System.out.println(outerInstanceField);
        }
    }
}

// Utilizarea clasei interne
class Main {
    public static void main(String[] args) {
        Outer outerObject = new Outer();
        Outer.Inner innerObject = outerObject.new Inner();
        innerObject.accessOuter();
    }
}

Clasele interne sunt împărțite în:

Clase interne regulate: Definite direct în corpul clasei exterioare.

Clase locale: Definite în interiorul metodelor, constructorilor sau blocurilor de inițializare. Sunt vizibile doar în interiorul acestor blocuri.

class Outer {
    void display() {
        class LocalInner { // Clasă internă locală
            void message() {
                System.out.println("Clasă internă locală");
            }
        }
        LocalInner obj = new LocalInner();
        obj.message();
    }
}

Clase anonime: Clase fără nume, utilizate pentru crearea unei instanțe a unei clase sau interfețe și pentru furnizarea imediată a implementării lor. Sunt adesea folosite cu ascultători de evenimente.

interface Greeting {
    void sayHello();
}

class Main {
    public static void main(String[] args) {
        Greeting greeting = new Greeting() { // Clasă anonimă
            @Override
            public void sayHello() {
                System.out.println("Salut!");
            }
        };
        greeting.sayHello();
    }
}

Când se aplică clasele înglobate:

Grupare logică: Dacă clasa face parte doar dintr-o altă clasă și are sens să fie grupată împreună. Acest lucru îmbunătățește lizibilitatea și întreținerea codului.
Încapsulare: Clasele înglobate pot avea acces la membrii clasei exterioare, oferind o legătură mai strânsă și posibilitatea de a ascunde detaliile de implementare.
Cod mai clar: Când o clasă mică și simplă este utilizată doar într-un singur loc, încorporarea acesteia poate face codul mai ordonat.
Utilizare eficientă a resurselor: Clasele interne au acces la membrii clasei exterioare fără a fi nevoie să îi transmită explicit, ceea ce poate simplifica codul. Un exemplu este implementarea iteratorilor.
Implementarea interfețelor sau extinderea claselor în context: Clasele anonime sunt adesea folosite pentru a oferi o implementare compactă a interfețelor sau claselor abstracte "din mers".
Ascunderea implementării: Ascunderea unei clase în interiorul altei clase, făcând-o invizibilă din exterior.

Compararea claselor înglobate statice și interne:

Parametru	Clasa înglobată statică	Clasa internă
Modificator `static`	Da	Nu
Acces la membrii clasei exterioare	Doar statice (chiar și private)	Toți membrii (statice și non-statice, private)
Este nevoie de o instanță a clasei exterioare pentru a crea	Nu	Da
Legătura cu instanța clasei exterioare	Nu	Da

Alegerea între o clasă înglobată statică și o clasă internă depinde de necesitatea ca clasa înglobată să aibă acces la membrii non-statice ai clasei exterioare. Dacă da, folosiți o clasă internă. Dacă nu, o clasă înglobată statică este mai potrivită, deoarece nu este legată de o instanță a clasei exterioare și poate fi mai eficientă.

Vorbește despre clasele imbricate și în ce cazuri sunt utilizate.