ჩაბუდებული კლასები

ჩაბუდებული კლასი არის კლასი რომლის დეკლალირებაც ხდება არსებულ კლასში,  ჩაბუდების რამოდენიმე სახეობა არსებობს, რომლებზეც ამ ბლოგში ვისაუბრებთ.

საბაზისო გამყოფი ზოლი სახეობებს შორის გადის შიდა ჩაბუდებულ კლასზე და სტატიკურ ჩაბუდებულ კლასზე. (Inner Class and Static Nested Class). ამ ორიდან შიდა ჩაბუდებული კლასი იყოფა ცალკე ტიპებად და ესენია, ლოკალური შიდა კლასი და ანონიმური შიდა კლასი. (Local Inner Class and Anonymous Inner Class) რაც საერთო ჯამში გვაძლევს 4 ძირითად კონცეპციას ჩაბუდებისა, რომლებიც განსხვავდებიან ერთმანეთისგან, აქვთ განსხვავებული ქცევის და გამოყენების წესები. ყველა კლას სათითაოდ განვიხილავთ, გავიგებთ როგორ ხდება მათი გამოყენება, რა არის ნებადართული, როგორ ხდება მათი ინსტანცირება და ა.შ ბლოგის ბოლოში მოკლედ ვისაუბრებთ ჩაბუდებულ ინტერფეისებზე.

კლას-ს რომელშიც ხდება ჩაბუდება ქვია OuterClass და კლასი, რომლის ჩაბუდებაც ხდება ქვია InnerClass;

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

ამ მაგალითს არც უნდა გაჩვენებდეთ, private ტოპ კლასის ქონას არ აქვს აზრი რადგან ამ კლას ვერავინ ვერ გამოიყენებს, კლასი თუ ვერ გამოიყენე მისი ქონის არსიც იკარგება, თუმცა:

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

რატო ან სად უნდა გამოვიყენოთ ჩაბუდებული კლასები? ეს კითხვა ჩდება ხოლმე ხშირად დამწყებ პროგრამისტებში: ველოსიპედის გამოგონებას არ დავიწყებ და პირდაპირ მოვახდენ ციტირებას ჯავას ოფიციალური ვებ გვერდიდან:

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

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

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

ყველაზე ხშირად ჩაბუდებული ოპერაციების გამოყენებას JavaFx-ში და არა მარტო JavaFx არამედ ბევრ ჯავა პაკეტში შეხვდებით, რომლებიც ამუშავებენ დიზაინს და ქმნიან პატერნებს.

მაშ ასე, დავიწყოთ ყველა ჩაბუდებული კლასის განხილვა.

·        Inner Class

·        Static Nested Class

·        Local Inner Class

·        Anonymous Inner Class

შიდა კლასი(inner class) - მსგავსად ინსტანციური ცვლადისა და მეთოდისა, ინსტანციური კლასიც ხვდება კლასის ცვლადის ზეგავლენის ქვეშ. ანუ ტოპ კლასის ცვლადით შესაძლებელია ინსტანციურ კლასზე წვდომა, ისევე როგორც ხდება მეთოდებზე და ცვალდებზე წვდომა. საკმაოდ მარტივი პრინციპია, არაფერი განსხვავებული. შიდა კლას აქვს წვდომა ნებისმიერი მოდიფიკატორის მქონე ოპერაციაზე გარე კლასში, პირიქითაც სწორია, გარე კლავს აქვს წვდომა ნებისმიერი მოდიფიკატორის მქონე ინფორმაციაზე შიდა კლასში.  შიდა კლას არ შეუძლია იქონიოს სტატიკური წევრები, ალბათ ხვდებით რატომაც, სტატიკური წევრები კლასის დონის წევრებია, მის დეფინირებას თუ შიდა კლასში მოახდენთ რომელი კლასის წევრი უნდა იქნეს სტატიკური წევრი? შიდა კლასის თუ გარე კლასის? რა თქმა უნდა სტატიკური წევრი მხოლოდ ტოპ ლეველის მქონე კლასის წევრია და მის დეფინირებას თუ მოვახდენთ შიდა კლასში , მაშინ მთლიანად სტატიკური ოპერაცია აზრს კარგავს, თუ გაქვთ ჩემი ბლოგები გადაკითხული ნახავდით რო სტატიკურ წევრზე კლასის სახელით ხდება წვდომა და არა რეფერენციული ცვლადით. ობიეკტის შექმნის დროს,  შიდა კლასის რეფერენცია მთლიანად დამოკიდებულია გარე კლასის რეფერენციაზე და მის წევრებზე გარე კლასის რეფერენციის მეშვეობით ხდება წვდომა, გამომდინარე აქედან ლოგიკურად რო ვიმსჯელოთ ობიეკტის რეფერენციით სტატიკურ წევრზე წვდომა ცოტა არ იყოს არა სწორი პროგრამირება გახლავთ, აქედან დასკვნა შიდა კლას არ აქვს უფლება იქონიოს სტატიკური წევრი. თუმცა ლეგალურია იქონიოთ static final კონსტანტური ცვლადი. მაგალითად თუ შიდა კლასი extends ან implements რომელიმე კლას საიდანაც კონსტანტური ცვლადის აღება სურს კომპილატორი ხელს არ შეუშლის ამის გაკეთებაში, ისევე როგორც საკუთარი დეფინირების დროს. ბევრი რომ არ გაგვიგრძელდეს, ვნახოთ სინტაქსური მაგალითი:

სინტაქსი მარტივია. წარმოდიგინეთ რო ამ კლასის კომპილირება მოვახდინეთ კომანდ პრომპიდან,  მაშინ ვირტუალური მანქანა შექმნის 2 კლას ფაილს ჩვენთვის.  javac Outer.java გაუშვით თქვენ კომანდ პრომპში და ნახავთ რო Outer.class და Outer$Inner.class ფაილები შეიქმნება, ტექნიკურად შიდა კლასი სხვა კლასია ამიტომაც ქმნის კომპილატორი მისთვის ცალკე ფაილს, ეს არ ნიშნავს იმას რომ შიდა კლასზე ინფორმაციას ისევე მივწვდებით როგორც ჩვეულებრივ კლასში, თუ სურვილი გვაქ მსგავსი ოპერაციის შესრულების, მოგვიწევს გარე გკლასის ინსტანცირება და მისი ცვლადით შესაძლებელი გახდება მივწვდეთ შიდა კლას. ნახეთ მაგალითები:

ენკაპსულაციის თვალსაზრისით, პატარა კოდის მონაკვეთით ვაღწევთ მთლიან ენკაპსულაციას.

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

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

ამ ფოტოზე ნაჩვენებია 3 სხვა და სხვა გზა შიდა კლასის ინსტანცირების. რა სხვაობებია მათ შორის?:

   1 თუ სურვილი გაქვთ შექმნათ შიდა კლასის ინსტანცია გარე კლასში შეგიძლიათ მიმართოთ შემდეგ ხერხს.  Outer out = new Outer();
2.   თუ სურვილი გაქვთ გამოიყენოთ შიდა კლასის კოდი გარე კლასში ან რომელიმე სხვა კლასში მაშინ მიმართეთ შემდეგ  2 ვარიანტს. მე-2 ვარიანტი ფოტოზე სადაც ინსტანცირება ხდება გარე კლასის ცვლადის დახმარებით და მესამე ვარიანტი სადაც ინსტანცირება ხდება შიდა კლასის ცვლადის დახმარებით.

სამივე შემთხვევაში ხდება გარე კლასის ინსტანცირება რათა 

მიწვდეთ ინფორმაციას შიდა კლასში, ჩემი აზრით ვარიანტი 

ნომერი 1 უფრო წაკითხვადია დანარჩენ ორთან შედარებით.                       

                                  შიდა კლასი და დაჩრდილვა

თუ გარე კლასში, შიდა კლასში და მეთოდში პარამეტრად გაქვთ 

ერთი და იგივე ტიპის ცვლადი ერთი და იგივე დასახელებით, 

მაშინ დაჩრდილვა ცვლადების ხდება იერარქიულად. დაუშვათ 

გაქვთ მეთოდი რომელსაც აქვს პარამეტრი int number; იგივე 

ტიპის დასახელებით თუ გაქვთ ცვლადი შიდა კლასში, მაშინ 

პარამეტრი ჩრდილავს შიდა კლასის ცვლადს, რაც ავტომატურად 

ჩრდილავს გარე კლასის ცვლადს, ანუ საკვანძო ფიგურა 

დაჩრდილვაში არის მეთოდის პარამეტრი, რომელიც ჩრდილავს 

შიდას დ შიდა ჩრდილავს გარეს. თუ სურვილი გაქვთ მათ მიწვდეთ 

უნდა გაითვალისწინოთ შემდეგი წესი. ნახეთ მაგალითი:

ფოტოზე ხედავთ სამ ცვლადს, რომლებიც არიან ერთი ტიპის 

და დასახელების, კომპილირების დროს რომელი ცვლადი გამოვა 

ეკრანზე? რა თქმა უნდა პარამეტრი, 

