ჯავას სინტაქსი

1.  საკვანძო სიტყვები

2.  იდენტიფიკატოები

3.  ლიტერალები

4.  ცვლადები

5.  ტიპები

6.  ბლოკები

7.  კომენტარები

1

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

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

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

სწორი დასათაურება:

1. myJavaBook
2. myjavabook
3. MYJAVABOOK
4. x
5.  y
6. _myjavabook
7. $myjavabook
8. _12cigni
9. OHenry
10. es_aris_uazro_teqsi_magalitistvis_romels_sigrdzles_aranairi_mnishvneloba_ar_aqvs_imitom_rom_cvladis_dasaxelebis_sigrdze_gansazgvruli_ar_aris

დაიმახსოვრეთ! myJavaBook,  myjavabook, MYJAVABOOK ერთი და იგივე ღირებულების მატარებლები არ არიან სწორედ ამას ნიშნავს (case sensitive). როგორ წერ მეტყველებს იმაზე თუ რას აკეთებ. კიდევ ერთი მაგალითი case sensitive-ზე. ცვლადი Double და ცვლადი double ერთი და იგივე ღირებულებას არ ატარებენ. ერთი ობიეკტია (Double) მეორე პრიმიტიული ცვლადის ტიპი(primitive type variable - double)

მცდარი დასათაურება:

1. My Java Book // შეიცვას space-ს
2. 12cigni  //  დასათაურება იწყება ციფრით
3. Bondos + mayvala // + ნიშანი არ არის ალფანუმერაციული (არც ციფრია არც ბგერა)
4. O’Henry // აპოსტროფი არ არის ალფანუმერაციული
5. es_&_aris_&uazro_&_teqsi_magalitistvis //ამპერსანტი არ არის ალფანუმერაციული.

3.  ლიტერალები (Literals).  ლიტერალები მარტივად რო ვთქვათ არის ღირებულება, ამა თუ იმ ტიპის, პრიმიტიული იქნება ტიპი თუ რეფერენციული. მაგალითზე ადვილად მიხვდებით :

String string = “vashli” // String - ობიეკტური, რეფერენცული ტიპის დატა,

string - ცვლადის სახელწოდება, “vashli” - ცვლადის ღირებულება. ვაშლი ამ შემთხვევაში არის ლიტერალი.

Int girebuleba = 25; // მაგალითისთვის ვყიდით ვაშლს რომელიც ღირს 25 ლარი, როცა ვქმნით პროგრამას რომელმაც სუპერმარკეტში უნდა იმუშაოს აუცილებელია ვიცოდეთ რა ღირს სუპერმარკეტში ვაშლი. ამისთვის გვინდა ტიპიზირებული დატა, რომელიც ამ შემთხვევაში იქნება int (Integer - პრიმიტიული ტიპის დატა -  primitive data type), გვინდა ცვლადის სახელწოდება (girebuleba) და გვინდა ტიპის ღირებულება. რაც 25 ლარია. 25 ლარი არის ლიტერალი. ისევ გადავხედოთ, ლიტერალი არის ცვლადზე, ობიეკტზე ან/და ტიპზე მინიჭებული ღირებულება (Value)

ლიტერალების ოთხი სახეობა არსებობს, ესენია:

• String ლიტერალი. სტრინგ ლიტერალი ყოველთვის მოთავსებულია ორმაგ აპოსტროფში („“) String s = “java, yava, banani”;
• Character (char) ლიტერალი. ჩარ ლიტერალი ყოველთვის მოთავსებულია აპოსტროფში (‘’) მხოლოდ ერთი ბგერით: char c = ‘j’, á’, ‘v’, á’;
• Boolean (boolean) ლიტერალი. მას ხოლოდ ორი ღირებულების ქონა შეუძლია, მცდარის ან მართალის (true or false).
• Numeric ლიტერალი. შეუძლია ნუმერაციული ღირებულებების ქონა, როგორიც არის  Integer(int) და Float (float)

4.ცვლადები (Variables). ცვლადები არის სახელები ღირებულებების, მაღლა განვიხილეთ ლიტერალები რაც ღირებულება არის ცვლადების, შესაბამისად ცვლადი არის სახელი ღირებულების.  Int data = 50: data ამ შემთხვევაში არის ცვლადი, სახელი 50-ის. მაგალითი ფოტოზე.

ჯავაში არსებობს სამი ძირითადი ტიპის ცვლადი, ესენია, ლოკალური ცვლადები (local variables) სტატიკური ცვლადები( static variables) და instance variables.

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

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

