ოპერატორები

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

• Unary -  ასრულებს ერთ ოპერაციას ოპერანდზე: +. - , * და ა.შ
• Binary - ასრულებს ოპერაციას(მანიპულირებს) 2 ოპერანდს შორის და გვიბრუნებს შედეგს.
• Ternary - ასრულებს სამ ოპერაციას ოპერანდზე.

ოპერაციები თავის მხრივ კატეგორიებზე იყოფა, ესენია :

• არითმეტიკული : - + * / % ++ --
• ლოგიკური : && ||  !
• Bitwise  : & | ^ ~ << >> >>>
• შედარებისთვის :  == != > < >= <=
• მითვისებისთვის : = += -= *= /= %= &= |= ^= <<= >>= >>>=
• ტიპეპთან მუშაობისთვის : (type) instanceof
• Ternary : ? :

სხვაობა ოპერაციებს შორის არის ის რომ არითმეტიკული ოპერაციები მუშაობს ციფრებთან, ბინარული, იგივე Bitwise ოპერატორები მუშაობს ბიტებთან და ტერნარი გვიბრუნებს Boolean (true or false) შედეგს.  ლოგიკური ოპერაციაც Boolean კატეგორიიდან არის,  ფოტო არის ჯავას ოპიციალური ვებგვერდიდან, ყველა ოპერაციას გავივლით თანმიმდევრობით.

დავიწყოთ არითმეტიკულით, + - / * % ++ -- (Unary)

შედეგი;

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

ხედავთ სხვაობას, ++ -- ნიშნების  ცვლადის წინ და უკან დასმის შედეგად როგორ ხდება ოპერაციის წარმოება. შედეგი:

ლოგიკური : && ||  !

• && - Logical AND (Binary)
• || = Logical OR (binary)
• ! = Logical NOT (Unary)

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

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

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

განვიხილოთ ამ სამი ოპერაციის მოქმედება მაგალითებზე:

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

 

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

 შედეგი:

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

ფოტოზე პროგრამა იგივეა, ოპერატორი ითხოვს ორივე ოპერანდის მართებულობას ნებართვისთვის. მაგრამ პირველ ოპერანდზე ვუთითებთ, რომ ბიჭი არ არის აუცილებელი იყოს > 18-ზე.  ანუ ვუარყოფთ რომ ის 15 წლის არის და სინამდვილეში არის < 18-ზე.

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

შედეგი:

რაგდან ყველა ოპერაცია მცდარია.

Bitwise  : & | ^ ~ << >> >>>

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

• & - Bitwise AND
• | - Bitwise OR (inclusive OR)
• ^ - XOR (Exclusive Or)
• ~- Bitwise Compliment (Unary)
• << - Left Shift
• >> -  Right Shift
• >>> - Zero Fill Right Shift

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

ბიტური ოპერაციები რომ აწარმოოთ უნდა ვიცოდეთ ერთი ძირითადი წესი,  კომპიუტერი კითხულობს მთლიან რეგისტრს და არა კონკრეტულ ნაწილს, ვიცით რომ ყველაზე დიდი რეგისტრებია 32 ბიტი და 64 ბიტი, შესაბამისად ბიტურ ოპერაციას ვერ ვაწარმოებს byte, short და სხვა პატარა ზომის ტიპებთან (Casting)-ის გარეშე,  ბიტური ოპერაციის წამროებისთვის მიზანშეწონილუა ვიმუშაოთ int(32bit) და long(64bit) ტიპებთან,  მაგალითისთვის რომ ავიღოთ ნებისმიერი ციფრი რომელსაც თავისი წარმომადგენლობა აქვს ბიტებში და შევაბრუნოთ ~ ოპერატორით, შეიძლება მივიღოთ ისეთი სიდიდის ციფრი რომელსაც ვერც ერთი ტიპი ვერ დაიტევს და კომპილატორი პროგრამას არ გაუშვებს,  მსგავსი პრიმიტიული პრობლემა რომ ავირიდოთ თავიდან და მთელი კვირა არ ვიფიქროთ რატომ არ სრულდება ესა თუ ის ოპერაცია ჯობია პირდაპირ დიდი ზომის ტიპებთან ვიმუშაოთ.  მოკლედ რომ ვთქვათ, მოსაწყენ, მომაბეზრებელ, დამღლელ და უაზრო ინფორმაციასთან გვაქ საქმე რომლის ცოდნითაც უამრავ პრობლემას ავირიდებთ თავიდან.

მაშ ასე:

