კლასები, მეთოდები & ობიეკტები

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

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

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

საჭირო ინფორმაცია კლასებზე:

1. Source File-ში შესაძლებელია მხოლოდ ერთი public კლასის ქონა

2. Source File-ს შეუძლია განუსაზღვრელი non-public კლასების ქონა

3. კლასებს გააჩნია ხელმისაწვდომობის საფეხურები

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

5. დეფინირება ხდება საკვანძო სიტყვით class [<access_modifier>] class <class_name> 

6. კლასი მთლიანი სახელწოდება შედგება : <package_name>.<class_name>

7. თუ კლასის სახელწოდება შედგება რამოდენიმე სიტყვისგან აუცილებელია გავითვალისწინოთ Camel Case სიტაქსი;

8. ველების დეკლალირება კლასში როგორც წესი ხდება მეთოდების, კონსტრუკტორების და ბლოკების გარეთ: დეკლარირების მაგალითი; [<modifiers>] <field_type> <field_name>; ინიციალიზაციის მაგალითი; [<modifiers>] <field_type> <field_name> = <initial_value>;

9.კლასებს გააჩნია ატრიბუტები და ქცევის წესები

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

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

12. კლასებს გააჩნია იერარხია. არებობს ძირითადი კლასი, და ქვე კლასები. Main class and sub classes. ისინი ერთმანეთან კავშირში არიან და აქვთ სხვა და სხვა წესები წვდომის. 

განვიხილოთ ყველაფერი მაგალითზე. 

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

მთლიანი კლასის მაგალითი

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

                                                                            მეთოდი

რა არის მეთოდი. მეთოდი გახლავთ დასათაურებული ბლოკი კოდისა რომელიც ასრულებს მასზე დავალებულ მოქმედებას. ეს მოქმედება განსაზღვრავს ობიეკტის ქმედებას რომელიც შეიქმნება კლასიდან. მარტივად რომ ვთქვათ მეთოდი ასრულებს ალგორითმებს და ამუშავებს მონაცემებს რომელსაც ობიეკტი იყენებს. ერთი მეთოდის გამოყენება შესაძლებელია უამრავჯერ. მისი დეკლალირება ხდება შემდეგნაირად: [modifier] <return_type> <method_name>([<param_list>]) public void makeCoffe()

Public = [modifier], void = <return_type>, makeCoffe = <method_name>, ()=([<param_list>]) .

სადაც modifier გახლავთ (public, private, default ან protected), return type-ის საშუალებით ვერკვევით მეთოდი დაგვიბრუნებს რაიმე ინფორმაციას თუ არ დაგვიბრუნებს, მეთოდის სახელწოდება და ბოლოს პარამეტრები. მეთოდის სახელწოდებაზე საუბრის დროს აუცილებელია დავიცვათ შემდეგი წესები: სახელმა უნდა აღწეროს მისი ქმედება, მეთოდის სახელწოდება იწყება პატარა ბგერით და ითვალისწინებს CamelCase სინტაქს, მეთოდის სახელწოდება უნდა იყოს ზმნა ან არსებითი სახელი. რაც შეეხება პარამეტრებს: მეთოდებს შეუძლიათ მიიღონ პარამეტრები, პარამეტრების დეფინირება ხდება მეთოდის შექმნის დროს, საჭიროა გავითვალისწონოთ თანმიმდევრობა მათი გამოძახების დროს. შესაძლებელია იქონიათ განხვავებული მეთოდები ერთი და იგივე სახელწოდებით, მაგრამ განსხვავებული ტიპის ან/და ოდენობის პარამეტრებით.

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

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

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

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

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

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

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

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

<access_modifier> 

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