Static – არის ცვლადი რომელიც დეფინირებულია სიტყვა სტატიკურით, ის ვერ იქნება ლოკალური ცვლადი და მისი ღირებულება ყველა ინსტანცირებული ობიეკტებისთვის ერთია, უცვლელია, სიტყვა Static ჯავაში ძალიან ბევრს ნიშნავს, და მას ცალკე თავს დაუთმობთ. ამ ეტაპზე სტატიკურ ცვლადს რაც შეეხება და მთავარია ის არის რომ სტატიკური ცვლადი არის უცვლლელი ღირებულება, ყველა მეთოდისთვის, კონსტრუკტორისთვის თუ ობიეკტისთვის. Static double girebuleba = 2.5;

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

მაგალითი ცვლადების უკეთ აღქმისთვის;

5

 Data Types - ჯავაში არსებობს პრიმიტიული ღირებულების ტიპები და რეფერენციული ღირებულების ტიპები.  პრიმიტიული ტიპებია. (byte, short, int, long, char, double, float, Boolean). რეფერენციული ტიპებია, (object, string, arrays)

Primiteve data types - დანიშნულებაა შეინახოს ცვლადის სახელი და ზომა, ყველა ტიპს განსაზღვრული ზომის ინფორმაციის შენახვა შეუძლია.  როგორც ნახეთ 8 სახის პრიმიტიული ტიპი გვაქ მაღლა მოცემული. რომელიც თავის მხრივ იყოფა კატეგორიებზე,  (byte, short, int და long) არიან Integer ტიპის ოჯახიდან, მათ მხოლოდ სრული ციფრების შენახვა შეუძლიათ, მაგალითისთვის, 1, 2, 256, -789 და ა.შ (double და float) არიან Float ტიპის ოჯახიდან. მათ არასრული ციფრების შენახვა შეუძლიათ. მაგალითისთვის: 2,3.  7,8.  2,9F და ასე შემდეგ. Boolean-ს აქვს მხოლოდ 2 ღირებულება, ცრუ და მართალი (true or false). Char ინახავს ტექსტს რომელიც მოთავსებულია ბგერებად აპოსტროფში(‘’) და გააჩნია უნარი შეინახოს უნიკალური კოდური სიტყვები(unicode system რას ნიშნავს განვიხილავთ) დაბლა ფოტოზე ნახავთ რომელ ტიპს რამოდენა მეხსიერების რეზერვირება შეუძლია RAM მეხსიერებაში.

• Byte -  ინახავს 1 ბაიტ (8 ბიტ) ინფორმაციას (დიაპაზონი +127-ან, -128-ე)
• Short - ინახავს 2 ბაიტ (16 ბიტ) ინფორმაციას (დიაპაზონი +32,767-ან, -32,768-ე)
• Int - ინახავს 4 ბაიტ ( 32 ბიტ) ინფორმაციას ( დიაპაზონი +2,147,483,647-ან, -2,147,483,648 -ე)
• Long - ინახავს 8 ბაიტ (64 ბიტ) ინფორმაციას (დიაპაზონი + 9.22337E+18 -ან, -9.22337E+18-ე)
• Float - ინახავს 4 ბაიტ (32 ბიტ) ინფორმაციას (დიაპაზონი +3.40282347E+38F -ან, - 3.40282347E+38F-ე)
• Double - ინახავს 8 ბაიტ (64 ბიტ) ინფორმაციას (დიაპაზონი +1.79769313486231570E+308-ან, - 1.79769313486231570E+308-ე)
• Boolean - არ გააჩნია განსაზღვრული ზომა ინფორმაციის შენახვისთვის. მისი მოვალეობაა თქვას ესა თუ ის ოპერაცია მცდარია თუ მართალი. (true or false)
• Char - ინახავს 2 ბაიტ (16 ბიტ) ინფორმაციას ( დიაპაზონი 0-ან, 65535-ე)

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

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

