გააზიარეთ შიდა კლასების შესახებ და რომელ შემთხვევებში გამოიყენება.

Java-ში ნესტინგ კლასები (Nested Classes) არის კლასები, რომლებიც განსაზღვრულია სხვა კლასის შიგნით. ისინი იყოფა ორ ტიპად: სტატიკური (Static Nested Classes) და შიდა კლასები (Inner Classes):

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

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

  // გარეგანი კლასი
  class Outer {
      static int outerStaticField;
      int outerInstanceField;
  
      // სტატიკური შიდა კლასი
      static class StaticNested {
          void accessOuter() {
              // წვდომა გარეგანი კლასის სტატიკურ მახასიათებელზე
              System.out.println(Outer.outerStaticField);
              // წვდომა გარეგანი კლასის არა-სტატიკურ მახასიათებელზე შეუძლებელია
              // System.out.println(outerInstanceField); // კომპილაციის შეცდომა
          }
      }
  }
  
  // სტატიკური შიდა კლასის გამოყენება
  class Main {
      public static void main(String[] args) {
          Outer.StaticNested nestedObject = new Outer.StaticNested();
          nestedObject.accessOuter();
      }
  }
  

შიდა კლასები

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

  // გარეგანი კლასი
  class Outer {
      static int outerStaticField;
      int outerInstanceField;
  
      // შიდა კლასი
      class Inner {
          void accessOuter() {
              // წვდომა გარეგანი კლასის სტატიკურ მახასიათებელზე
              System.out.println(Outer.outerStaticField);
              // წვდომა გარეგანი კლასის არა-სტატიკურ მახასიათებელზე
              System.out.println(outerInstanceField);
          }
      }
  }
  
  // შიდა კლასის გამოყენება
  class Main {
      public static void main(String[] args) {
          Outer outerObject = new Outer();
          Outer.Inner innerObject = outerObject.new Inner();
          innerObject.accessOuter();
      }
  }
  

შიდა კლასები იყოფა:

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

  class Outer {
      void display() {
          class LocalInner { // ლოკალური შიდა კლასი
              void message() {
                  System.out.println("ლოკალური შიდა კლასი");
              }
          }
          LocalInner obj = new LocalInner();
          obj.message();
      }
  }
  

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

  interface Greeting {
      void sayHello();
  }
  
  class Main {
      public static void main(String[] args) {
          Greeting greeting = new Greeting() { // ანონიმური შიდა კლასი
              @Override
              public void sayHello() {
                  System.out.println("გამარჯობა!");
              }
          };
          greeting.sayHello();
      }
  }
  

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

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

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

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

შერჩევა სტატიკური ნესტინგ კლასის ან შიდა კლასის შორის დამოკიდებულია იმაზე, საჭიროა თუ არა შიდა კლასს წვდომა არა-სტატიკურ წევრებზე. თუ საჭიროა, გამოიყენეთ შიდა კლასი. თუ არა, სტატიკური ნესტინგ კლასი უფრო შესაფერისია, რადგან ის დაკავშირებული არა-სტატიკურ მაგალითთან და შეიძლება იყოს უფრო ეფექტური.