რომელიც გამოიტანს კონზოლში 25-ს. თუმცა ჯადოსნური სიტყვა 

this-ს დახმარებით შეგვიძლია სამივე გამოვიტანოთ ეკრანზე, 

ნახეთ მაგალითი:

კომპილირების შემდგომ:

საკმაოდ მარტივი პრინციპებით ხელმძღვანელობს შიდა კლასი,

არაფერი გამორჩეული მას არ გააჩნია, (თუ არ ჩავთვლით 3 სახის ინსტანცირებას) 

ან რაიმე სახის შეზღუდვა, გარდა იმისა რომ არ შეუძლია იქონიოს 

სტატიკური მეთოდები. ყველაფერი დანარჩენი იგივე აქვს რაც ჩვეულებრივ კლას. 

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

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

სანამ ვისაუბრებთ სტატიკური ჩაბუდებული კლასის გამოყენების წესებზე, ნახეთ მაგალლითი:

წესი 1: სტატიკური კლასის ინსტანცირებისთვის არ არის საჭირო გარე კლასის ობიეკტის შექმნა, საერთოდ არ იქნებოდა ობიეკტის შექმნა საჭირო თუ სტატიკურ კლასში მეთოდი სტატიკური იქნებოდა.

წესი 2: სტატიკური კლასი არის კლასის სტატიკური წევრი და მისი გამოყენება შეიძლება ისევე როგორც სტატიკური ცვლადის ან მეთოდის.

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

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

როდის გამოვიყენოთ სტატიკური კლასი? როდესაც ვხედავთ რო კლას “X”-ს ჭირდება ერთი კონკრეტული კლასი, რათა შეასრულოს მისი მოვალეობა, ამისთვის არ არის აუცილებელი ცალკე მდგომი ტოპ ლეველის კლასის შექმნა, ჩვენ შეგვიძლია ჩავაბუდოთ სტატიკურად კლას “X”-ში საჭირო ინფორმაცია და ნებისმიერ ადგილზე გამოვიყენოთ ის, როგორც რესურსი. მაგალითზე უკეთ მიხვდებით რასაც ვგულისხმობ:

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

ლოკალური შიდა კლასი(local inner class) -ლოკალური შიდა კლასი არის კლასი რომელიც დეფინირებულია ბლოკში  ან მეთოდში. მეთოდში დეფინირებას როცა ვამბობ ეს ნიშნავს იმას რომ ლოკალური კლასის დეფინირება შესაძლებელია ისეთ მეთოდებში როგორიც არის for-while loop, if-else statement და ა.შ. ნებისმიერი ოპერაცია, რომელიც სრულდება ფრჩხილებით და იხსნება ბლოკით იღებს ლოკალურ კლას.

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

გამოყენების წესები მაგალითებთან ერთად:

1.   ლოკალურ ცვლადს გააჩნია მხოლოდ ფინალურ ცვლადზე წვდომა მეთოდში ან მხოლოდ ეფეკტურად ფინალურ ცვლადზე. ეფეკტურად ფინალური ცვლადი არის ცვლადი რომლის ინიციალიზაციაც ხდება და შემდგომ არ იცვლება, დაუშვათ სურათზე გვაქ someN ცვლადი რომელიც = 10-ს. მისი ღირებულება რომ არ შეგვეცვალა ლოკალური ცვლადის მეთოდში კომპილირება მოხდებოდა რადგან ცვლადი არის ეფეკტურად ფინალური ლოკალური კლასისთვის.

2.     ლოკალურ კლას არ გააჩნია მოდიფიკატორები. სტატიკური, საჯარი, დამალული, დაცული მოდიფიკატორების ქონა აკრძალულია, მაგრამ მას შეუძლია იყოს ფინალური და აბსტრაკტული. Abstract class LocalClass, final class LocalClass სრულიად ლეგალური ოპერაციებია.

3.      ლოკალურ კლას გააჩნია წვდომა მეთოდის პარამეტრებზე რომელშიც არის დეფინირებული.

4.     ლოკალური კლასის გამოყენება შეუძლებელია მეთოდს გარეთ, რომელშიც მოხდა მისი დეფინირება, ამიტომაც მისი ინსტანცირება ხდება მეთოდშივე.

იგივე ფოტო აღწერით, კომპილირების შემდგომ:

5.     ლოკალურ კლას გააჩნია წვდომა ნებისმიერი ტიპის ცვლადზე მის გარე კლასში:

კომპილირების შემდგომ:

6.დაჩრდილვა ისევე ხდება ლოკალური კლასის შემთხვევაში, როგორც შიდა კლასის დროს ხდება. შიდა ცვლადი ჩრდილავს გარე ცვლადს.

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

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

ანონიმური შიდა კლასი(Anonymous inner class)-ანონიმური შიდა კლასი არის კლასი, რომლის დეკლალირებაც და ინსტანცირებაც ხდება ერთდროულად.  მას პროგრამისტები იყენებენ მაშინ როდესაც სურვილი აქვთ მოახდინონ მხოლოდ ერთხელ ინსტანცირება, მათვის საჭირო კლასის. სინტაქსი ანონიმური კლასის ცოტა რთულია მაგრამ თუ ისწავლით მისი გამოყენების წესებს, საკმაოდ ხშირად გამოიყენებთ, რადგან ძალიან მოსახერხებელი და კომფორტულია. ის ძალიან გავს „წესებით“ ლოკალურ კლას, ერთი დიდი განსხვავებით, ანონიმურ კლას არ აქვს სახელი. ამიტომაც მას ხშირად გამოხატულებას უფრო უწოდებენ ვიდრე კლას.

ანონიმური კლასის გამოყენების წესებს სანამ გავეცნობოდეთ, ნახეთ მარტივი მაგალითი:

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

2. ანონიმური კლასი ახდენს იმპლემენტირებას ინტერფეისის ან extends კლას (ან აბსტრაკტულ კლას), ფოტოზე მოცემული კლასი, გამოიყურება შემდეგნაირად,   static SomeClass$1 extends Anon, მაგრამ ამას ჩვენ ვერ ვხედავთ, SomeClass$1 ადგილას ვირტუალური მანქანა თვითონ ირჩევს კლასის სახელს, რომელიც ხდება ზემდგომი კლასის რეფერენციის ზეგავლენის ქვეშ, ანუ ნებისმიერი ანონიმური კლასი არის გარე კლასის ტიპის, რასაც მივყავართ პოლიმორფიზმამდე. დეტალურად დაბლა ვისაუბრებთ.

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

4. ანონიმურ კლას გააჩნია წვდომა იმ მეთოდის პარამეტრებზე , რომელშიც მოხდა მისი დეფინირება და ინსტანცირება.

5. ანონიმურ კლას გააჩნია წვდომა გარე კლასის ცვლადებზე.

6. მსგავსად შიდა და ჩაბუდებული  კლასისა, ანონიმურ კლასში დეკლალირებული ცვლადი ჩრდილავს სხვა ცვლადებს იგივე დასახელებით.

7. მსგავსად ლოკალური კლასისა, ანონიმურ კლასშიც ვერ იქონიებთ სტატიკურ წევრებს.

8. სტატიკური წევრი, რომლის ქონაც ნებადართულია, არის სტატიკური კონსტანტა.

9. ანონიმურ კლასში შეგიძლიათ მოახდინოთ დეფინირება ლოკალური კლასის, ველების, დამატებითი მეთოდების.

10. ანონიმურ კლას არ გააჩნია კონსტრუკტორი, მარტივი მიზეზის გამო, არ არ აქვს სახელი, შესაბამისად ვერ ექნება კონსტრუკტორი.

ანონიმური კლასის სინტაქსი:

ასე გამოიყურება ნორმალური კლასის სიტაქსი.

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