Unicode system- რომელიც თავის მხრივ char ღირებულებაა,  არის საერთაშორისო სტანდარტის მქონე უნიკალური ღირებულებების მინიჭების უნარი ჩარზე. მისი შექმნის იდეა შემდეგში მდგომარეობს, ადრე ამა თუ იმ ენაზე წერის დროს ერთი ღირებულება მინიჭებული ჩარზე თუ იყო 1 ბაიტი, მეორე ენაზე იყო 2 ბაიტი, რაც გარკვეულ პრობლემებს იწვევდა კოდირების დროს. ამიტომაც ჯავამ შეიმუშავა ჩარ ტიპის ღირებულება რომელიც დღეისთვის ყველა ენაზე მოსაუბრე პროგრამისტებისთვის ერთია. მისი განსაზღვრული ზომა არის 2 ბაიტი. რამაც ბევრი პრობლემა გადაჭრა.  საწყისი ღირებულება u0000 (რაც 0-ია) და მაქსიმალური ღირებულება uFFFF(რაც 65535-ია) უნიკალური კოდური სისტემის გამოყენებამდე იყო მრავალი კოდური სტანდარტები ენებისთვის. მაგალითად ამერიკელები წერდნენ ASCII-ზე (American Standard code for information interchange). KOI-8 იყენებდნენ რუსები დ ა.შ

    ყველაზე გამოყენებადი ნუმერაციები რომლის შენახვაც ტიპებს შეუძლიათ, ესენია დეციმელური, ჰექსადეციმელური და ბინარული. კომპიუტერი მუშაობს ბინარულ სისტემაზე. გეცოდინებათ კიდეც, ნუმერაცია რომელიც მხოლოდ 0 და 1-ან შედგება (010100011001). კომპიუტერის მეხსირება მუშაობს ჰექსადეციმელური თვლით, რომელიც 16 სიმბოლოსგან შეგება.  რეალურ ცხოვრებაში,  პროგრამირების დროს დეციმელურის გარდა არამგონია რომელიმე სხვა სისტემა გამოიყენოთ მაგრამ მაინც განვიხილოთ.

Decimal - არის რიცხვების სისტემა რომელიც შედგება 10 ციფრისგან. 0-ან 9-დე. დეციმალური, ადამიანურ ენაზე ნუმერცარიული რიცხვების სისტემა ყველაზე გამოყენებადი სისტემაა პროგრამისტებში.

ტერნარი იმიტომ დავამატე სურათს რომ უფრო კარგად გაათვიცნობიეროთ როგორ ხდება ათვლა რიცხვების სისტემაში, დეციმალურ სკრინზე ყველაფერი ნათელია, მაგრამ ტერნარზე ალბათ ხედავთ რო რიცხვები ცოტა არ იყოს მიმოფანტულია. მიზეზი შემდეგია, ტერნარი მუშაობს სამ ციფრთან, ესენია 0,1,2, როდესაც 2-დე მიდის თვლა ათვლა იზრდება და იწყება ახლიდან, ამიტომაც მოყვება 10,11,12, რის შემდგომაც მოდის 20,21,22. 22-ის შემდეგ მოდის 100 როგორც ხედავთ, ეს იმიტომ რო 2 მაქსიმალური სიდიდის ციფრია ათვლით სისტემაში, მან საკუთარი თავი ამოწურა რის გამოც ათვლა გაგრძელდა ასეულებში. იგივე მოხდება თუ ასეულებში  მიხვალთ 222-დე. ათვლა გაგრძელდება 1000-ან. და ა.შ. ალბათ ხედავთ რაც უფრო პატარა თვლის სისტემა გვაქ მით უფრო დიდ ციფრებთან გვიწევს მუშაობა.

Hexadecimal – არის რიცხვების და ბგერების სისტემა რომელის დიაპაზონიც 16 უდრის. 0-9 დ A-F. მაგალითი: 0=0;1=1;2=2;3=3;4=4;5=5;6=6;7=7;8=8;9=9;10=A;11=B;12=C;13=D;14=E;15=F

ეს კიდევ ერთი გზაა ბიტებთან სამუშაოდ.  ჰექსადეციმელის პრეფიქსია 0x. მაგალითად: 0x100 ბაიტებში იგივეა რაც 256. 0x1a = 26 და ასე შემდეგ,

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

Binary - არის რიცხვების სისტემა. რომლის დიაპაზონიც 2 უდრის. ის მხოლოდ ორ ციფრს იყენებს, 0 და 1. მისი პრეფიქსია 0b. მაგალითად 0b0101 = 5, 0b0100 = 4.

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

ფოტოზე ნახავთ თვლის მაგალითებს:

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

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

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

Place holder	10 000	1000	100	10	1
Power	10^4	10 ^3	10 ^2	10 ^1	10 ^0
Digit’s	6	7	5	4	2

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

უფრო კარგად რო გავერკვეთ მოვახდინოთ Hexadecimal 2CD7 ალფანუმერაციის კონვერტირება decimal-ში

Place Value	4096	256	16	1
Power	16^3	16^2	16^1	16^0
Digit’s	2	C	D	7

Hexadecimal 2CD7 Base-16

