Ce sunt clasele imbricate?

Clasele imbricate (nested classes) sunt clase declarate în interiorul altei clase. Ele pot fi statice (static nested classes) sau nesatice (inner classes).

Clase imbricate statice:

• Sunt declarate cu modificatorul static.
• Nu au acces direct la membrii nesatice ai clasei exterioare (doar printr-o instanță a clasei exterioare).
• Pot conține atât membri statici, cât și nesatice.
• Sunt create fără o instanță a clasei exterioare.

public class Outer {
    private static int staticOuterVar = 10;
    private int instanceOuterVar = 20;

    public static class StaticNested {
        // Are acces la staticOuterVar
        public void printStaticValue() {
            System.out.println(staticOuterVar);
        }

        // Nu are acces direct la instanceOuterVar
        // public void printInstanceValue() {
        //     System.out.println(instanceOuterVar); // Eroare de compilare
        // }
    }
}

Utilizarea clasei imbricate statice:

// Exemplu de creare a unei instanțe a clasei imbricate statice
Outer.StaticNested nestedObject = new Outer.StaticNested();
nestedObject.printStaticValue(); // Va afișa 10

Clase interne (Inner Classes):

• Nu sunt declarate cu static.
• Au acces complet la toți membrii clasei exterioare, inclusiv cei privați.
• Nu pot conține membri statici (cu excepția constantelor de timp de compilare).
• Necesită o instanță a clasei exterioare pentru a fi create.

public class Outer {
    private static int staticOuterVar = 10;
    private int instanceOuterVar = 20;

    public class Inner {
        // Are acces la staticOuterVar și instanceOuterVar
        public void printValues() {
            System.out.println(staticOuterVar); // Disponibil
            System.out.println(instanceOuterVar); // Disponibil
        }
    }
}

Utilizarea clasei interne nesatice:

// Exemplu de creare a unei instanțe a clasei interne nesatice
Outer outerObject = new Outer();
Outer.Inner innerObject = outerObject.new Inner();
innerObject.printValues(); // Va afișa 10 și 20

Avantajele utilizării claselor imbricate:

1. Grupare logică: Clasele folosite doar de o altă clasă pot fi grupate logic în interiorul acesteia.
2. Încapsulare: Clasele imbricate au acces la membrii privați ai clasei exterioare.
3. Citibilitate și întreținere: Codul devine mai ordonat.

Tipuri de clase interne nesatice:

• Clase locale: Declarate în interiorul unei metode.
• Clase anonime: Clase fără nume explicit, folosite de obicei pentru a crea instanțe ale unei clase abstracte, interfețe sau clase de bază cu metode suprascrise.

Clasă locală:

public class Outer {
    public void myMethod() {
        class LocalClass {
            void display() {
                System.out.println("În interiorul clasei locale");
            }
        }
        LocalClass local = new LocalClass();
        local.display();
    }
}

Clasă anonimă (exemplu cu interfață):

interface Greeting {
    void sayHello();
}

public class Outer {
    public void greet() {
        Greeting anonymousGreeting = new Greeting() {
            @Override
            public void sayHello() {
                System.out.println("Salut din clasa anonimă!");
            }
        };
        anonymousGreeting.sayHello();
    }
}