როდესაც ქმნით ანონიმურ კლას, მისი დეკლალირება და ინსტანცირება ხდება ბლოკში, დააკვრდით პირველ შავ ისარს და მეორე შავ ისარს, ამ შავ ისრებშია ანონიმური კლასი, რომელსაც სახელი არ აქვს და რომლის რეფერენციული ცვლადიც გახლავთ ans. როდესაც ქმნით ანონიმურ კლას საკამრისია კონსტრუკტორის შემდგომ გახსნათ ფრჩხილი, მაოხდინოთ მეთოდების გადაწერა, მოახდინოთ საკუთარი მეთოდების დეფინირება და ფრცხილი რომელიც ხურავს ოპერაციას უნდა დაასრულოთ }; ß ამ ნიშნით. ცოტა უცნაურია ჯავა-ში მსგავსი ფრჩხილის ქონა, მაგრამ როდისმე ჯავასკრიპტზე ან ანგულარზე თუ გიცდიათ წერა , უცხოდ არ მოგეჩვენებათ. ფრჩხილი, რომელიც იხურება წერტილ-მძიმეს ნიშნით დახურავს ანონიმურ კლას და მხოლოდ ამის შემდგომ შეგიძლიათ მისი მეთოდების გამოძახება. დააკვირდით როგორ ხდება მეთოდების გადაწერა კლასში, რადგან ანონიმურ კლას არ გააჩნია საკუთარი სახელი ის არის პოლიმორპიული, ანუ ხედავს მხოლოდ სუპერ კლასის მეთოდებს, გამოძახებაც მეთოდების პოლიმორპიული პრინციპით ხდება, ვიძახებთ იმ მეთოდებს რომლებიც დეფინირებულია სუპერ კლასში, არანაირი ხელის შემშლელი ფაკტორი არ გვაქ რომ მოვახდინოთ საკუთარი მეთოდის დეფინირება, ფოტოზე ეს ნათლად ჩანს, თუმცა მისი გამოძახება შეუძლებელია. ამიტომაც ვიძახებთ სხვა მეთოდში. ერთ-ერთი მინუსი რაც აქვს ანონიმურ კლას , შეუძლებელია DownCasting მოვახდინოთ, რათა მივწვდეთ ჩვენ მიერ დეფინირებულ მეთოდს. პოლიმორფიულ ობიეკტში გვაქ ამის უფლება, გვიწევს კიდეც გამოძახება ჩვენი მეთოდის, მაგრამ ანონიმურ კლასში ამის თეორიული შანსი არ არსებობს, თუმცა არსებობს პრაკტიკული შანსი, მაგრამ ამის ცოდნა არსად არ წაგადგებათ, ამიტომაც არ გაჩვენებთ.

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

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

                                     ანონიმური კლასი როგორც არგუმენტი

სანამ ანონიმურ კლას როგორ არგუმენტს გაგაცნობთ, ერთ პატარა მაგალითს გაჩვენებთ რო აღქმა გაგიადვილდეთ ოპერაციის.

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

დააკვირდით 3 კლასი დაგვჭირდა რო ერთი ინტერფეისის შიგთავსი გამოგვეყენებინა, სამი სხვა და სხვა ფაილი, რომელიც წაგვართმევს უამრავ დროს თუ კლასი დიდია, თუ უამრავი პაკეტი გვაქ და ვმუშაობთ პროეკტზე. როგორ ჩავეტიოთ დროში კოდის წერის დროს? თუ პროგრამისტი ხართ ეს ნომერ პირველი თავსატკივარია თქვენთვის,  ანონიმური კლასი როგორც არგუმენტი ამ შემთხვევაში უდრის უამრავ კლას, უბრალოდ ვახდენთ მის დეფინირებას პირდაპირ, როგორც არგუმენტის. რაც ნიშნავს რო ვახდენთ დეკლალირებას და ინსტანცირებას კლასის არგუმენტის(პარამეტრის) ადგილას. ცოტა უცნაურად ჟღერს ხო? დამიჯერეთ ისევე უცნაურად გამოიყურება როგორც ჟღერს. ნახეთ მაგალითი:

ინტერფეისის დეკლალირება და ინსტანცირება მოვახდინეთ მეთოდის პარამეტრის ადგილას, ანონიმური კლასის როგორ არგუმენტის სინტაქია ({ }); როდესაც ჩვეულებრივი ანონიმური კლასის სინტაქსია {}; კიდევ ერთხელ დააკვირდით ფოტოს. მეთოდის ფრჩხილი იხსნება, იწყება ინსტანცირება, იხსნება ახალი ფრჩხილი, ხდება მეთოდის გადაწერა, იხურება ინსტანციის ფრჩხილი, იხურება მეთოდის ფრჩხილი. საკმაოდ მარტივია. განსაკუთრებული წესები ამ კლას არ გააჩნია, უბრალოდ სინტაქი აქვს განსხვავებული.

                                                    ჩაბუდებული ინტერფეისი

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

1.   თუ ინტერფეისის ჩაბუდებას ვახდენთ ინტერფეისში მაშინ ჩაბუდებული ინტერფეისი არის ავტომატურად public მოდიფიკატორით, თუ მის ჩაბუდებას ვახდენთ კლასში, მოდიფიკატორი არჩევითია.

2. ჩაბუდებული ინტერფეისი არის სტატიკური ავტომატურად.

ნახეთ მაგალითი:

ინტერფეისის კლასში ჩაბუდებაც შეიძლება და კლასის ინტერფეისში ჩაბუდებაც გავრცელებული პრაკტიკა გახლავთ. ანუ შეზღუდვები არ გაქვთ, სინტაქსი ერთი აქვს და მაგალითებს არ გაჩვენებთ.

ამით ჩაბუდებულ კლასებზე საუბარს მოვრჩით. მე დაგემშვიდობებით. კარგად ბრძანდებოდეთ.