• ციფრი = 2 * 16^3 + C * 16^2 + D * 16^1 +7 * 16^0
• ციფრი =  2 * 4096 + 12 * 256 + 13 * 16 + 7 *1
• ციფრი = 8,192 + 3,072 + 208 + 7
• ციფრი = 11,479

Hexadecimal 2CD7 = Decimal 11.479.

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

Value	16	8	4	2	1
Power	2^4	2^3	2^2	2^1	2^0
Digit’s	1	0	1	1	0

Binary 10110 Base 2

• ციფრი =  0 * 2^0  + 1 * 2^1 + 1 * 2^2 + 0 *2^3 + 1 * 2 ^4
• ციფრი =  0 + 2 + 4 + 0 + 16
• ციფრი = 22;

Binary 10110 = Decimal 22;

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

Value	256	128	64	32	16	8	4	2	1
Power	2^8	2^7	2^6	2^5	2^4	2^3	2^2	2^1	2^0
Digit’s		1	0	0	0	1	0	1	0

Decimal 138 Base 10 To Binary Base 2

• ციფრი = 138
• ციფრი = 138 – 128 = 10
• ციფრი = 10 – 8 = 2
• ციფრი = 2-2 = 1

138-ში დაფაზე რომელი მაღალი  ციფრი შევა თავისუფლად?  როგორც ჩანს 128, ამიტომ დავიწყებთ პოზიციონირებას 128-ან.  პოზიცია რომელსაც ციფრი იტევს უნდა ჩავრთოთ, ანუ მივაწეროთ 1.  პოზიცია რომელიც ციფრს ვერ დაიტევს ავტომატურად გახდება 0. სხვანაირად ამ ოპერაციას ჩამრთველებს ეძახიან, 1 რთავს ციფრს 0 თიშავს.  138-მა დაიტია 128, დაგვრჩა 10, 10 რომელ მაღალ ციფრს დაიტევს თავისუფლად,  როგორჩ ჩანს 8-ს, რის შემდგომაც გვრჩება 2.  2 დაიტევს 2-ს და ამით მორჩება ჩვენი ძიება.  ციფრები რომლებიც არ მოხვდნენ ტევადობაში ვთიშავთ.

შედეგი:  Decimal 138 = Binary 10001010

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

Value	8	4	2	1	8	4	2	1	8	4	2	1	8	4	2	1
Power	2^3	2^2	2^1	2^0	2^3	2^2	2^1	2^0	2^3	2^2	2^1	2^0	2^3	2^2	2^1	2^0
Base 2	1	1	1	0	1	1	0	1	1	0	0	0	0	1	0	1
Digit’s		E				D					8			5

გვაქ ჰექს ციფრი ED85 რომლის კონვერტირებაც გვინდა ბინარულ ციფრად. დაფა არის ჰექადეციმელური, 16 ფანჯრისგან, მაგრამ მარტივად გარკვევისთვის გავყავი 4-ზე. პრინციპი ერთია უბრალოდ ასე უკეთესად ჩანს.  რომ გავიგოთ ბინარული შედეგი ჰექსის მოვახდინეთ ჰექს ციფრის პოზოციონირება გრაფებში. E გვახსოვს რო ჰექსში არის 14, E  გრაფაში, 14 მოგვცემს 8, 4 და 2. (8+4+2) ამითომ ამ ციფრებს ვრთავთ და დაბლა ვუწერთ 1-ს.  D ჰექსში არის 13, 13-ს მოგვცემს 8,4 და 1 (8+4+1=13), ვრთავთ ამ ციფრებსაც,  8-ს გვაძლევს 8. ამიტომ ვრთავთ 8-ს და დანარჩენს 3 ციფრს ვთიშავთ, 5-ს გვაძლევს 4 და 1.

შედეგად Hexadecimal base 16 ED85 = Binary base 2 1110110110000101

ED85 = 1110110110000101 = 60805

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

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

 პრიმიტიულ ტიპებზე ინფორმაცია Stack მეხსიერებაში ინახება.