• Public მოდიფიკატორის მეშვეობით ელემენტზე, მეთოდზე თუ კლასზე წვდომა შესაძლებელია გლობალურად, ის ჩანს კლასში, პაკეტში, ქვე კლასში და მას ყველა ხედავს. 
• Protected მოდიფიკატორის მხედველობაც აგრეთვე ვრცელდება ყველაფერზე გარდა გლობალური ხედვისა, მას ვერ ნახავს ხალხი. 
• Default მოდიფიკატორის მხედველობა ვრცელდება კლასზე და პაკეტზე მხოლოდ. 
• Private მოდიფიკატორის მხედველობა ვრცელდება მხოლოდ კლასზე. კლას გარეთ, კლასში დეფინირებული private field, variable, method თუ ნებისმიერი სხვა რამე არ ჩანს. 

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

რა არის კონსტუკტორი; 

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

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

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

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

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

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

3. This შეიძლება გამოყენებულ იქნეს კლასის მეთოდებზე წვდომისთვის 

4. This შეიძლება გადაწოდებულ იქნეს მეთოდზე როგორც არგუმენტი 

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

6. This შეიძლება გადაწოდებულ იქნეს კონსტუკტორზე როგორც არგუმენტი. 

მაგალითზე უკეტ მივხვდებით: 

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

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

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

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

ახსნა განმარტებას არ საჭიროვებს, ყველაფერი ნათელია; კომპილირების შემდგომ 

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

ვისაუბრეთ კლასებზე, მეთოდებზე, და დროა ვისაუბროთ იმაზე თუ რა იქმენბა კლასებიდან და მეთოდებიდან. 

                                                                                  ობიეკტი

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

1. საკვანძო სიტყვა new-ს მეშვეობით ვქმნით ადგილს მეხსირებაში; 

2. კონსტუკტორის დახმარებით ვახდენტ ობიეკტის მომზადებას 

3. ობიეკტის შექმნის დროს ინსტანციურ ველს გააჩნია საწყისი ღირებულება, 0 ან NULL 

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

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

6. ობიეკტის განთავისუფლება ხდება Null-ის მეშვეობით; მაგალითად Student zaira = new Student(); შეიქმნა ობიეკტი. Student Zaira = Null; გაუქმდა ობიეკტი. უფრო დეტალურად თუ ავხსნით შეწყდა ობიეკტის გამოყენება რომელსაც Garbage Collector მოაკითხავს გაუქმებისთვის. 

7. ობიეკტს გააჩნია მდგომარეობა და ქცევის წესები; 

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

თუ თქვენ შეადარებთ სოფტ ობიეკტს რეალურ ობიეკტს რეალური ცხოვრებიდან მაშინ მიხვდებით რომ მათ შორის არ არის დიდი სხვაობა. რეალურ ობიეკტებსაც გააჩნიათ მდგომარეობა და ქცევის წესები. მაგალითისთვის ავიღოთ ძროხა, მისი მდგომარეობა არის შემდეგი, მას გააჩნია სახელი და ფერი, ქცევის წესები კი აქვს შემდეგი, იცოხნება, იწველება, დარბის, ღმუის. ყველაფერი ამის შექმნა პროგრამუალდ შესაძლებელია რათა შევქმნათ ობიეკტი ძროხა. თუ განვავრცობთ, სახელს და ფერს მარტივად მივანიჭებთ ცვლადებით, მერე მეთოდების საშუალებით შეუქმნით ქცევის წესებს, public String waggingTheTail(){return “all day long”} ა.შ და ა.შ 

                                                                              Static

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

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

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

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

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

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

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

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

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

მაშ ასე: 

Math - არის კლასის სახელი. 

. არის ოპერატორი 

Sqrt - არის მეთოდი 

()-ნებისმიერი ინფორმაცია ფრჩხლებში არის პარამეტრი. 