& - Bitwise AND ოპერატორი ასრულებს ოპერაციას ორ ოპერატორს შორის და გვიბრუნებს 1-ს თუ ორივე ოპერატორი შეიცავს 1-ს სხვა დანარჩენ შემთხვევაში გვიბრუნებს 0-ს. (იმედია გახსოვთ რო ბიტური ოპერაციები მხოლოდ 0 და 1-ან შედგება.) განსხვავებით ლოგიკური &&(AND)-ან  ის ამოწმებს ორივე ოპერანდს ბოლომდე. ლოგიკური (და) კითხულობს მხოლოდ მარჯვენა ოპერატორს და თუ ის მცდარია წყვეტს მუშაობას, მაგალითად, int age>20 && weight <70, პროგრამის მოთხოვნა არის რომ ასაკი იყოს 15 წლიდან, ამ შემთხვევაში ასაკი 20 უკვე მცდარია, შესაბამისად მუშაობა შეწყდა და გააგრძელა სხვა მეთოდის კითხვა,,  ბიტურ (და)-ში კითხულობს ოპერანდის ორივე მხარეს და გვიბრუნებს შედეგს, მიუხედავად იმისა შედეგი რა იქნება. სხვანაირად წარმოუდგენელიც კი არის ბიტური ოპერაციის წარმოება,  თუ ერთი ციფრის ბიტური წარმომადგენლობა ვიცით შესაბამისად მეორესიც უნდა ვიცოდეთ რო შევადაროთ ერთმანეთს. რაც მთავარია ერთი და იგივე ოპერაციაზე ორი მსგავი ოპერატორის გამოყენების დროს (ლოგიკური (და) ბიტური (და)) სხვა და სხვა შედეგებს ვიღებთ. ლოგიკურ (და)ს პროგრამისტები ზარმაც (და)-ს ეძახიან და ცდილობენ ნაკლებად გამოიყენონ, პრინციპში გააჩნია რა ოპერაციასთან გვაქვს საქმე, ლოგიკური (და) უფრო Boolean შედეგის მიღებისთვის გამოიყენება.  მაგრამ ბულიან შედეგის მისაღებად ბიტური (და) რომ გამოვიყენოთ მივიღებთ მსგავს შედეგს, 2 & 4 = 0/false როდესაც 2 && 4 = 1 / true.

| - Bitwise OR (inclusive OR)  ასრულებს ოპერაციას ორ ოპერანდს შორის და გვიბრუნებს დადებით შედეგს თუ რომელიმე მხარე შეიცავს დადებით ციფრს (ჩვენ შემტხვევაში 1-ს) 1100 | 1001 = 1101, სხვაობა ლოგიკურ (ან) და ბიტურ (ან)-ს შორის ზუსტად იგივეა რაც (და)-ს შორის, ის მუშაობს ორივე ოპერატორთან და არ ასრულებს მხოლოდ მარჯვენა ოპერაციას.  ლოგიკურში ან ერთი უნდა იყოს მართალი ან მეორე რომ ოპერაცია შესრულდეს, ბიტურში არ აქვს მნიშვნელობა სწორია თუ მცდარი, ოპერაცია ყველა ვარიანტში სრულდება.

^ - XOR (Exclusive Or) რატომღაც ეს ოპერატორი ყველაზე რთულად აღქმადია პროგრამისტებში და ძალიან დიდი რაოდენობა დამწყები პროგრამისტების გასაუბრებებზე სწორედ ამ ოპერატორთან დაკავშირებით დასმულ შეკითხვებზე იჭრება, შევეცდები მარტივად აგიხსნათ რას აკეთებს ექსკლუზიური(ან). ის გვიბრუნებს დადებით შედეგს მხოლოდ მაშინ როცა ოპერანდის ერთი მხარე მცდარია და მეორე დადებითი, სხვა ყველა დნარჩენ შეთხვევაში ის გვიბრუნებს უარყოფით შედეგს, უკეთესად რომ წარმოვიდგინოთ, 10110^11000= 01110. ანუ რა მოხდა სადაც დადებითი შედეგები გვქონდა შეიცვალა უარყოფითით, 1 და 1 გახდა 0, შემდგომ 0 და 1 გახდა 1, განმეოდა 0 და 1 , ბოლო 0 და 0 გვიბრუნებს მცდარ შედეგს.  მარტივად რომ დაიმახსოვროთ, დადებითი და უაროფითი შედეგები გვიბრუნებს უარყოფით შედეგს, ცალკე მდგარი დადებითი და უარყოფითი შედეგები გვიბრუნებს დადებით შედეგს.