Referance data types - არის ტიპი რომელიც ღირებულებაზე მიმნიშნებელია, ის არ ინახავს ღირებულებას როგორც პრიმიტიული ტიპი, პროგრამირების ენაში მას მიმთითებლებს უწოდებენ. რეფერენციული ტიპებია String, Object, Arrays და ა.შ  ის მიგვითითებს და გვეუბნება თუ სად არის შენახული ინფორმაცია მეხსიერებაში. Reference data type იყენებს Heap მექსიერებას. ძირითადი სხვაობა პრიმიტიულ ტიპსა და რეფერენციულ ტიპს შორის არის ის რომ პრიმიტიულ ტიპს ყოველთვის გააცნია ღირებულება. By default მისი ღირებულება უდრის 0-ს. დიახ 0 ღირებულებაა. მაგრამ რეფერენციულ ტიპს შეუძლია საერთოდ არ ექნეს ღირებულება, ის უბრალოდ ცარიელია და მისი default ღირებულება არის Null. დაიმახსოვრეთ ნული(0) და Null არ არის ერთი და იგივე, 0 ღირებულებაა Null კი ცარიელი ადგილია, ყველანაირი ღირებულების გარეშე. NULL IS ABSENCE OF VALUE!!! პროგრამირების დროს თუ დაგავიწყდათ პრიმიტიულ ტიპზე ღირებულების მინიჭება პროგრამა მაინც იმუშავებს, მაგრამ თუ დაგავიწყდათ რეფერენციულ ტიპზე ღირებულების მინიჭება პროგრამა შეწყვეტს მუშაობას და გიჩვენებთ Error-ს რომლის სახელწოდებაც არის NullPointerException. ერორების სახეობებს მოგვიანებით განვიხილავთ.

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

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

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

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

• Double –double;
• Short – short;
• Long – long;
• Integer – int;
• Float – float;
• Byte – byte;
• Char – char;
• Boolean – boolean;

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

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

Constant -  არის ღირებულება რომელიც უცვლელია. მისი ღიღებულება არ იცვლება, არ აგერიოთ Static საკვანძო სიტყვაში, სტატიკური ღირებულება ერთია ყველასთვის, კონსტანტური ღირებულება უცვლელია ყველასთვის.  უფრო დეტალურად განვიხილოთ. კონვენციის მიხედვით კონსტანტური ღირებულების დეკლალირება ხდება ALL_UPPER_CASE სიტყვებით, სადაც სიტყვები ერთმანეთისგან გამოყოფილია ქვედა ტირით.  რომ მოვახდინოთ კონსტანტის დეკლალირება უნდა გამოვიყენოთ საკვანძო სიტყვა (მოდიფიკატორი) final. მაგალითად წარმოიდგინეთ წერთ თამაშს, რომელსაც აქვს რეზოლუცია ეკრანის, ეკრანის რეზოლუცია გინდათ რო იყოს უცვლელი, ამისთვის წერთ ვერტიკალი უდრი 1200 და დიაგონალი უდროს 2000, ყველა ეკრანზე რომელზეც არ უნდა ჩაირთოს თქვენი თამაში ვერტიკალი და დიაგონალი უცვლელი იქნება. ვთქვათ თამაში არის Shooter სადაც ერთ მისიაში 10 მტერი გყავთ. რომლის ლიკვიდაციაც უნდა მაოხდინოთ. მარტივად და უფრო წაკითხვადად რო დაწეროთ მსგავსი კოდი იყენებთ კონსტანტებს. Final  Int MISSION_ENEMY = 10; რაც ნიშნავს რო ამ მისიაში იქნება 10 მოწინააღმდეგე და რაც არ უნდა მოხდეს ეს ციფრი არ შეიცვლება. უფრო რო დავხვეწოთ კოდი უკეთესი იქნება თუ დავწერთ შემდეგნაირად, static final int MISSION_ENEMY=10; ალბათ გაგიჩდათ კითხვა რატო გამოვიყენეთ სტატიკური უცვლელი ღირებულება ყველა ინსტანცირებული ობიეკტისთვის, ისედაც უცვლელ ღირებულება კონსტანტთან. სწორედ აქ მიხვდებით რა სხვაობაა static მოდიფიკატორ და final(contstant) მოდიფიკატორს შორის, როდესაც ვქმნით კლას, თამაშს, სადაც გვაქ კონსტანტური დიაგონალი, ვერტიკალი და მისიაში მტერის ოდენობა, რამდენჯერაც არ უნდა შევქმნათ ამ კლასიდან რეფერენციული ობიეკტი იმდენ კოპირებას მოვახდენთ მეხსიერებაში ინფორმაციის. ვთქვათ, ვიყენებთ class Games, საიდანაც ვქმნით ობიეკტს, რამოდენიმე ხნის შემდეგ გაგვახსენდა რო ამ კლასიდან შეგვიძლია მეორე მისიის შექმნა, მესამე მისიის შექმნა სადაც მტერის რაოდენობა ყველგან 10 უდრის, რამდენჯერაც შევქმნით ობიეკტს კლასიდან იმდენჯერ შეიქმნება მეხსიერებაში ადგილი ერთი და იგივე ღირებულებით. რაც მეხსიერების უაზროდ გაფლანგვაა, ამიტომაც ვწერთ Static მოდიფიკატორს რო ეს უაზრო ფლანგვა ავირიდოთ თავიდან და მეხსიერებაში შევქმნათ ზუსტად ერთი ცვლადი რომელსაც გამოიყენებს ყველა ინსტანცირებული ობიეკტი უცვლელად, და არა 100 ცვლადი რომესაც ერთი ღირებულება ექნება. სწორედ ეს არის სხვაობა. სტატიკური ცვლადი ერთია ყველასთვის. ფინალური ცვლადი ახდენს კლონირებას და მას აქვს უცვლელი ღირებულება. კონსტანტ არის ცვლადი(variable) რომლის ღირებულებაც არ იცვლება.  მაგალითი სკრინიზე.