ასე დეტალურად იმიტომ რო იერარხია წარმოიდგინოთ როგორ შეიქმნა მათემატიკური კლასი, რა მეთოდები აქვს შიგნით და როგორ მუშაობენ ეგ მეთოდები, ამ მაგალითზე კარგად ჩანს რომ math.sqrt() მეთოდი არის Return type მეთოდი რომელიც აბრუნებს ღირებულებას. თუ როგორ უნდა განასხვავოთ R Type(return type) და V Type (void type) მეთოდი ერთმანეთისგან ამას დაბლა ნახავთ. როგორ მივხვდით რომ შემდეგი ორი მათემატიკური ოპერაცია არის სტატიკური კონსტანტა. თუ გახსოვთ ადრე ვისაუბრეთ კონსტანტებზე, რომლის დეფინირებაც ხდება ALL_UPPER_CASE, ზუსტად აქედან გამომდინარე PI და E გახლავთ კონსტანტური ცვლადები, მაგრამ როგორ მივხვდით რომ კონსტანტური ცვლადები სტატიკურად არის დეფინირებული? ამაზეც ვისაბრეთ სტატიკურ წევრზე წვდომა სტატიკურ წევრებს შეუძლიათ მხოლოდ. ჩვენ შემთხვევაში public static void main() მეთოდი არის სტატიკური, შესაბამისად Math.PI გახლავთ სტატიკური კონსტანტური ცვლადი. 2 მიზეზის გამო. 1. ის რომ არ იყოს სტტაიკური კონსტანტა მის გამოსაძახებლად ობიეკტის შექმნა მოგვიწევდა 2.ის რომ არ იყოს სტატიკური რამდენჯერაც გამოვიძახებდით იმდენჯერ მოვახდენდით მეხსირებაში ადგილის ალოკაციას. რაც ძალიან მეეჭვება რომ ჯავას დეველოპერებს არ ქოდნეთ გათვალისწინებული. 

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

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

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

შემდეგი განსახილველი თემა გახლავთ მეთოდის პარამეტრები: 

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

შედეგი: 

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

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

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

შესაბამისად მეთოდის შექმნის დროს გასათვალისწინებელია: თანმიმდევრობა, ოდენობა და შეთავსება. ეს გახლვათ სამი ოქროს წესი რომელიც არასდროს არ უნდა დაგავიწყდეთ. + ყველა სხვა წესები ვრცელდება ჩვეულებრივად ტიპებზე. კასტინგი, კონვერიტრება და ა.შ თუმცა გამოგვრჩა ერთი შეცდომა, ნახეთ ალბათ რო 35000 ლარი გვაქ საბანკო ანგარიშზე მაგრამ ეკრანზე გამოვიდა 35 ლარი. პრობლემას Escape Sequances და Printf() მეთოდი, მოაგვარებს, რომელზეც ვრცლად ვისაუბრეთ. როდესაც დიდი ინფორმაციის ფორმატირებასთან გვაქ საქმე რამოდენიმე არგუმენტით, მიზანშეწონილია ფორმატირების მეთოდს მივმართოთ. მაგალითს არ გავაკეთებთ. თქვენ თვითონვე მიაგენით გამოსავალს. (თუ ინტერესი გექნათ)

                                                                      Void & Non Void Method 

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

Non Void ტიპის მეთოდი წარმოადგენს მეთოდს რომელიც აუცილებლად დააბრუნებს ღირებულებას, ცვლადს, ლიტერალს ან ოპერაციას. თუ რა ღირებულებას აბრუნებს იმაზეა დამოკიდებული რა ტიპის ღირებულების მატარებელია მეთოდი, (int,byte,short,String) თუ ნებისმიერი სხვა. ტიპი რომლის მატარებელიც არის მეთოდი და ტიპი რომელიც დაბრუნებულ იქნება მეთოდიდან აუცილებლად უნდა ემთხვეოდეს ერთმანეთს. შეუძლებელია მეთოდი იყოს int ტიპის მატარებელი და return <String> ბრძანება მივცეთ დასასრულის დროს. ჯავა ამის უფელაბს არ მოგვცემს იმიტომ რო 100 % სიზუსტით ითხოვს იმფორმაციას თუ რა მოქმედებას შეასრულებს ეს ოპერაცია. 

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

მაგალითი 1: 

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

