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

• წვდომის მოდიფიკატორები;
• კლასი, მეთოდი, ცვლადი და ძაფების მოდიფიკატორები, რომლებიც გამოიყენება არაწვდომის მიზნებისთვის.

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

საჯარო კლასი className ( // ... ) private boolean myFlag; სტატიკური საბოლოო ორმაგი კვირა = 9.5; დაცული სტატიკური საბოლოო int BOXWIDTH = 42; საჯარო სტატიკური void main (სტრიქონის არგუმენტები) ( // მეთოდის სხეული )

წვდომა მოდიფიკატორებზე

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

• ჩანს პაკეტში (ეს არის ნაგულისხმევი და მოდიფიკატორი არ არის საჭირო).
• ხილული მხოლოდ კლასისთვის (პირადი).
• ხილული ყველასთვის (საჯარო).
• ხილულია პაკეტისთვის და ყველა ქვეკლასისთვის (დაცული).

წვდომის ნაგულისხმევი მოდიფიკატორი - საკვანძო სიტყვა არ არის

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

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

მაგალითი

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

სიმებიანი ვერსია = "1.5.1"; ლოგიკური processOrder() ( დაბრუნება true; )

პირადი წვდომის მოდიფიკატორი

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

პირადი წვდომის მოდიფიკატორი არის ყველაზე შემზღუდავი წვდომის დონე. კლასი და ინტერფეისები არ შეიძლება იყოს პირადი.

Private გამოცხადებულ ცვლადებზე წვდომა შესაძლებელია კლასის გარეთ, თუ საჯარო მეთოდები, რომლებიც მათ იღებენ, არის კლასში (იხილეთ მაგალითი და ახსნა ქვემოთ).

Java-ში პირადი მოდიფიკატორის გამოყენება მონაცემების დამალვის მთავარი გზაა.

მაგალითი

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

საჯარო კლასის Logger ( კერძო სტრიქონის ფორმატი; საჯარო სტრიქონი getFormat() ( return this.format; ) public void setFormat (სტრიქონის ფორმატი) ( this.format = format; ) )

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

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

საჯარო წვდომის მოდიფიკატორი

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

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

კლასის მემკვიდრეობის წყალობით, ჯავაში, კლასის ყველა საჯარო მეთოდი და ცვლადი მემკვიდრეობით მიიღება მისი ქვეკლასებით.

მაგალითი

შემდეგი ფუნქცია იყენებს საჯარო წვდომის კონტროლს:

საჯარო სტატიკური void main (სტრიქონის არგუმენტები) ( // ... )

მეთოდი მთავარი ()უნდა იყოს საჯარო. წინააღმდეგ შემთხვევაში, კლასის გასაშვებად მისი გამოძახება შეუძლებელია Java თარჯიმნის გამოყენებით.

წვდომის მოდიფიკატორი დაცულია

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

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

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

მაგალითი

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

კლასი AudioPlayer ( დაცული ლოგიკური openSpeaker(Speaker sp) ( // განხორციელების დეტალები ) ) class StreamingAudioPlayer ( ლოგიკური openSpeaker(Speaker sp) ( // განხორციელების დეტალები ) )

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

წვდომის კონტროლი და მემკვიდრეობის წესები

შემდეგი წესები Java-ში ვრცელდება მემკვიდრეობით მეთოდებზე:

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

კლასი, მეთოდი, ცვლადი და ძაფების მოდიფიკატორები, რომლებიც გამოიყენება არაწვდომის მიზნებისთვის

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

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

მოდიფიკატორი სტატიკური

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

სტატიკური ცვლადები

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

სტატიკური ცვლადები ასევე ცნობილია როგორც კლასის ცვლადები. ჯავაში ადგილობრივი ცვლადები არ შეიძლება გამოცხადდეს სტატიკური.

სტატიკური მეთოდები

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

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

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

მაგალითი

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

საჯარო კლასის InstanceCounter ( private static int numInstance = 0; დაცული static int getCount() ( return numInstance; ) private static void addInstance() ( numInstances++; ) InstanceCounter() ( InstanceCounter.addInstance(); ) საჯარო სტატიკური არგუმენტი main ) ( System.out.println("დაწყებული " + InstanceCounter.getCount() + "მაგალითიდან"); for (int i = 0; i

მიიღება შემდეგი შედეგი:

0-დან დაწყებული 500 ინსტანცია შეიქმნა

საბოლოო მოდიფიკატორი

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

საბოლოო ცვლადები

საბოლოო ცვლადის ინიციალიზაცია შესაძლებელია მხოლოდ ერთხელ. საბოლოო სახით გამოცხადებულ საცნობარო ცვლადს ვერასოდეს მიენიჭება სხვა ობიექტის აღნიშვნა.

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

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

მაგალითი

საჯარო კლასის ტესტი( საბოლოო int მნიშვნელობა = 10; // ქვემოთ მოცემულია მუდმივი დეკლარაციების მაგალითები: საჯარო სტატიკური საბოლოო int BOXWIDTH = 6; სტატიკური საბოლოო სტრიქონი TITLE = "Manager"; public void changeValue(){ value = 12; //будет получена ошибка } } !}

საბოლოო მეთოდები

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

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

მაგალითი

მეთოდის დეკლარაცია, რომელიც იყენებს საბოლოო მოდიფიკატორს კლასის დეკლარაციაში, ნაჩვენებია შემდეგ მაგალითში:

საჯარო კლასის ტესტი( საჯარო საბოლოო void changeName())( // მეთოდის სხეული ) )

საბოლოო კლასი

Java-ში საბოლოო გამოცხადებული კლასის გამოყენების მთავარი მიზანია კლასის ქვეკლასად ყოფნის თავიდან აცილება. თუ კლასი მონიშნულია როგორც საბოლოო, მაშინ არცერთ კლასს არ შეუძლია მიიღოს რაიმე ფუნქცია საბოლოო კლასიდან.

მაგალითი

საჯარო დასკვნითი კლასის ტესტი (// კლასის ორგანო)

აბსტრაქტული მოდიფიკატორი

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

კლასის აბსტრაქტი

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

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

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

მაგალითი

აბსტრაქტული კლასი Caravan( კერძო ორმაგი ფასი; კერძო სტრიქონის მოდელი; კერძო სტრიქონის წელი; საჯარო აბსტრაქტული void goFast(); //აბსტრაქტული მეთოდი საჯარო აბსტრაქტული void changeColor(); )

აბსტრაქტული მეთოდი

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

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

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

აბსტრაქტული მეთოდი მთავრდება მძიმით. მაგალითი: საჯარო აბსტრაქტული ნიმუში();

მაგალითი

საჯარო აბსტრაქტული კლასი SuperClass( abstract void m(); //abstract მეთოდი ) class SubClass extends SuperClass( // ახორციელებს აბსტრაქტულ მეთოდს void m())( ......... ) )

სინქრონიზებული მოდიფიკატორი

სინქრონიზებული მოდიფიკატორი

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

მაგალითი

საჯარო სინქრონიზებული void showDetails() ( ........ )

გარდამავალი მოდიფიკატორი

მაგალითად, ცვლადი, რომელიც მონიშნულია გარდამავალი, ეუბნება Java ვირტუალურ მანქანას (JVM) გამოტოვოს კონკრეტული ცვლადი, როდესაც მას შეიცავს ობიექტის სერიულიზაციას.

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

მაგალითი

საჯარო გარდამავალი int ლიმიტი = 55; // არ შეინახება public int b; // შეინახება

არასტაბილური მოდიფიკატორი

არასტაბილური მოდიფიკატორი- გამოიყენება ჯავაში ძაფებისთვის.

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

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

მაგალითი

საჯარო კლასი MyRunnable ახორციელებს Runnable( private volatile boolean active; public void run())(active = true; while (active)( // line 1 // ზოგიერთი კოდი აქ) ) public void stop())(active = false; / / ხაზი 2 ))

როგორც წესი, run() გამოიძახება ერთ თემაში (როდესაც პირველად იწყებ Runnable-ის გამოყენებას Java-ში) და stop() იძახება სხვა thread-ზე. თუ ხაზი 1 იყენებს ქეშირებულ აქტიურ მნიშვნელობას, მაშინ მარყუჟი ვერ შეჩერდება მანამ, სანამ არ დააყენებთ აქტივობას false-ზე მე-2 ხაზზე.

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

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

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

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

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

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

კლასებზე წვდომა

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

კლასის წევრებზე წვდომა

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

საჯარო მოდიფიკატორი

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

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

მოდიფიკატორი დაცულია

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

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

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

დაცული .

მოდიფიკატორი პირადი

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

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

ზედა დონის კლასები და ინტერფეისები არ შეიძლება გამოცხადდეს როგორც კერძო .

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

შევქმენი კლასები Mod02.java, DefMod.java, ProMod.java და PrvMod.java, რომლებიც ეკუთვნის პაკეტს pro.java.pkg002, ასევე კლასი PubMod.java, რომელიც ეკუთვნის პაკეტს pro.java.pkg003. ქვემოთ მოცემულია ამ კლასების მხოლოდ ეკრანის ანაბეჭდები და პროგრამის შედეგი:

5

მე ვნახე რამდენიმე დისკუსია StackOverflow-ზე ამ თემაზე, მაგრამ ვერაფერს ვხედავ, რაც დამეხმარა შემდეგი პუნქტის გაგებაში:

მე მოვდივარ C++ ფონიდან და ვ ბოლო დროსდავიწყე ჯავის სწავლა. C++-ში, როცა დაცული, გამოიყენება მხოლოდ ქვეკლასი, რომელსაც შეუძლია წევრზე წვდომა (ანალოგური ველი Java-ში).

ასევე არის "მეგობრის" კლასები C++-ში, რომლებსაც შეუძლიათ ჰქონდეთ წვდომა კერძო/დაცულ კლასის კამერებზე, რომლებიც აძლევენ "მეგობრობას". ეს ცოტათი ჰგავს "პაკეტის" ველის მოდიფიკატორს Java-ში (ველის ნაგულისხმევი მოდიფიკატორი), გარდა იმისა, რომ C++-ში მეგობრობა აძლევს წვდომას ყველა პირად წევრზე, მაგრამ Java-ში, იმავე პაკეტის კლასებიდან წვდომა სპეციფიკურია კლასის ველისთვის. .

რასაც ვერ ვხვდები, თუ ვივარაუდოთ, რომ მხოლოდ ქვეკლასებზე წვდომის მინიჭება მსურს, არის ის, რისი გაკეთებაც შემიძლია C++-ში დაცული წევრების გამოცხადებით კლასში, რომელიც არ "აძლევს" მეგობრობას.

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

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

კიდევ ერთი რამ, რაც არ მესმის, ჯავაში, თუ ვივარაუდებთ, რომ A კლასში ორი ველი მაქვს: b, c. მე მინდა მივცეთ B-ს წვდომა b-ზე, მაგრამ არა, და მინდა მივცეთ C-ს წვდომა c-ზე, მაგრამ არა b-ზე. და "მსოფლიოს" მინდა b, c დამალვა. როგორ შეიძლება ამის გაკეთება? მე ვხვდები, რომ B, C უნდა იყოს იმავე პაკეტში, როგორც A. ოღონდ b, c-ის გამოცხადებით პაკეტიმოდიფიკატორით I ნებას რთავს B, C წვდომას როგორც b, ასევე k. ჯავაში არის ამის საშუალება?

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

11

უკეთესი კითხვა, თუ ნაკლებად სასარგებლო იქნება თქვენთვის, იქნება უფრო ვიწრო და კონკრეტული. ზოგადი კითხვა "ყველაფერი Java-სა და C++-ში კონფიდენციალურობის შესახებ და როგორ განსხვავდებიან ისინი" ცოტა მეტისმეტად ფართოა. შეგიძლიათ უფრო კონკრეტული შეკითხვა დაგისვათ უფრო კონკრეტულ პრობლემასთან დაკავშირებით? - იაკ 04 მარ 15 2015-03-04 16:38:58

• 4 პასუხი

დახარისხება:

აქტივობა

2

C++-ში, როდესაც დაცვა გამოიყენება, მხოლოდ ქვეკლასს შეუძლია წვდომა ელემენტზე (ანალოგური ველი Java-ში).

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

C++-ში ასევე არის „მეგობრის“ კლასები, რომლებსაც შეუძლიათ წვდომა ჰქონდეთ კლასის პირად/დაცულ წევრებთან, რაც იძლევა „მეგობრობას“. ეს ცოტათი ჰგავს "პაკეტის" ველის მოდიფიკატორს Java-ში (ველის ნაგულისხმევი მოდიფიკატორი), გარდა იმისა, რომ C++-ში მეგობრობა აძლევს წვდომას ყველა კერძო წევრზე, მაგრამ Java-ში წვდომა იმავე პაკეტის კლასებიდან სპეციფიკურია კლასისთვის. ველი.

არსებობს არა მხოლოდ მეგობრების კლასები, არამედ ფუნქციებიც.

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

ის, რაც მე ვერ გავარკვიე, თუ ვივარაუდებ, რომ მხოლოდ ქვეკლასებზე წვდომის მინიჭება მსურს, არის ის, რისი გაკეთებაც შემიძლია C++-ში, გამოვაცხადო მომხმარებლები დაცულები კლასში, რომელიც არ "აძლევს" მეგობრობას.

მაგრამ ჯავაში არ ვიცი როგორ გავაკეთო ეს,

პასუხი: არ შეგიძლია.

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

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

ტექნიკურად კი. მაგრამ ეს სხვა პრობლემებს ქმნის. თქვენი კლასი ვეღარ შეძლებს წვდომას მისი წინა პაკეტის პირადი პაკეტის ნაწილებზე. ვთქვათ, თქვენი BaseClass იყო com.example.one-ში. თქვენ გადაიტანთ მას com.example.two-ზე. ახლა ის ვეღარ შეძლებს სხვა კერძო კლასის პაკეტებზე წვდომას com.example.one.

ეს მართლაც მამოძრავებელი ფაქტორია პაკეტების დაჯგუფებაში?

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

კიდევ ერთი რამ, რაც არ მესმის, არის ჯავაში, თუ ვივარაუდებთ, რომ მე მაქვს ორი ველი A კლასში: b, c. მე მინდა მივცეთ B-ს წვდომა b-ზე, მაგრამ არა, და მინდა მივცეთ C-ს წვდომა c-ზე, მაგრამ არა b-ზე. და "მსოფლიოში" მინდა b, c დამალვა. როგორ შეიძლება ამის გაკეთება?

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

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

1

საკმაოდ ბევრი კითხვაა ერთად...

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

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

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

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

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

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

თქვენი A, B და C კლასებისთვის, მაგალითად, ატრიბუტებით:

მე ვფიქრობ, რომ B, C უნდა იყოს ორივე ერთ პაკეტში, A. a დეკლარირებადი b, შეფუთვის მოდიფიკატორთან ერთად მივცე B, C წვდომას როგორც b, ასევე k, არის თუ არა ამის გაკეთება Java-ში?

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

0

მოკლე პასუხი: არ არსებობს ამის გაკეთება.

თუ თქვენ გაწუხებთ კლიენტების შეჭრა, რომლებიც შეაქვთ კლასის პაკეტში არაავტორიზებული წვდომის მისაღებად, შეგიძლიათ გადაიტანოთ მგრძნობიარე კოდი ცალკე პაკეტში და დალუქული გახადოთ პაკეტი ქილაში, რომელსაც მიაწვდით: http://docs.oracle. com/javase/tutorial /deployment/jar/sealman.html

1

ირიბად ვარაუდობენ, რომ პაკეტის ყველა კლასი „იცნობს“ ერთმანეთს (რადგან ისინი დაწერილია ერთი და იგივე პირის/კომპანიის/ორგანიზაციის მიერ). ასე რომ, მათ ან არ აქვთ წვდომა დაცულ ველებზე, ან თუ აქვთ, იციან როგორ გააკეთონ ეს სწორად.

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

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

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

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

ასე რომ, საბოლოო ჯამში სასურველი გზა გასაკეთებლად რასაც ამბობთ Java-ში არის მათი ჩასმა იმავე პაკეტში, ან ჩაწეროთ B და C, როგორც A-ს შიდა კლასები, რათა მათ შეეძლოთ პირდაპირ წვდომა A-ს კერძო წევრებზე და გამოავლინონ ისინი მათგან მიღებული კლასებისთვის. .

საჯარო კლასი A ( საჯარო სტატიკური აბსტრაქტული კლასი B ( დაცული Whatever getWhatever (A a) ( დაბრუნება a.b; ) დაცული void setWhatever (A a, რა მნიშვნელობა) (a.b = მნიშვნელობა; ) ) საჯარო სტატიკური აბსტრაქტული კლასი C ( დაცული Whatever getWhatever (A a) (დაბრუნება a.c; ) დაცული void setWhatever (A a, Whatever მნიშვნელობა) (a.c = მნიშვნელობა; ) ) private Whatever b)

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

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

• კერძოკლასის წევრები ხელმისაწვდომია მხოლოდ კლასში
• პაკეტი-პირადი ან ნაგულისხმევი (ნაგულისხმევი)კლასის წევრები ჩანს პაკეტის შიგნით
• დაცულიკლასის წევრები ხელმისაწვდომია პაკეტის შიგნით და შთამომავალ კლასებში
• საჯაროკლასის წევრები ყველასთვის ხელმისაწვდომია

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

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

მოდიფიკატორები სტატიკური, აბსტრაქტული და საბოლოო

სტატიკური

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

აბსტრაქტი

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

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

საბოლოო

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

კონსტრუქტორიარ შეიძლება იყოს სტატიკური, აბსტრაქტული ან საბოლოო

მოდიფიკატორები მკაცრი fp, გარდამავალი, არასტაბილური, სინქრონიზებული, მშობლიური

Strictfp

• ვრცელდება მეთოდებსა და კლასებზე
• უზრუნველყოფს ოპერაციებს float და ორმაგ რიცხვებზე (მცურავი წერტილი) IEEE 754 სტანდარტის მიხედვით

გარდამავალი

• ვრცელდება მხოლოდ კლასის დონის ცვლადებზე (ლოკალური ცვლადები არ შეიძლება გამოცხადდეს გარდამავალი)
• გარდამავალი ცვლადები არ შეიძლება იყოს საბოლოო ან სტატიკური.
• გარდამავალი ცვლადები არ არის სერიული

არასტაბილური

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

სინქრონიზებული

• ვრცელდება მხოლოდ მეთოდებზე ან მეთოდების ნაწილებზე
• გამოიყენება კოდის მნიშვნელოვან ნაწილებზე წვდომის გასაკონტროლებლად მრავალ ხრახნიან პროგრამებში

მშობლიური

• გამოიყენება მხოლოდ მეთოდებისთვის
• მიუთითებს, რომ მეთოდი დაწერილია სხვა პროგრამირების ენაზე
• Java-ში კლასები იყენებენ ბევრ მშობლიურ მეთოდს მუშაობის გასაუმჯობესებლად და აპარატურაზე წვდომის გასაუმჯობესებლად
• თქვენ შეგიძლიათ გადასცეთ/დააბრუნოთ Java ობიექტები მშობლიური მეთოდებიდან
• მეთოდის ხელმოწერა უნდა დასრულდეს „;“-ით, ხვეული ბრეკეტები გამოიწვევს კომპილაციის შეცდომას

ფუნქციები ინტერფეისებში

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

მოდით შევკრიბოთ ყველა მოდიფიკატორი:

	კლასი	შიდა კლასი	ცვლადი	მეთოდი	კონსტრუქტორი	ლოგიკური ბლოკი
საჯარო	დიახ	დიახ	დიახ	დიახ	დიახ	არა
დაცული	არა	დიახ (გარდა ადგილობრივი და ანონიმური კლასებისა)	დიახ	დიახ	დიახ	არა
ნაგულისხმევი	დიახ	დიახ		დიახ	დიახ	დიახ
კერძო	არა	დიახ (გარდა ადგილობრივი და ანონიმური კლასებისა)	დიახ	დიახ	დიახ	არა
საბოლოო	დიახ		დიახ (და ადგილობრივი ცვლადისთვის)	დიახ	არა	არა
აბსტრაქტული	დიახ	დიახ (ანონიმური კლასების გარდა)	არა	დიახ	არა	არა
სტატიკური	არა	დიახ (გარდა ადგილობრივი და ანონიმური კლასებისა)	დიახ	დიახ	არა	დიახ
მშობლიური	არა	არა	არა	დიახ	არა	არა
გარდამავალი	არა	არა	დიახ	არა	არა	არა
სინქრონიზებული	არა	არა	არა	დიახ	არა	დიახ (მხოლოდ როგორც მეთოდის ნაწილი)
არასტაბილური	არა	არა	დიახ	არა	არა	არა
მკაცრი fp	დიახ	დიახ	არა	დიახ	არა	არა

მოდიფიკატორის კლასი
Modifier კლასი დაშიფვრავს ყველა მოდიფიკატორს,
გამოიყენება ტიპის დეკლარაციებში, ფორმაში
მუდმივები:
ABSTRACT, FINAL, INTERFACE, NATIV,
პირადი, დაცული, საჯარო, სტატიკური,
მკაცრი, სინქრონიზებული, გარდამავალი,
არასტაბილური.
თითოეულ მუდმივზე პასუხის გაცემა ხდება ფორმის მოთხოვნის მეთოდით
isMod(int მოდიფიკატორი) (აქ Mod არის ერთ-ერთი ზემოთ ჩამოთვლილი
მოცემული სახელები, მაგალითად, არის საჯარო),
რომელიც აბრუნებს true თუ მოდიფიკატორი
mod წარმოდგენილია ტიპის დეკლარაციაში.

მოდით შევხედოთ მაგალითს. დაე იყოს
საველე დეკლარაცია
საჯარო სტატიკური საბოლოო int s=10;
შემდეგ მეთოდით დაბრუნებული მნიშვნელობა
მიიღეთ შესაბამისი ობიექტის მოდიფიკატორები
კლასის სფერო ასე გამოიყურება
მოდიფიკატორი.საჯარო | მოდიფიკატორი.STATIC |
მოდიფიკატორი.ფინალი
ჩნდება მკაცრი fp მოდიფიკატორი
მუდმივი STRICT.
შეკითხვის მეთოდების გამოყენება შესაძლებელია
შემდეგი ფორმა

Modifier.isPrivate(field.getModifiers());
ეს უდრის შემდეგ მდგომარეობას
(field.getModifiers()&Modifier.PRIVATE)!=0
საკლასო სფერო
Field კლასი ახორციელებს მეთოდებს
საშუალებას გაძლევთ მოითხოვოთ ინფორმაცია
ველის ტიპი, ასევე წაიკითხეთ და დააყენეთ იგი
მნიშვნელობა.
მოდით შევხედოთ Field კლასის რამდენიმე მეთოდს
1. getType() – აბრუნებს კლასის ობიექტს
კლასი, რომელიც შეესაბამება მიმდინარე ველის ტიპს.
მაგალითად, int ტიპის ველისთვის ვიღებთ
საერთაშორისო კლასი.

2. დააყენეთ და მიიღეთ მეთოდები - საშუალებას გაძლევთ წაიკითხოთ
ველის მიმდინარე მნიშვნელობა, ასევე დააყენეთ ახალი.
მოდით შევხედოთ მაგალითს:
საჯარო სტატიკური void printField(ობიექტი o,
სიმებიანი სახელი) ისვრის
NoSuchFieldException,
არალეგალური წვდომის გამონაკლისი (
ველის ველი = o.getClass().getField(სახელი);
მოკლე მნიშვნელობა = (მოკლე) ველი.get(o);
System.out.println(მნიშვნელობა);
}
იმათ. get მეთოდი აბრუნებს მნიშვნელობას, რომლითაც
ეხება შესაბამის ველს ან ობიექტს
ჭურვის კლასი.
ნაკრების მეთოდის გამოყენების მაგალითი ასე გამოიყურება:

საჯარო სტატიკური void setField (ობიექტი o, სტრიქონის სახელი,
მოკლე ნვ) ისვრის
NoSuchFieldException,
არალეგალური წვდომის გამონაკლისი (
ველის ველი = o.getClass().getField(სახელი) ;
field.set(o,new Short(nv));
}
nv-ის შესანახად მოცემული ობიექტის ველში
შეფუთვის კლასები უნდა იყოს გამოყენებული.
ასევე არსებობს ფორმის მეთოდები
getPrimitiveType (მაგ. getInt) და
setPrimitiveType. ეს მეთოდები შეიძლება იყოს
გამოიყენეთ კლასში ველების შესაცვლელად,
პრიმიტიული ტიპის მქონე. მაგალითად,
field.setShort(o,nv);

მეთოდის კლასი
მეთოდის კლასი ნიშნავს - საშუალებას გაძლევთ მიიღოთ
სრული ინფორმაცია იმის შესახებ
გარკვეული კლასის მეთოდების დეკლარაციები,
და საჭიროების შემთხვევაში გამოიძახეთ ეს მეთოდები
მოცემული ობიექტების კონტექსტში.
მოდით გადავხედოთ Method კლასის მეთოდებს.
1. საჯარო კლასი getReturnType() - აბრუნებს
კლასის ობიექტი, რომელიც შეესაბამება ტიპს
მიმდინარე მეთოდით დაბრუნებული მნიშვნელობა.
თუ დაბრუნების ნაცვლად ჩაწერეთ
მეთოდის დეკლარაცია განსაზღვრავს სერვისს
სიტყვა void, განსახილველი მეთოდი დაბრუნდება
ბათილად.კლასის ობიექტი.

2. public Class getParameterTypes() - აბრუნებს

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

4. საჯარო ობიექტის გამოძახება (Object onThis, Object args)
აგდებს IllegalAccessException,
უკანონო არგუმენტი გამონაკლისი,
InvocationTargetException
იძახებს მიმდინარე ობიექტის მიერ განსაზღვრულ მეთოდს
მეთოდი, ამოცანის onThis ობიექტის კონტექსტში
args მასივის მიერ გადაცემული არგუმენტების მნიშვნელობები.
არასტატიკური მეთოდებისთვის, განხორციელების არჩევა
ხორციელდება რეალური ტიპის მიხედვით
ობიექტი, რომელიც განსაზღვრულია onThis პარამეტრით. ამისთვის
სტატიკური მეთოდები onThis არ არის მიღებული
ყურადღება და შეიძლება იყოს ნული.
არგსის მასივის სიგრძე უნდა შეესაბამებოდეს რიცხვს
პარამეტრების მეთოდის დეკლარაციაში და მასივის ელემენტების ობიექტის ტიპებმა უნდა დაუშვან მინიჭება
მეთოდის პარამეტრების შესაბამისი ტიპები - ინ
წინააღმდეგ შემთხვევაში გამონაკლისი იქნება დაშვებული
IIlegalArgumentგამონაკლისი.

10.

თუ, როგორც განსაზღვრული ობიექტის ნაწილი
ამ პარამეტრზე, არ არის ტიპი, წევრი
რომელიც არის ამჟამინდელი მეთოდი,
გამონაკლისი არის დაშვებული
უკანონო არგუმენტი გამონაკლისი.
თუ onThis არის null და მეთოდი არა
სტატიკური, ტიპის გამონაკლისი არის დაყრილი
NullPointerException.
თუ გამოძახებული მეთოდის შესრულება
არანორმალურად წყდება, გადაყრილია
გამონაკლისი ტიპის InvocationTargetException.

11.

მოდით შევხედოთ მაგალითს. დარეკეთ საშუალებით
ასახვის მეთოდი დაბრუნების str.indexOf(".", 8)
მაშინ გვაქვს
სცადე (
კლასი strClass = str.getClass();
მეთოდი indexM = strClass.getMethod("indexOf",
ახალი კლასი (string.class, int.class));
ობიექტის შედეგი = indexM.invoke(str, ახალი ობიექტი (
".", ახალი lnteger(8)));
დაბრუნების ((მთლიანი) შედეგი).intValue();
}
catch (NoSuchMethodException e) (…….. )
დაჭერა (invocationTargetException e) (……..)
დაჭერა (არალეგალური წვდომა გამონაკლისი ე) (……)

12.

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

13.

სტატიკური ორმაგი ტესტიData = (0.3,1.3e-2, 7.9, 3.17);

სცადე (
for(int arg = 0; arg< args.length; arg++){
სტრიქონის სახელი = args;
კლასი classFor = Class.forName(სახელი);
SortDouble sorter =
(SortDouble)classFor.newInstance();
SortMetrics metrics = sorter.sort(testData);
System.out.println(სახელი + ": " + მეტრიკა);
for(int i =0; i< testData.length; i++)
System.out.println(“ " + testData[i]); ) )
catch(გამონაკლისი e) ( System.err.println(e); ) )

14.

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

15.

SecurityException - თუ პოლიტიკა მოქმედებს
უსაფრთხოება კრძალავს ახალი ობიექტების შექმნას
ExceptionInInitializerError – ისვრის როდის
კლასის ინიციალიზაცია.
Constructor კლასი ასევე განსაზღვრავს სხვა მეთოდებს.
საჯარო კლასი getParameterTypes()

პარამეტრების ტიპების შესაბამისი რომ
მითითებულია მიმდინარე კონსტრუქტორის დეკლარაციაში.
საჯარო კლასი getExceptionTypes()
აბრუნებს კლასის ობიექტების მასივს,
გამონაკლისის ტიპების შესაბამისი რომ
მითითებულია დეკლარაციის სროლის პუნქტში
მიმდინარე კონსტრუქტორი.

16.

საჯარო ობიექტის ახალი სტადია (ობიექტის არგები)
ისვრის InstantiationException,
არალეგალური წვდომის გამონაკლისი,
უკანონო არგუმენტი გამონაკლისი,
InvocationTargetException
იყენებს მიმდინარე კონსტრუქტორს
კონსტრუქტორის ობიექტის შექმნა და ინიციალიზაცია
კლასის ახალი მაგალითი, რომელშიც კონსტრუქტორი
განაცხადა, მოცემული არგუმენტების გაცემით.
აბრუნებს ბმულს ახლად შექმნილი და
ინიცირებული ობიექტი. არგების მასივის სიგრძე
უნდა შეესაბამებოდეს პარამეტრების რაოდენობას
კონსტრუქტორის დეკლარაცია და მასივის ელემენტების ობიექტის ტიპები უნდა დაუშვან მინიჭება
კონსტრუქტორის პარამეტრების შესაბამისი ტიპები -
წინააღმდეგ შემთხვევაში გამონაკლისი იქნება დაშვებული
უკანონო არგუმენტი გამონაკლისი.

17.

მოდით შევხედოთ მაგალითს:
კლასი Myclass (
კერძო int ა;
საჯარო Myclass(int k)(a=k;)
საჯარო int ფუნქცია (int a,int b) (დაბრუნება a+b;)
}
საჯარო კლასის მთავარი (
საჯარო სტატიკური სიცარიელე მთავარი (სტრიქონი არგები)(
სცადე (
სტრიქონის სახელი = "Myclass";
კლასი mycl=Class.forName(name);
კლასი d=(int.class);
კონსტრუქტორი c=mycl.getConstructor(d);
Myclass ob=(Myclass)c.newInstance(new Object(
ახალი მთელი რიცხვი(10)));
System.out.println(ob.func(3,5)); )
catch(გამონაკლისი ე)();
}}

18.

AccessibleObject კლასი
Field, Constructor და Method კლასები არის
მიღებული AccessibleObject კლასიდან,
რაც შესაძლებელს ხდის გადაჭრას ან
გამორთეთ შემოწმების დონის წვდომის ატრიბუტები
ენები, როგორიცაა საჯარო და კერძო.
AccessibleObject კლასს აქვს მეთოდები
1. საჯარო void setAccessible (ლოგიკური დროშა)
აყენებს ობიექტზე წვდომის დროშას
არგუმენტის მნიშვნელობის მიხედვით: true
ნიშნავს, რომ ობიექტი აღარ ექვემდებარება
დონეზე დადგენილი წვდომის წესები
ენა (და ყოველთვის ხელმისაწვდომი იქნება), ყალბი
აიძულებს ობიექტს შეინარჩუნოს მოცემულობა
წვდომის დონე.
თუ უფლებამოსილება შეცვალოს დაშვების დროშა
საკმარისი არ არის, გამონაკლისი არის დაშვებული
უსაფრთხოების გამონაკლისი

19.

2. საჯარო სტატიკური
void setAccessible (AccessibleObject მასივი,
ლოგიკური დროშა)
საშუალებას გაძლევთ დააყენოთ წვდომის დროშა
მასივის სახით გადაცემული ობიექტები.
თუ დამუშავების პროცესშია შემდეგი
ობიექტი აგდებს ტიპის გამონაკლისს
SecurityException, ობიექტები მდებარეობს
მასივში ადრე შეინახეთ ახლად მითითებული
წვდომის დონის მნიშვნელობები და ყველა სხვა
ობიექტები რჩება იმავე მდგომარეობაში.
3. საჯარო ლოგიკური isAccessible()
აბრუნებს წვდომის დროშის მიმდინარე მნიშვნელობას
ობიექტს

20.

მასივის კლასი
Array კლასი გამოიყენება მასივის შესაქმნელად
ასახვის საშუალება.
მეთოდის ორი ფორმა გამოიყენება მასივების შესაქმნელად
ახალი ინსტანცია.
საჯარო ობიექტის newlnstance (კლასი compType, int სიგრძე)
აბრუნებს მითითებას compType ტიპის ახალ მასივზე
მოცემული სიგრძის სიგრძე.
საჯარო ობიექტი newInstance (კლასი compType, int dim)
აბრუნებს ბმულს ახალზე მრავალგანზომილებიანი მასივიტიპი
compType, რომლის ზომები მითითებულია მნიშვნელობებით
პარამეტრული მასივის ელემენტები dim.
თუ მასივი dim ცარიელია ან აქვს სიგრძეზე მეტი
ზომების დასაშვები რაოდენობა (ჩვეულებრივ 255),

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

21.

მოდით შევხედოთ მაგალითებს.
მაგალითი 1. მოდით შევქმნათ ბაიტის ტიპის მასივი
ბაიტი ბა = (ბაიტი)
Array.newlnstance(byte.class,13);
ეს ექვივალენტურია
ბაიტი ბა = ახალი ბაიტი;
მაგალითი 2.
int dims = (4, 4);
ორმაგი მატრიცა = (ორმაგი)
Array.newlnstance(double.class, dims);
ეს ექვივალენტურია
ორმაგი მატრიცა = ახალი ორმაგი;

22.

Array კლასს აქვს get and set მეთოდები.
მიეცით int ტიპის მნიშვნელობების x მასივი; მერე
გამოთქმა xa[i] შეესაბამება:
მთელი რიცხვი n=Array.get(xa, i)
თქვენ შეგიძლიათ მიანიჭოთ მნიშვნელობა მასივის ელემენტს, როგორიცაა:
xa[i] = 23; - ეს იგივეა, რაც
Array.set(xa, i, new Integer(23));
პაკეტის კლასი
Class კლასის getPackage მეთოდის გამოძახება საშუალებას იძლევა
მიიღეთ პაკეტის კლასის ობიექტი, რომელიც შეიცავს
პაკეტის აღწერა, რომელიც შეიცავს
კლასი (თავად პაკეტის კლასი განთავსებულია პაკეტში
java.lang).
Package ობიექტის getName() მეთოდი ბრუნდება
მიმდინარე პაკეტის სრული სახელი.

23.

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

24.

პროქსი კლასი იქმნება მეთოდის გამოძახების გამოყენებით
Proxy.getProxyClass რომელიც იღებს ClassLoader-ს და
ინტერფეისების მასივი და აბრუნებს ობიექტს
class java.lang.კლასი რომელიც დატვირთულია
გაიარა ClassLoader და ახორციელებს გადაცემულ მასივს
ინტერფეისები.
არსებობს მთელი რიგი შეზღუდვები გავლილ პარამეტრებზე:
1. ინტერფეისების მასივის ყველა ობიექტი უნდა იყოს
ინტერფეისები. ისინი არ შეიძლება იყოს კლასები ან
პრიმიტივები.
2. მასივში არ შეიძლება იყოს ორი იდენტური ინტერფეისი.
ობიექტები.
3. ინტერფეისების მასივში ყველა ინტერფეისი უნდა იყოს
ჩატვირთულია ClassLoader-ის მიერ, რომელიც გადაეცემა მეთოდს
getProxyClass.
4. ყველა არასაჯარო ინტერფეისი უნდა იყოს განსაზღვრული
იმავე პაკეტში, სხვაგვარად გენერირებული პროქსი კლასი
ვერ შეძლებს მათ ყველა განხორციელებას.

25.

5. არ შეიძლება ჰქონდეს ორი ინტერფეისი
მეთოდი ამავე სახელწოდებით და
პარამეტრის ხელმოწერა, მაგრამ განსხვავებული
დაბრუნების ტიპები.
6. ინტერფეისების მასივის სიგრძე შეზღუდულია
65535 ინტერფეისი. ჯავის კლასი არ არის
არ შეუძლია 65535-ზე მეტის განხორციელება
ინტერფეისები.

26.

დინამიური პროქსი კლასის თვისებები
1. პროქსი კლასი არის საჯარო, გათვალისწინებული
საბოლოო მოდიფიკატორი და არ არის აბსტრაქტული.
2. პროქსი კლასის ნაგულისხმევი სახელი არ არის
განსაზღვრულია, მაგრამ იწყება პროქსიდან. ყველა
სახელთა სივრცე, რომელიც იწყება პროქსით
დაცულია პროქსი კლასებისთვის
(IN უახლესი ვერსიებიჯავა არ არის საჭირო).
3. პროქსი კლასი მემკვიდრეობით იღებს
java.lang.reflect.Proxy.
4. პროქსი კლასი ახორციელებს ყველა ინტერფეისს,
გადაეცემა შექმნისას, გადაცემის წესით.

27.

5. თუ პროქსი კლასი ახორციელებს არასაჯარო
ინტერფეისი, შემდეგ იგი გენერირებული იქნება პაკეტში
რომელიც განსაზღვრავს ამ ყველაზე არასაჯარო
ინტერფეისი. ზოგადად, პაკეტი, რომელშიც
წარმოიქმნება განუსაზღვრელი პროქსი კლასი.
6. Proxy.isProxyClass მეთოდი აბრუნებს true for
გამოყენებით შექმნილი კლასები
Proxy.getProxyClass და ობიექტების კლასებისთვის,
შექმნილია Proxy.newProxyInstance და
ცრუ სხვაგვარად.
ამ მეთოდს იყენებს ქვესისტემა
ჯავის უსაფრთხოება და ამის გაგება გჭირდებათ
უბრალოდ მემკვიდრეობით მიღებული კლასი
java.lang.reflect.Proxy დაბრუნდება false.

28.

შექმნილი პროქსი კლასის ინსტანციის თვისებები შემდეგია:
1. ჩვენ მივყავართ პროქსი კლასის ობიექტს ყველა ინტერფეისში,
გავიდა ინტერფეისების მასივში. თუ IDemo ერთ-ერთია
გადაცემული ინტერფეისები, შემდეგ ოპერაციის პროქსი მაგალითი
IDemo ყოველთვის დაბრუნდება true, ხოლო ოპერაციის (IDemo) პროქსი
სწორად დასრულდება.
2. სტატიკური მეთოდი Proxy.getInvocationHandler
აბრუნებს შექმნისას გავლილ ზარის დამმუშავებელს
პროქსი კლასის მაგალითი. თუ გადაეცემა ამ
მეთოდის ობიექტი არ არის პროქსი კლასის მაგალითი
გამონაკლისი იქნება IllegalArgumentException.
3. ზარის დამმუშავებლის კლასი ახორციელებს ინტერფეისს
InvocationHandler, რომელიც განსაზღვრავს გამოძახების მეთოდს,
რომელსაც აქვს შემდეგი ხელმოწერა:
საჯარო ობიექტის გამოძახება (ობიექტის პროქსი, მეთოდის მეთოდი,
ობიექტს არგს) ისვრის Throwable

29.

მოდით შევხედოთ მაგალითს:
პაკეტი javaapplication3;
ინტერფეისის ანგარიში (
ორმაგი getBalance();
void changeBalance(int sum);
ბათილი პროცენტები (ორმაგი თითოზე);)
კლასი MyAccount ახორციელებს ანგარიშს (
პირადი ორმაგი ბალანსი;
საჯარო MyAccount() (ბალანსი=0.0; )
public double getBalance() (დაბრუნების ბალანსი;)
საჯარო ბათილობის ცვლილება ბალანსი(ინტ ჯამი)(
ბალანსი+=ჯამად;)
საჯარო სიცარიელის პროცენტები (ორმაგი თითო)(
ბალანსი+=ბალანსი*100-ზე; ); )

30.

კლასი MyAccountProxy ახორციელებს
Invocation Handler(
პირადი ანგარიში ac;
საჯარო MyAccountProxy(Account acc)(ac=acc;)
საჯარო სტატიკური ანგარიში newInstance(Account da)(
return (ანგარიში)Proxy.newProxyInstance(
da.getClass().getClassLoader(),
da.getClass().getInterfaces(),
ახალი MyAccountProxy(da));
}

31.

საჯარო ობიექტის გამოძახება (ობიექტის პროქსი,
მეთოდის მეთოდი, ობიექტის არგსი)
ისვრის სასროლი(
if(method.getName()=="პროცენტები")(
double d=((Double)args).doubleValue();
თუ (დ<0) d=0;
if(d>30) d=30;
args=new Double(d);

სხვა (
დაბრუნების მეთოდი.invoke(ac, args); )
}
}

32.

საჯარო კლასის მთავარი (
საჯარო სტატიკური სიცარიელე მთავარი (სტრიქონი არგები)(
ჩემი ანგარიში ma=new MyAccount();
ანგარიში
a=(ანგარიში)MyAccountProxy.newInstance(ma);
a.changeBalance(150);

ა.პროცენტები(20);
System.out.println(a.getBalance());
ა.პროცენტები(35);
System.out.println(a.getBalance());))

33.

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

34.

ClassLoader კლასი არის აბსტრაქტული კლასი.
საკუთარი კლასის ჩამტვირთველის შესაქმნელად,
თქვენ უნდა შექმნათ კლასი, რომლის შთამომავალია
ClassLoader და override მეთოდი
დაცული კლასი findClass (სტრიქონის სახელი) ისვრის
ClassNotFoundException
რომელიც პოულობს კლასის ბაიტეკოდს მოცემულობით
დაარქვით სახელი და იტვირთება მონაცემები გარემოში
ვირტუალური მანქანა, აბრუნებს კლასის ობიექტს,
აღმოჩენილ კლასს წარმოადგენს.
ჩამტვირთავი ობიექტს შეუძლია დელეგირება
უფლებამოსილება ჩატვირთოს კლასები „მშობელზე“
კლასის ჩამტვირთველს (მშობლის კლასის ჩამტვირთველს).
"მშობელი" კლასის ჩამტვირთავი შეიძლება იყოს
არგუმენტად მოცემულია კლასის კონსტრუქტორისთვის
ClassLoader.

35.

დაცული ClassLoader()
ქმნის ClassLoader ობიექტს, იმპლიციტურად
გამოყენება როგორც "მშობელი"
კლასის მტვირთავი სისტემის ჩამტვირთავი
(რომლის მიღება შესაძლებელია მეშვეობით
გამოიძახეთ getSystemClassLoader მეთოდი).
დაცული ClassLoader (ClassLoader-ის მშობელი)
ქმნის ClassLoader ობიექტს გამოყენებით
მითითებული "მშობელი" კლასის ჩამტვირთავი.
ClassLoader კლასის ძირითადი ნაწილი
არის loadClass მეთოდი

36.

საჯარო კლასი loadClass (სტრიქონის სახელი) ისვრის
ClassNotFoundException
აბრუნებს Class ობიექტს მოცემული კლასისთვის
დაასახელეთ და, საჭიროების შემთხვევაში, იტვირთება ეს
კლასი. თუ კლასი ვერ იტვირთება,
გამონაკლისი არის დაყრილი
ClassNotFoundException.
მეთოდით შემოთავაზებული კლასის დატვირთვის სქემა
loadClass არის ნაგულისხმევი და ჩვეულებრივ არა
გადაფარული, ასე გამოიყურება:
1. შეამოწმეთ მეთოდის გამოძახებით
ClassLoader-ის findLoadedClass, არა
ჩაიტვირთა? მოცემული კლასიადრე; როგორც ნაწილი
ClassLoader გთავაზობთ ობიექტების ცხრილს
ინსტრუმენტებით დატვირთული კლასი ყველა კლასისთვის
მიმდინარე კლასის ჩამტვირთავი; თუ იყო კლასი
ადრე ჩატვირთული, findLoadedClass მეთოდი
დააბრუნებს მითითებას არსებულ Class ობიექტზე;

37.

2. თუ კლასი არ იყო დატვირთული, მას ეძახიან
"მშობელი" ჩამტვირთველის loadClass
კლასები; თუ მიმდინარე ჩამტვირთველი არ არის
ჰყავს „მშობელი“, გამოიყენება
სისტემის კლასის ჩამტვირთავი;
3. თუ კლასი ჯერ კიდევ არ არის დატვირთული,
findClass მეთოდი ეწოდება, doing
მოძებნეთ და ჩამოტვირთეთ კლასი.
ამრიგად, აუცილებელია მისი განხორციელება
შემდეგი მეთოდების საბაჟო ვერსიები
ClassLoader:

38.

დაცული სინქრონიზებული კლასი
loadClass (სტრიქონის სახელი, ლოგიკური გარჩევადობა)

დაცული კლასი findClass (სტრიქონის სახელი)
ისვრის ClassNotFoundException
დაცულია java.net.URL findResource (სტრიქონის სახელი)
დაცული java.util.Enumeration
findResources (სტრიქონის სახელი) ისვრის IOException
(აბსტრაქტული კლასი ClassLoader წარმოადგენს
მხოლოდ loadClass მეთოდის დანერგვაზე დაფუძნებული
დაცულ მეთოდებზე – findLoadedClass და findClass).

39.

მოდით შევხედოთ მაგალითს.
კლასის PlayerLoader აფართოებს ClassLoader-ს (
საჯარო კლასი findClass (სტრიქონის სახელი) ისვრის
ClassNotFoundException(
სცადე (
ბაიტი buf = bytesForClass(სახელი);
return defineClass(name, buf, 0, buf.length);
}
დაჭერა (IOException e) (
გადაყარეთ ახალი ClassNotFoundException(e.toString());
}
}
// ...bytesForClass მეთოდის დეკლარაციები და სხვა
მეთოდები
}

40.

findClass მეთოდი ჩვეულებრივ აკეთებს ორ რამეს
ფუნქციები.
პირველ რიგში, მან უნდა აღმოაჩინოს ბაიტეკოდი
მოცემული კლასი და შეინახეთ მასივში
ტიპის ბაიტი - ეს მოვალეობა მაგალითში
ენიჭება bytesForСlass მეთოდს.
მეორეც, ის იყენებს აპლიკაციის მეთოდს
defineСlass რომ გააკეთოს ფაქტობრივი
ბაიტიკოდით განსაზღვრული კლასის ჩატვირთვა.
defineСlass მეთოდი ასე გამოიყურება

41.

დაცული საბოლოო კლასი defineClass (სტრიქონის სახელი,
ბაიტის მონაცემები, int offset, int length) სროლა
ClassFormatError
აბრუნებს Class ობიექტს კლასისთვის მოცემული სახელით
სახელი; კლასის ორობითი წარმოდგენა გადაეცემა
მასივის მონაცემების სახით.
კლასის ჩასატვირთად გამოიყენება მხოლოდ ბაიტები,
შეიცავს მონაცემთა მასივის ელემენტებს ინდექსებით
ოფსეტიდან ოფსეტამდე+სიგრძე. თუ ბაიტები მითითებულიდან
ხარვეზები არ აკმაყოფილებს საჭირო ფორმატს
კლასის აღწერილობაში, გამონაკლისის ობიექტია გადაყრილი
აკრიფეთ ClassFormatError.
მეთოდი პასუხისმგებელია ობიექტზე მითითების შესანახად
დატვირთული კლასის კლასი ჩატვირთულ ცხრილში
კლასები მოძიებული findLoadedClass მეთოდით.

42.

მოდით შევხედოთ bytesForClass მეთოდს.
დაცული ბაიტი ბაიტიForClass(სტრიქონის სახელი) ისვრის
lOException, ClassNotFoundException(
FileInputStream in = null;
სცადე (


თუ (სიგრძე == 0) გადაყარეთ ახალი ClassNotFoundException(სახელი);
ბაიტი buf = ახალი ბაიტი;

დაბრუნება buf;
}
ბოლოს (
if (in!=null) in.close();
}
}

43.

ამგვარად სრული კოდიაქვს ფორმა:
იმპორტი java.lang.reflect.*;
java.io.* იმპორტი;
კლასი MyClassLoader აფართოებს ClassLoader(
საჯარო კლასიfindClass (სტრიქონის სახელი) ისვრის
ClassNotFoundException(
ბაიტი buf=ReadFromBuffer(სახელი);
if(name.equals("MyInterface1"))(

) სხვა შემთხვევაში, თუ (buf==null) (
დაბრუნება findSystemClass(სახელი);
) სხვა (
return defineClass(name,buf,0,buf.length);
}
}

44.

დაცული ბაიტი ReadFromBuffer (სტრიქონის სახელი) ისვრის
ClassNotFoundException(
FileInputStream in = null;
სცადე (
in = new FileInputStream(სახელი + ".კლასი");
int სიგრძე = in.available(); // ხელმისაწვდომი ბაიტების რაოდენობა
თუ (სიგრძე == 0) ჩააგდოს
ახალი ClassNotFoundException(სახელი);
ბაიტი buf = ახალი ბაიტი;
in.read(buf); // წაიკითხეთ ბაიტები
დაბრუნება buf;
}
catch(FileNotFoundException e)( return null;)
catch(IOException e)( return null;)
ბოლოს (
try(if (in!=null) in.close();)
catch(IOException e)( )
}
}

45.

დაცული სინქრონიზებული კლასი
loadClass (სტრიქონის სახელი, ლოგიკური გადაწყვეტა) ისვრის
ClassNotFoundException(
კლასის შედეგი= findClass(სახელი);
if (resolve) solveClass(result);
დაბრუნების შედეგი;
}
}

46.

საჯარო კლასი მთავარი 1 (
საჯარო სტატიკური სიცარიელე მთავარი (სტრიქონი არგები) (
სცადე (
სტრიქონის სახელი = "Myclass";
ClassLoader ld=new MyClassLoader();
კლასი cl=Class.forName(name, true, ld);
კონსტრუქტორი s=cl.getConstructor(int.class);
ჩემი ინტერფეისი 1
ob=(MyInterface1)s.newInstance(
ახალი მთელი რიცხვი(8));
System.out.println(ob.func(3,5));
)დაჭერა(გამონაკლისი ე)( );
}
}

47.

საჯარო ინტერფეისი MyInterface1(
public int func(int a,int b);
}
საჯარო კლასი Myclass ახორციელებს MyInterface1 (
კერძო int ა;
საჯარო Myclass(int k) (a=k;)
public int func(int a,int b)( დაბრუნება a+b;)