~- Bitwise Compliment (Unary) მსგავსად სხვა დანარჩენი სამი ოპერატორისა ისიც ასრულებს ოპერაციას ოღონდ განსხვავებით მისი წინამორბედებისა ის არის (Unary) რაც ნიშნავს ერთ ოპერაციას ერთ ოპერანდზე. მისი ძირითადი დანიშნულებაა მოახდინოს რევერსირება ციფრების. მაგალითისთვის თუ გვაქ ციფრი 00000000 და ვახდენთ მის რევერსიებას ~00000000 შედეგად მივიღებთ 11111111-ს ყველა 0-ის ადგილზე გვექნება 1 და ყველა 1-ის ადგილზე გვექნება 0.(უბრალოდ მაგალითისთვის, როგორც ესეთი მოცემულობა მცდარია) უფრო კარგად რომ წარმოიდგინოთ მთლიანი ბიტური რეგისტრის დაფა უნდა შევქმნათ სადაც 32 ბიტის ნახვა იქნება შესაძლებელი.

1	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	1
-2	1	1	1	1	1	1	1	1	1	1	1	1	1	1	1	1	1	1	1	1	1	1	1	1	1	1	1	1	1	1	1	0

32 ბიტი ვერ ექცევა  ჩარჩოებში წესიერად, სამწუხაროდ.

ასე გამოიყურება მთლიანი დაფა შებრუნების შემდეგ,  დეტალურად არ განვიხილავთ, იმიტომ რო საკმაოდ მოცულობითი ინფორმაციაა, მარტივად მიუდგებით, წარმოიდგინეთ გაქვთ ცვლადი y რომლის შებრუნება გინდათ, შესაბამისად ვწერთ ~y და y რა ღირებულებაც ექნება მაგას -1 უნდა ვიანგარიშოთ. მაგალითისთვის, თუ y არის 10, შებრუნების შემდეგ იქნება, -11, ფორმულა: (-y)-1, ჩვენ შემთხვევაში (-10)-1 რაც უდრის -11. 10-ის კომპლიმენტი გამოდის -11. რა ხდება როცა უარყოფით ციფრს ვაბრუნებთ? ფორმულა იგივეა, ~-10 = დადებით 10 და შემდგომ -1, შედეგი იქნება 9. თუ რატომ ხდება ეს ასე გაერკვიეთ ინტერნეტში, (one’s complement, two’s complement, signed and unsigned numbers, UTF-16) საკმაოდ დიდი  ინფორმაციაა, ცნობისთვის ჯავა იყენებს მხოლოდ signed ციფრებს, Char ტიპის გამოკლებით, Char არის unsigned ციფრი.  ჩემი აზრით ტყუილა დაკარგავთ დროს მსგავსი ინფორმაციის ათვისებაში. მარტივია ფორმულის დამახსოვრება, (-y)-1.

<< - Left Shift ეს ოპერატორი  ახდენს ბიტის ჩაწევას მარცხნივ, იმდენი ნაბიჯით რამდენითაც გსურთ, მაგალითისთვის,  40 << 1, მოახდენს 40-ის 1 ბიტით მარცხნივ ჩაწევას, რაც გარკვეულ შედეგს მოგვცემს.  ეს შედეგი კი იქნება 80, ნებისმიერი ციფრო რომელსაც ვწევთ მარცხნივ მრავლდება 2ზე. დაფაზე ნახავთ მაგალითს.

<<	64	32	16	8	4	2	1
40	0	1	0	1	0	0	0
80	1	0	1	0	0	0	0

როგორც ხედავთ მოვახდინეთ ბიტების მარცხნივ ჩაწევა ერთი ნაბიჯით, რამაც მიგვიყვანა გარკვეულ შედგამდე, 32 ადგილზე მყოფმა 1-მა გადაინაცვლა 64-ზე და 8-ის ადგილზე მყოფმა გადაინაცვლა 16ის ადგილზე.  ეს გაკრვევისთვის, ისე კი ნებისმეირი ბიტის 1 ნაბიჯით მარცხნივ ჩაწევა ნიშნავს 2-ზე გამრავლებას, 16<<1 იქნება 32 და ა.შ

ერთი ბიტით მარცხნივ ჩაწევა:  = 2 =2^1=2*40=80

ორი ბიტით მარცხნივ ჩაწევა: = 2*2 = 2^2=4*40=160

40<<2 იქნება 160.  3 იქნება 320 და ა.შ

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