შევიყვანეთ პირველი ციფრი, მეორე ციფრი. ვოიდ მეთოდმა იმუშავა მაგრამ Non-Void(Return Type) მეთოდის შემდგომ გვაქ სიცარიელე. ეს გახლავთ პირველი შეცდომა რომელსაც დამწყები პროგრამისტები უშვებენ, ამ ორი მეთოდის კომპილირება არ ხდება ერთნაირად. სხვა და სხვა მიდგომა აქვს. სკრინზე თუ დააკვირდებით math.sumVoidEx(num1,num2); ვოიდ მეთოდი ცალკე დგას, ასე ხდება მასთან წვდომა. ის ყოველთვის ცალკე დგას, რასაც არ უნდა აბრუნებდეს. მაგრამ Return Type მეთოდისგან შედეგის დაბრუნება თუ გვსურს შემდეგი ოპერაციები უნდა გამოვიყენოთ, 

ა. ის უნდა მოვაქციოთ სხვა მეთოდში. ჩვენ შემთხვევაში System.out.println().

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

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

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

და ამის ნათელი მაგალითია ეს სურათი. ვოიდ მეთოდში მთლიანი ოპერაცია ჩანს როგორ მივიღეთ ხუთი, მაგრამ დანარჩენ სამ მაგალითზე უბრალოდ შედეგი გვაქ 5. 2+3=5 ჩვენ თვითონ დავწერეთ ესეც მართალია. მაგრამ იმიტომ დავწერე რო მაგალითი კარგად გამოჩენილიყო, მეორე განსხვავება ვოიდ მეთოდს System.out.println(). მეთოდი აქვს შიგნით, რაც Return Type მეთოდს არ ჭირდება. თუ სურვილი გაგვიჩდა რო მსგავსი შედეგი დავიბრუნოთ Return Type მეთოდიდან მაშინ უბრალოდ ჩავამატებთ მთავარ მეთოდში System.out.println(num1 + “+” + num2 + “=” + math.sum.NonVoidEx(num1,num2))

ან return num1 + “+” + num2+”=”+ calculate. ვნახოთ მაგალითზე. 

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

ეს გახლავთ მაგალითი 2: ყველაზე ხშირად დაშვებულ შეცდომებში, ტიპი რომლის მატარებელიც არის მეთოდი უნდა ემთხვეოდეს ტიპს რომელსაც აბრუნებს მეთოდი, ჩვენ შემთხვევაში მეთოდი int გვაქ და ვაბრუნებთ String-ს. მარტივად სწორდება ეგ შეცდომა, ინტის ადგილზე სტირნგს დავწერთ. გაითვალისწინეთ ეგ ორი ოპერაცია უნდა ემთხვეოდეს ერთმანეთს და პარამეტრებად რა გაქვთ საერთოდ არ არის მნიშვნელოვანი. ინტ ოპერაციას თუ ასრულებთ ინტი უნდა დაბრუნდეს. Byte თუ ასრულებთ byte უნდა დაბრუნდეს და ა.შ

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

დაგვიბრუნდა სტრინგი.

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

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

მაგალითი 3:

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

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

                                                                                 დამხმარე მეთოდი

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

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

მომხმარებელია ახდენს ინფორმაციის მიწოდებას და პროგრამა აბრუნებს მიწოდებულ ინფორმაციას. 

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

ძირითადი მეთოდი:

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

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

                                                                                         Getter’s & Setter’s