განვიხილეთ ტიპები. ასე თუ ისე წარმოდგენა შეგვექმნა რასთან გვაქ საქმე. დროა განვიხოლოთ რას ნიშნავს Strongly typed vs Weakly typed  და implicitly typed vs explicitly typed. ჯავა არის Strongly typed პროგრამირების ენა. (გახსოვთ ალბათ რო ის აგრეთვე სტატიკურად ტიპიზირებულია), რას ნიშნავს Strongly typed, წარმოიდგინეთ გვაქ სხვა და სხვა ცვლადის ტიპები, რომლებსაც სხვა და სხვა ღირებულების შენახვა შეუძლია, შესაბამისად Strongly typed ენაში ერთი ღირებულებას მეორეს ვეღარ მიუმატებთ ან/და ვერ მიანიჭებთ,  ვერ გამოაკლებთ იმიტომ რო კომპილატორი ამის უფლებას არ მოგცემთ. რაც ლოგიკურია, დათოს + 10 რას უნდა უდრიდეს, დათოს თუ 10-ს? ან დათო როგორ უნდა გადაიქცეს ციფრად და ციფრი დათოდ? ამის შესაძლებლობები არსებობს მაგრამ არა პირდაპირ არამედ მკაფიო განმარტებით და მითითებით რო დათო გახდება ციფრი ამა და ამ მიზეზის გამო. სწორად ამას ნიშნავს Strongly typed, ჯავა არის დღევანდელი მონაცემებით ყველაზე Strongly typed პროგრამირების ენა.  თუ დავფიქრდებით Strongly typed აგრეთვე გვეხმარება გადამოწმებაში მოხდა თუ არა ცვლადბის ტიპიზირება. ანუ სტატიკურად სწორად დავწერეთ კოდი თუ გაგვეპარა რამე.  Strongly typed პროგრამირების ენა გვაძლევს საშუალებას  თავიდან ავირიდოთ შეუთავსებელ ტიპებს შორის ოპერაციების წარმოება.  განვიხილოთ მაგალითებზე;

Error msg;

მოცემულ პროგრამაში სამი შეცდომა გვაქ.  1. მოვახდინეთ ცვლადზე ღირებულების მინიჭება ტიპიზირების გარეშე. მესიჯი გვეუბნება რო ტიპიზირება არ მოხდა 8-10 ველზე.  დაგვავიწყდა რო ჯავა არის სტატიკურად ტიპიზირებული. შედეგი, პროგრამამ მუშაობა შეწყვიტა. 2. ინტ ტიპს მივანიჭეთ დაბლ ღირებულება. შესაბამისად პროგრამა გვეუბნება , დაგავიწყდათ სწორად ტიპიზირება ან კონვერტირებაო. 3. მოავხდინეთ 2 ტიპის შექმნა, რომლის ღიებულებების შეკრებაც გადავწყვიტეთ.  შესაბამისად გვაქ მესამე ერორ მესიჯი რომელიც გვეუბნება, შეუთავსებელი ტიპები, სტირნგი ვერ გახდება დაბლ ღირებულება, სწორედ ამას ნიშნავს Strong typing.