>> -  Right Shift ახდენს ბიტების მარჯვნივ ჩაწევას იმდენი ბიტით რამდნეითაც გსურთ, განვიხილოთ იგივე მაგალითი, 40>>1

>>	64	32	16	8	4	2	1
40	0	1	0	1	0	0	0
20	0	0	1	0	1	0	0

 ალბათ მიხვდით , მარჯვნივ ჩაწევა ნიშნავს ციფრის 2-ზე გაყოფას, 40>>1= 20: ნებისმიერი ციფრო რომელსაც ჩაწევთ 1-ით მარჯვნივ გაიყოფა ორზე, 20>>1= 10: და ა.შ.

სამი ბიტით მარჯვნივ: 40>>3 =  2*2*2=2^3=40/8=5;

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

4 ბიტით მარჯვნივ: 40>>4 = 2*2*2*2=2^4=40/16=2(2.5)

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

>>> - Zero Fill Right Shift ახდენს ბიტების მარჯვნივ ჩაწევას ზუსტად იგივე პრონციპით როგორც >> მაგრამ მისგან განსხვავებით მას აქვს ერთი უნიკალური თვისება, იცილებს ბიტს და მის ადგილს ავსებს ახალი ბიტით, ახალი ბიტი ყოველთვის არის 0. მაგალითისთვის,  00001101 თუ ჩავწევთ მარჯვნივ ერთი ნაბიჯით, 00001101>>>1 შედეგი იქნება 00000110

თუ დააკვირდებით მარჯვენა ბოლოში 1 გაქრა და მისი ადგილი დაიკავა მარცხენა ბოლოში ახალმა ციფრმა(0-მა)  წარმოდგენა რომ შეგექმნათ როგორ მუშაობს >>> - Zero Fill Right Shift დააკვირდით ფოტოს.

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

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

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

შედარებისთვის :  == != > < >= <=

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

== - ამოწმებს ერთი ოპერანდი ზუსტად უდრის თუ არა მეორეს. თუ არ უდროს გვიბრუნებს შედეგს.( False.) თუ უდრის გვიბრუნებს შედეგს (true.) არ დაგავიწყდეთ (მათემატიკაში “ტოლობის“ ნიშანი) = და == ერთი და იგივე არ არის, = არის ნიშანი მითვისებისთვის, == არის ნიშანი ტოლობისთვის.

=! - ოპერანდი არ უდრის მეორე ოპერანდს.

ოპერატორი > ამოწმებს ერთი ოპერანდი მეტია თუ არა მეორეზე

ოპერატორი < ამოწმებს ერთი ოპერანდი ნაკლებია თუ არა მეორეზე

ოპერატორი >= ამოწმებს ერთი ოპერანდი მეთია თუ უდრის მეორე ოპერანდს

ოპერატორი <= ამოწმებს ერთი ოპერანდი ნაკლებია თუ უდროს მეორე ოპერანდს.

მაგალითზე უკეთესად გავერკვევით:

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

მითვისებისთვის : = += -= *= /= %= &= |= ^= <<= >>= >>>=

ოპერატორი „მითვისებისთვის“ ანიჭებს ღირებულებას მარცხნივ მდგარ ოპერანდს. მისი გამოყენება შეგიძლიათ როგორც პრიმიტიულ ისე რეფერენციულ ტიპებთან. მაგალითისთვის String dog = new String(“bamsi”), ამ შემთხვევაში = ნიშანი არის ოპერატორი მითვისებისთვის, მან მიითვისა სახელი ბამსი.

+= ოპერატორი ანიჭებს მარცხნივ მდგარ ოპერანდს მარჯვნივ მდგარი ოპერანდის ღირებულებას. მაგალითად. C+=B, თუ B ჩვენ შემთხვევაში უდრის 10-ს და C = 5,  მაშინ C ახალი ღირებულება იქნება 15. C+=B უფრო კარგად რო გაიაზროთ, გავშლი, C= C+B, ზუსტად იგივე შედეგით იმუშავებს ყველა დანარჩენი დამატება, გამრავლება იქნება, გაყოფა, ნაშტი თუ ბიტური ოპერაცია. ნებისმიერ შემთხვევაში მიითვისებს მარცხნივ მდგარი ოპერანდი მარჯვნივ მდგარი ოპერანდის ღირებულებას, მიუხედავად იმისა რა ღირებულება ექნება მარცხნივ მდგარ ოპერანდს. გაითვალისწინეთ,  თუ მარცხნივ მდგარი ოპერანდი ზომით პატარა არის მარჯვნივ მდგარ ოპერანდზე მაშინ მოგიწევთ, (Casting) ოპერაციის განხორციელება რომ ერთმა ტიპმა მეორე მიიღოს. მაღლა ამაზე ვისაუბრეთ. 

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