გეთერები და სეთერები გახლავთ მეთოდები რომლის მოვალეობაც არის შეაღწიოს და ღირებულება შეუცვალოს კლასის private წევრებს, ცვლადებს მაგალითად. პროგრამირების ენაზე ამას ენკაპსულაცია ქვია, ვინაიდან და რადგანაც ენკაპსულაცია გაცილებით მეტია ვიდრე გეთერები და სეთერები ახლა გვერდს აუვლი. მისი დადებითი მხარე გახლავთ ის რომ ცვლადებზე ლავირების უფლება გეძლევათ და ინფორმაციის დამალვის პრიორიტეტი გაგაჩნიათ. წარმოიდგინეთ ქარხანა აწყობს ავტომობილს, რომელსაც გააჩნია გამოშვების წელი, გარბენი, ტახომეტრები და ა.შ რომელიც მუდმივად იცვლება, ავტომობილის შექმნის დროს ცვლად გარბენს, ცვლად გამოშვების წელს ღირებულებებს ხომ არ მიანიჭებთ? რათქმა უნდა არა. ან გარედან ვინმეს ხომ არ მიცემთ ღირებულებების მინიჭების უფელაბს? პასუხი იგივეა. არა! სწორედ ამისთვის გამოიყენება ეგ მეთოდები. მათი მოვალეობა არის შეაღწიონ და ღირებულება შეუცვალონ კლასის დამალულ წევრებს, დასახელება თვითონ მეტყეველბს მის მისიაზე. გეთერების საშუალებით ვახდენთ შეღწევას დამალულ წევრებში და სეთერების საშუალებით ვანიჭებთ მას ღირებულებას, რის შემდგომაც მინიჭებულ ღირებულებას გეთერების მეშვეობით ვაბრუნებთ პროგრამაში, ეს გარანტიას გვაძლევს რო ჩვენი ავტომობილის გამოშვების წელი გარედად არ იქნება შეცვლილი და არ მოგვიწევს მასზე ღირებულების მინიჭება თავიდანვე. თუ ვერ წარმოიდგინეთ ავტომობილის მაგალითზე წარმოიდგინეთ თამაში სადაც გაქვთ Game level, Weapons და სხვა ატრიბუტები, გესიამოვნებათ ვინმემ თქვენ თამაში ლეველი თვითონვე რომ აირჩიოს? ან ღირებულება რო მიანიჭოთ 0 ლეველი და მთელი პროცესის მანძილზე 0 ლეველი იყოს მოთამაშე. აზარტი არ ექნება ეგეთ თამაშს. Accesor-ად გამოიყენება კონსტრუკტორიც, ოღონდ მას სულ სხვა მოვალეობები გააჩნია. ნახეთ მაგალითი ამ ორ მეთოდზე. 

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

რასაც ერთი წლის მერე შევცვლით: 

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

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

                                                                                              toString() 

toString() არის მეთოდი რომელიც გვეხმარება ობიეკტის წარმოდგენაში და წარმოადგენს მას როგორც String-ს. როდესაც ვქმნით ობიეკტს და არ გვაქ დიდი სურვილი ვწეროთ ბევრი (გამოვიძახოთ სასურველი მეთოდები სათითაოდ, გამოვიძახოთ ცვლადები და ა.შ) ვიყენებთ ამ მშვენიერ მეთოდს რომელიც რეფერენციულ ცვლადს ავტომატურ რეჟიმში (Implicity) ანიჭებს ღირებულებებს. მისი გამოყენება მიზნშეწონილია დებაგირებისთვისაც, რადგან მარტივად ვახდენთ დებაგირებას. გვიმარტივებს ინფორმაციის Map, Hashmap, list და სხვა საჭირო ხელსაწყოებში შენახვას. ნახეთ მაგალითი: 

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

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

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

ჩავასწოროთ კოდი. 

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

სტატიკური მაგალითები: 

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

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

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

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

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

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

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

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

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

და მოავხდინეთ კომპილირება: 

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

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

დასკვა: სტატიკურ ცვლადს ინაწილებს ყველა ინსტანცირებული ობიეკტი თანაბრად. ინსტანცირებულ ცვლადს იყენებს ყველა ობიეკტი ცალ-ცალკე. 

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

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

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

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

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

6. სტატიკური მეთოდი ვერ იქნება ჩანაცვლებული. განსხვავებით ინსტანცირებული მეთოდისა, რომლის ჩანაცვლება მუდმივად შესაძლებელია (can not be overridden) 

მაგალითი: 

ყველაფერი მოქმედებაში: 

ქვე კლასი. 

ძირითადი კლასი: 

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

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

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

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

შედეგი: 

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

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