რა არის შიდა კლასი?

შენახული კლასები (nested classes) არის კლასები, რომლებიც გამოაცხადეს სხვა კლასის შიგნით. ისინი შეიძლება იყოს სტატიკური (static nested classes) და არასტატიკური (inner classes).

სტატიკური შიდა კლასები:

• გამოაცხადეს static მორფით.
• პირდაპირ არ აქვს წვდომა გარეგანი კლასის არასტატიკური წევრებზე (მხოლოდ გარეგანი კლასის ნიმუშის საშუალებით).
• შეიძლება შეიცავდეს როგორც სტატიკურ, ასევე არასტატიკურ წევრებს.
• შექმნილია გარეგანი კლასის ნიმუშის გარეშე.

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

    public static class StaticNested {
        // აქვს წვდომა staticOuterVar-ზე
        public void printStaticValue() {
            System.out.println(staticOuterVar);
        }

        // პირდაპირი წვდომა instanceOuterVar-ზე არაა შესაძლებელი
        // public void printInstanceValue() {
        //     System.out.println(instanceOuterVar); // კომპილაციის შეცდომა
        // }
    }
}

სტატიკური შიდა კლასის გამოყენება:

// მაგალითი სტატიკური შიდა კლასის ნიმუშის შექმნის
Outer.StaticNested nestedObject = new Outer.StaticNested();
nestedObject.printStaticValue(); // გამოიტანს 10

არასტატიკური შიდა კლასები (Inner Classes):

• გამოაცხადეს static მორფის გარეშე.
• აქვს სრული წვდომა გარეგანი კლასის ყველა წევრზე, მათ შორის პრივატულებზე.
• არ შეუძლია შეიცავდეს სტატიკურ წევრებს (გარდა დროებითი კონსტანტების).
• საჭიროებს გარეგანი კლასის ნიმუშის შექმნას.

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

    public class Inner {
        // აქვს წვდომა staticOuterVar და instanceOuterVar-ზე
        public void printValues() {
            System.out.println(staticOuterVar); // ხელმისაწვდომია
            System.out.println(instanceOuterVar); // ხელმისაწვდომია
        }
    }
}

არასტატიკური შიდა კლასის გამოყენება:

// მაგალითი არასტატიკური შიდა კლასის ნიმუშის შექმნის
Outer outerObject = new Outer();
Outer.Inner innerObject = outerObject.new Inner();
innerObject.printValues(); // გამოიტანს 10 და 20

შენახული კლასების გამოყენების უპირატესობები:

1. ლოგიკური ჯგუფირება: კლასები, რომლებიც გამოიყენება მხოლოდ სხვა კლასის მიერ, შეიძლება ლოგიკურად გაერთიანდეს მასში.
2. ინკაფსულაცია: შიდა კლასებს აქვთ წვდომა პრივატულ წევრებზე გარეგან კლასში.
3. კოდის წაკითხვა და შენარჩუნება: კოდი ხდება უფრო წესრიგში.

არასტატიკური შიდა კლასების ტიპები:

• ლოკალური კლასები: გამოაცხადეს მეთოდის შიგნით.
• ანონიმური კლასები: კლასები გარეშე სახელის, ჩვეულებრივ გამოიყენება აბსტრაქტული კლასის, ინტერფეისის ან ბაზის კლასის ნიმუშის შექმნისთვის მეთოდების გადაფარვით.

ლოკალური კლასი:

public class Outer {
    public void myMethod() {
        class LocalClass {
            void display() {
                System.out.println("შიგნით ლოკალური კლასი");
            }
        }
        LocalClass local = new LocalClass();
        local.display();
    }
}

ანონიმური კლასი (ინტერფეისის მაგალითი):

interface Greeting {
    void sayHello();
}

public class Outer {
    public void greet() {
        Greeting anonymousGreeting = new Greeting() {
            @Override
            public void sayHello() {
                System.out.println("გამარჯობა ანონიმურ კლასში!");
            }
        };
        anonymousGreeting.sayHello();
    }
}