საკმაოდ მარტივი რამ არის როგორც ხედავთ. ერთხელ ცდის მერე ყოველთვის გემახსოვრებათ.

ტიპეპთან მუშაობისთვის : (type) instanceof

მისი ძირითადი მოვალეობა არის შეამოწმოს მემკვიდრეობა, ობიეკტის, ტიპის, თუ ცვლადის. ცოტა რთულად აღქმადია ამ ეტაპზე ალბათ მემკვიდრეობა მაგრამ ჯავა ხომ იერარხიული პროგრამირების ენა არის. ყველა ოპერაცია რომელიმე ოპერაციიდან გამომდინარეობას, შესაბამისად ამა თუ იმ ოპერაციის მემკვიდრეა,  ძალიან საჭირო ხელსაწყოა, მაშინ როცა კოდის წერის დროს გაიჭედები ან დაგავიწყდება რის მერე რა გააკეთე. უბრალოდ ერთი მარტივი კოდის შექმნით გადაამოწმებ საიდან მოხვედი არსებულ ადგილამდე.  პატარა მაგალითზე განვიხილავთ, მაგრამ წარმოიდგინეთ გააკეთეთ ძალიან დიდი პროგრამა, უამრავი გვერდით, ქვე-ქვერდით, ღილაკებით. ერთი სიტყვით ყველაფრით რაც დიდ გვერდს გააჩნია, თუ გინდათ რო გაერკვეთ ესა თუ ის ობიეკტი რომელი ობიეკტის მემკვიდრეა ან რომელი კლასიდან შეიმნა, გამოიყენებთ Instanceof ოპერატორს და მარტივად გადაამოწებთ, მას გააჩნია casting-ის უნარიც, როცა ქვე-კლასიდან ამოწმებთ ზემდგომ კლასში პირდაპირ არის შესაძლებელი გადამოწმება, მაგრამ როცა ზემდგომი კლასიდან ქვემდგომ კლასში გინდათ რამის ნახვა მოგიწევთ DownCasting-ის შექმნა, რაც არც ისე მარტივია დამწყებთათვის ამიტომ ამ ინფორმაციას ახლა გვერდს აუვლით. განვიხილით სკრინზე რას გვაძლევს ეს ოპერატორი, როგორც ყველა სხვა დანარჩენი ოპერატორები ისიც ამოწმებს მარცხნივ მდგომი ოპერანდი არის თუ არა კონტაკტში მარჯვნივ მდგომ ოპერანდთან. რაც მთავარია ის არის Boolean ტიპის, და გვეუბნება true ან false შედეგს. მაგალითი სკრინზე.

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

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

Ternary: ? : ის მუშაობს სამ ოპერანდთან, და იყენებს ორ სიმბოლოს, (? და :) პროგრამირების ენაში ტერნარი შემოკლებული ვარიანტია, if-else Statement-ის, ვრცლად ნახავდით ჩემ სკრინებზე, განვიხილოთ რას აკეთებს ტერნარი ოპერატორი.  პირველი ოპერაცია არის არგუმენტი, მეორე ოპერაცია არის არგუმენტის გადამოწმება და მესამე ოპერაცია არის მართებული პასუხის დაბრუნება, წარმოიდგინეთ, ადრე დავწერეთ პროგრამა სადაც კლუბში შესვლა ასაკის მიხედვით იყო ნებადართული, თუ სწორად მახსოვს ბიჭის ასაკი იყო 15 წელი, რის შემდგომაც შევქმენით if(თუ)15 წლის არის შესვლა აკრძალულია და else თუ 18-ზე მეტის არის შესვლა ნებადართულია. კოდი 10 ველზე რომ არ ვწეროთ ტერნარული ოპერატორი გვაძლევს საშუალებას ზუსტად იგივე კოდი დავწეროთ ერთ ველზე. 3 ოპერაციის გამოყენებით. მაგალითი სკრინზე.

ორი ერთი და იგივე შინაარსის მატარებელი პროგრამა ერთ გვერდზე, პირველი if-else-ის გამოყენებით შესრულებული და მეორე ტერნარული ოპერაციით, რომელი უფრო წაკითხვადია? კოდი 7 ველზე თუ კოდი 1 ველზე?   კომპილირების შემდგომ:

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