ალბათ შეამჩნიეთ რო მეორე ერორ მესიჯზე და მესამე ერორ მესიჯზე სხვა და სხვა ტონალობაა. ერთზე გვეუბნება რო შესაძლებელია დაგავიწყდათ ან არ მაოხერხეთ და მესამეზე მკაფიოდ და მკაცრად გვეუბნება რომ მსგავსი ოპერაცია შეუძლებელია.  სწორედ მეორე მესიჯის აზრი მდგომარეობას implicitly vs explicitly typing-ში.  Implicitly typing ნიშნავს ერთი ტიპის მეორე ტიპად კონვერტირებას ავტომატურ რეჟიმში.  explicitly typing ნიშნავს ერთი ტიპის ხელოვნურად კონვერტირებას მეორე ტიპად. პროგრამისტები ამ ოპერაციას (casting)-ს ეძახიან.  რატომ ხელოვნურად და არა ავტომატურ რეჟიმში, ალბათ გახსოვთ რო ყველა ტიპს აქვს განსაზღვრული მეხსიერება, int არის 4 ბაიტი, double არის 8 ბაიტი და ა.შ.  double საკმაოდ დიდია იმისთვის რო int ღირებულება შეინახოს ყველანაირი დახმარების გარეშე, მაგრამ თუ მოვიქცევით პირიქით საკმაოდ დიდია იმისთვის რო int ღირებულებაში შევიდეს. ანუ 4 ბაიტით დიდია, სწორედ ამ დროს ვახდენთ (casting)-ს და ვტენით ინფორმაციას შიგნით, რის შედეგადაც ხდება ინფორმაციის დაკარგვა. მაგალითად: double = 400,689 და გვინდა მისი კონვერტირება int ღირებულებად, კონვერტირების შემდეგ ის დაკარგვას 689 და გახდება int = 400; იმიტომ რო ინტმა მოიცილა ის ინფორმაცია რომელსაც ვერ იტევდა.  განვიხილოთ მაგალითზე;

შედეგად Float-მა მარტივად მიიღო ინტ ღირებულება. 8 გახდა 8.0. მაგრამ Casting-ის შემდგომ double-მა დაკარგა ღირებულება და 12.789 გახდა 12.

6. ბლოკები (blocks)

ა. {} ფრჩხილები (curly braces)

ბ. [] კვადრატული ფრჩხილები (square brackets)

გ. () ოვალური ფრჩხილები (parentheses)

დ. <> ეგრეთ წოდებული მეტობა-ნაკლებობის ნიშანი. (angle brackets)

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

Square brackets[] - დანიშნულება არის მიიღოს დიდი რაოდენობის ციფრები ან სიტყვები,  რომელსაც გააჩნია ინდექსები. მას ძირითადად Array-ს შექმნის დროს იყენებთ.

Parantheses()- მას ძალიან დიდი და მოცულობითი დანიშნულება აქვს პროგრამირებაში.  ის გვიჩვენებს პარამეტრების საწყის და დასასრულს,(მაგ: String[]args-არგს არის პარამეტრი მეთოდის) გამოიყენება ყველა მეთოდთან, კონსტრუკტორთან, ინსტანცირებულ მეთოდთან პარამეტრებით ან პარამეტრების გარეშე. პარამეტრი გვეუბნება რა ოპერაციას შეასრულებს მეთოდი თუ კონსტრუკტორი, (კონსტრუკტორიც თავის მხრივ მეთოდია).  ყველაზე ადვილად რო გაიგოთ რასთან გვაქ საქმე, როცა ხედავთ () ანუ ვმუშაობთ მეთოდთან, ინორმაციით ან ინფორმაციის გარეშე.

Angle brackets<>- როცა ის არ ასრულებს მეტობა-ნაკლებობის ფუნქციას და ვიყენებთ როგორც ერთ ფუნქციას გვეძლევა საშუალება მოვახდინოთ ინფორმაციის კოლექცირება, მაგალითად <> შეგვიძლია ჩავსვათ ინტ ღირებულება რომელსაც თავის მხრივ აქვს უსასრულო ღირებულება ან განსაზღვრული ღირებულება,  ძალიან მოქნილი და გამოსადეგია დიდი ნაწილი კოდის გადავსვათ <> და კოდი უფრო წაკითხვადი გავხადოთ. უკეთ გაერკვევით როცა, list, ArrayList, Generis, Maps, HashMap და სხვა მრავალ გამოსადეგ ინფორმაციამდე მივალთ.

7. კომენტარები.  

ჯავაში არსებობს სამი სახის კომენტარი, ესენია:

• // - ვიყენებთ ერთ ველზე ინფორმაციის დასამალად. მაგალითად:
• // es aris informacia romelsac kompilatori ver naxavs, is damalulia.
• /* .... */ - ვიყენებთ მრავალ ველზე ინფორმაციის დასამალად. მაგალითად:
• /*  es veli damaluli iqneba manam sanam ar gamoviyenebt momavalshi, dagvchirdeba programirebis dasrulebis dros, an xels gvishlis am etapze. Shemdegi moqmedebebis dros gamoviyenebt an ar gamoviyenebt, kompilatori mas mainc ver xedavs da kodi ar ziandeba*/
• /** ……*/ დოკუმენტური კომენტარი, (doc comment). კომპილატორი ახდენს მის იგნორირებას ისევე როგორც მისი წინა მორბედების იგნორირება ხდება, მაგრამ მას კითხულობს JDK უფრო კონკრეტულად javadoc.  წაკითხვის შემდგომ JDK იცის რა სახის ოპერაციასთან აქვს საქმე.

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

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

                                                              Stack   Vs Heap

Stack- მეხსიერება. 

1.LIFO(Last in first out).

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

3.აქვს განსაზღვრული ზომა.

4.მეხსიერების მართვა ხდება OS(Operation System)-ან

5. არის სწრაფი

6. არ არი აუცილებელი ხელოვნურად გაანთავისუფლოთ ადგილი ცვლადისთვის.

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

8. არ ახდენს მეხსიერების ფრაგმენტირებას

9. Variables can not be resized

Heap- მეხსირება.

1.არ აქვს განსაზღვრული ზომა

2.მეხსიერების მართვა ხდება GC(Garbage Collection)-ან

3.არის ნელი

4.Errors and Memory Leaks problem

5. ცვლადები ხელმისაწვდომია გლობალურად. მას ყველა ხედავს.

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

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

8. Variables can  be resized

როგორ მუშაობს მეხსიერება, ნებისმიერი პროგრამისტის განკარგულებაშია ორი მეხსიერება, სტაკი და ჰიპი, სტაკი მარტიავდ რომ ვთქვათ არის თქვენი პირადი მეხსიერება მას ვერავინ ხედავს, სადაც ახდენს ცვლადების და მეთოდების შენახვას, საიდანაც ხდება ობიეკტების შექმნა რომელიც ინახება ჰიპ მეხსიერებაში. საინტერესოა როგორი თამნიმდევრობით ხდება სტაკ მეხსიერების გამოყენება. ის ავტომატურად მართავს საკუთარ თავს. და აქვს იერარხია ინფორმაციის მიღების და მოშორების. წარმოიდგინეთ გაქვთ რამოდნეიმე მეთოდი , თავისი ლოკალური ცვლადებით. მეთოდი1(), მეთოდი2(), მეთოდი3(პარამეტრით), ცვლადი, ინფორმაცია სტაკ მეხსიერებაში შედის, LIFO პრინციპით და როცა მისი გამოყენება სრულდება ავტომატურად ხდება ადგილის გამონთავისუფლება სადაც ახალი ცვლადი ან მეთოდი იკავებს ადგილს. თუ მუშაობთ დიდი ზომის პროგრამასთან და შეგექმნათ მეხსიერების პრობლემა მაშინ ეკრანზე გამოვა ერორ მესიჯი java.Lang.StackOverFlowError.

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

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

ყველაფერი ინახება სტაკში, მეთოდები, პარამეტრები, ლოკალური ცვლადები, ჰიპში ინახება მხოლოდ ობიეკტი, სტაკ ინახავს მიმთითებელს ჰიპ მეხსიერებაში შენახული ობიეკტისთვის. რა თანმიმდევრობით ხდება სტაკში ინფორმაციის შენახვა. Last In First Out. თუ რას ნიშნავს ეს მოგვიანებით უფრო კარგად გავარკვევთ. საწყისისთვის რაც მნიშვნელოვანია მოცემულია სკრინზე. როდესაც აღარ ხდება მეთოდის გამოყენება მის მიერ რეზერვირებული ადგილი მეხსირებაში თავისუფლდება და მის ადგილს ახალი მეთოდი იკავებს. როდესაც ვახდენთ მეთოდის წაშლას საიდანაც ობიეკტი შევქმენით, ამ სიტუაციაში A4-ის. ჰიპ მეხსირებაში რჩება ობიეკტი რის გაანდგირებასაც შემდგომ GC ახდენს. ნებისმიერი ობიეკტი რომელსაც არ აქვს კავშირი მეთოდთან ხვდება GC-ის შავ სიაში, კვდება.

    Garbage Collection(GC)- ემსახურება მეხსიერებას და მართავს მას ავტომატურ რეჟიმში,  მას აქვს შემდეგი პლიუსები:

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

ბ). მართავს ობიეკტებს.

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

დ). ოპტიმალურად ახდენს Heap მეხსიერების გამოყენებას.

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

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