Ce tipuri de clase imbricate există?

Clasele imbricate (Nested Classes) în Java sunt împărțite în două tipuri principale:

1. Clase imbricate statice (Static Nested Classes)

   • Marcate cu modificatorul static.
   • Se comportă ca membri statici obișnuiți ai clasei container.
   • Pot accesa membrii statici ai clasei externe (chiar dacă sunt privați).
   • Nu au acces direct la membrii non-statice ai clasei externe.
   • Sunt create fără o instanță a clasei externe: OuterClass.StaticNestedClass nestedObject = new OuterClass.StaticNestedClass();.

2. Clase interne (Inner Classes)

   Clasele interne nu sunt marcate cu static și sunt legate de o instanță a clasei externe. Ele sunt subdivizate în:

   • Clase membru (Member Inner Classes)

     • Sunt declarate la nivelul membrului clasei container, dar în afara metodelor sale.
     • Au acces la toate membrii clasei externe, inclusiv privați.
     • Necesită o instanță a clasei externe pentru a crea propria instanță: OuterClass outerObject = new OuterClass(); OuterClass.MemberInnerClass innerObject = outerObject.new MemberInnerClass();.

   • Clase locale (Local Classes)

     • Sunt create în interiorul metodelor, constructorilor sau blocurilor de inițializare.
     • Domeniul de vizibilitate este limitat la blocul în care sunt declarate.
     • Nu pot fi declarate cu modificatori de acces (public, private, protected).
     • Pot accesa variabile locale final sau efectiv final ale blocului exterior.
     • Nu pot fi utilizate în afara blocului în care sunt definite.

   • Clase anonime (Anonymous Classes)

     • Practic, sunt clase locale fără nume.
     • Sunt declarate și instantiate în același timp.
     • Sunt utilizate pentru implementarea în timp real a unei clase abstracte sau a unei interfețe.
     • La fel ca și clasele locale, au acces la variabile locale final sau efectiv final ale blocului exterior.

   Exemplu de structură:

class OuterClass {
    private int outerField;
    private static int staticOuterField;

    // Clasă imbricată statică
    static class StaticNestedClass {
        void accessOuter() {
            // Poate accesa membrii statici ai clasei externe
            int value = staticOuterField;
            // Nu poate accesa membrii non-statice ai clasei externe
            // int value2 = outerField; // Eroare de compilare
        }
    }

    // Clasă membru (Clasă internă)
    class MemberInnerClass {
        void accessOuter() {
            // Poate accesa toți membrii clasei externe
            int value1 = outerField;
            int value2 = staticOuterField;
        }
    }

    void methodWithLocalAndAnonymous() {
        final int localVar = 10; // efectiv final

        // Clasă locală
        class LocalClass {
            void accessOuter() {
                // Poate accesa membrii clasei externe și variabilele locale final/effectively final
                int value1 = outerField;
                int value2 = staticOuterField;
                int localValue = localVar;
            }
        }

        LocalClass localObj = new LocalClass();
        localObj.accessOuter();

        // Clasă anonimă (care implementează interfața Runnable)
        Runnable anonymousRunnable = new Runnable() {
            @Override
            public void run() {
                // Poate accesa membrii clasei externe și variabilele locale final/effectively final
                int value1 = outerField;
                int value2 = staticOuterField;
                int localValue = localVar;
                System.out.println("Running with local variable: " + localValue);
            }
        };

        anonymousRunnable.run();
    }
}