რას ნიშნავს ჯავაში. ლოგიკური ოპერატორები. მთელი ბიტიანი ოპერატორები
პრიმიტიულ ტიპებზე ოპერაციების უმეტესობა ხორციელდება არა მეთოდების გამოყენებით, არამედ სპეციალური სიმბოლოების გამოყენებით ოპერაციის ნიშანი.
დავალების ოპერატორი
ცვლადის მინიჭებას მუდმივის, სხვა ცვლადის ან გამოხატვის (ოპერატორის ნიშნებით გამოყოფილი ცვლადები და/ან მუდმივები) მნიშვნელობის მინიჭება ე.წ. დავალების ოპერაციადა მითითებულია ნიშნით " = ", მაგალითად: x = 3; y = x; z = x; ჯავაში შესაძლებელია მინიჭების ოპერატორის გამოყენება რამდენჯერმე ერთ გამოსახულებაში, მაგალითად: x1 = x2 = x3 = 0; ეს ოპერაცია შესრულებულია მარჯვნივ მარცხნივ, ანუ ჯერ x3 ცვლადს ენიჭება მნიშვნელობა 0, შემდეგ ცვლადს x2 ენიჭება ცვლადის x3 (0) და ბოლოს ცვლადს x1 ენიჭება ცვლადის x2 (0). ოპერაციების ნიშნები, რომელთა არგუმენტები რიცხვებია, იყოფა ორ კატეგორიად: ერთიანიოპერაციების (უნარული) ნიშნები ერთი არგუმენტით და ორობითი(ორობითი) ორი არგუმენტით.ერთიანი ოპერაციები
შემდეგი უნიალური ოპერატორები განსაზღვრულია ჯავაში:- ერთიანი მინუს " - " – ცვლის რიცხვის ან გამოხატვის ნიშანს საპირისპიროდ;
- unary plus " + " – არ ასრულებს რაიმე მოქმედებას რიცხვზე ან გამონათქვამზე;
- bitwise complement "~" (მხოლოდ მთელი რიცხვებისთვის) – აბრუნებს რიცხვების ველის ყველა ბიტს (ცვლის 0-დან 1-მდე და 1-დან 0-მდე);
- increment "++" (მხოლოდ მთელი რიცხვებისთვის) – ზრდის ცვლადის მნიშვნელობას 1-ით;
- შემცირება " -- " (მხოლოდ მთელი რიცხვებისთვის) - ამცირებს ცვლადის მნიშვნელობას 1-ით.
y ცვლადს მიენიჭება მნიშვნელობა 2, რადგან ჯერ x-ის მნიშვნელობა გაიზრდება 1-ით და შემდეგ შედეგი მიენიჭება y ცვლადს. z ცვლადს მიენიჭება მნიშვნელობა 1, რადგან z ცვლადს ჯერ მიენიჭება მნიშვნელობა და შემდეგ x-ის მნიშვნელობა გაიზრდება 1-ით. ორივე შემთხვევაში, x-ის ახალი მნიშვნელობა იქნება 2. გასათვალისწინებელია, რომ ჯავაში, C ენისგან განსხვავებით, შემცირების და ზრდის ოპერაციების გამოყენება შესაძლებელია რეალურ ცვლადებზეც (ტიპი float და double).
ორობითი ოპერაციის ნიშნები იყოფა ოპერაციებად რიცხვითი შედეგით და შედარების ოპერაციებად, რომელთა შედეგი არის ლოგიკური მნიშვნელობა.:- არითმეტიკული ორობითი ოპერაციები
- ჯავა განსაზღვრავს შემდეგს
- არითმეტიკული ორობითი ოპერაციები
- დამატება "+";
- გამოკლება " - ";
// x2 = -1 x3 = x2 * x;
- // x3 = -7 x4 = x/ 4;
- // x4 = 1 (მთლიანი რიცხვების გაყოფისას // წილადი ნაწილი გაუქმებულია) x5 = x% 4 // წილადი ნაწილი გაუქმებულია)// x5 = 3 (გაყოფის ნაშთი
- // x4 = 1 (მთლიანი რიცხვების გაყოფისას // წილადი ნაწილი გაუქმებულია)// 7 4-ზე) // წილადი ნაწილი გაუქმებულია)ბიტიური ოპერაციები
- // x4 = 1 (მთლიანი რიცხვების გაყოფისას // წილადი ნაწილი გაუქმებულია) Bitwise ოპერაციები განიხილავს ნედლეულ ციფრულ მნიშვნელობებს, როგორც ბიტების ველებს და ასრულებს შემდეგ ოპერაციებს მათზე: // წილადი ნაწილი გაუქმებულია)დაყენება ცოტა
- პირველი ოპერანდის ველის ბიტების მარცხნივ გადატანა მეორე ოპერანდით განსაზღვრული ბიტების რაოდენობის მიხედვით (რიცხვის ნიშნის ბიტი არ იცვლება) - ბიტალურად გადაადგილება მარცხნივ ნიშნის გათვალისწინებით "<< ";
- პირველი ოპერანდის ველის ბიტების მარჯვნივ გადანაცვლება მეორე ოპერანდით განსაზღვრული ბიტების რაოდენობის მიხედვით (რიცხვის ნიშნის ბიტი არ იცვლება) – ბიტის გადანაცვლება მარჯვნივ, „ >>“ ნიშნის გათვალისწინებით;
- პირველი ოპერანდის ველის ბიტების მარჯვნივ გადანაცვლება მეორე ოპერანდით განსაზღვრული ბიტების რაოდენობის მიხედვით (რიცხვის ნიშნის ბიტიც გადაინაცვლებს) - ბიტზე გადანაცვლება მარჯვნივ " >>> გათვალისწინების გარეშე. "მოწერა.
ბიტალურად და
int x = 112; int y = 94;int z;
z = x & y; // z=80: 00000000 00000000 00000000 01010000ბიტალურად OR int x = 112;// x: 00000000 00000000 00000000 01110000 int y = 94;// წ: 00000000 00000000 00000000 01011110
z = x & y; // z=80: 00000000 00000000 00000000 01010000ბიტალურად OR int x = 112; int z; z = x |y;
// z = 126: 00000000 00000000 00000000 01111110 Bitwise ექსკლუზიური OR int z;<< 2 ; z = x^y;// z = 46: 00000000 00000000 00000000 00101110
მარცხნივ ცვლა ნიშნის მიხედვით int x = 31 , z;// x: 00000000 00000000 00000000 00011111
z = x // z = 124: 00000000 00000000 00000000 01111100მარჯვენა ცვლა ნიშნით int x = - 17 , z;
z = x >> 2;
// z = -5: 11111111 11111111 11111111 11111011 მარჯვენა ცვლა ნიშნის გათვალისწინების გარეშე int x = - 17 , z;- // x: 11111111 11111111 11111111 11101111
- z = x >>> 2 ;
- // z = 1073741819
- // z: 00111111 11111111 11111111 11111011
- კომბინირებული ოპერაციები
- ჯავაში, ორობითი არითმეტიკული ოპერაციებისთვის შეგიძლიათ გამოიყენოთ
- კომბინირებული
- (კომპოზიტური) ოპერატორის ნიშნები: იდენტიფიკატორის ოპერაცია = გამოხატულება ეს უდრის შემდეგ ოპერაციას: იდენტიფიკატორი = იდენტიფიკატორის ოპერაციის გამოხატულება მაგალითები:
- გამოთქმა x += b ნიშნავს x = x + b.<<= b означает x = x << b .
- გამოთქმა x -= b ნიშნავს x = x - b.
- გამოთქმა x *= b ნიშნავს x = x * b.
გამოთქმა x /= b ნიშნავს x = x / b.
გამოთქმა x %= b ნიშნავს x = x % b.- გამოთქმა x &= b ნიშნავს x = x & b.
- გამოთქმა x |= b ნიშნავს x = x | ბ.
- " < " (меньше) " <= " (меньше или равно)
int x1 = 5, x2 = 5, x3 = 3, x4 = 7;
არის ტოლი = x1 == x2;// isEqual = true isNonEqual = x1 != x2; // isNonEqual = false isGreater = x1 > x3;// isGreater = true // isGreaterOrEqual = true isGreaterOrEqual = x2 >= x3;- არის ნაკლები = x3
- ლოგიკური ოპერაციები
- ლოგიკური ოპერაციები
- შესრულებულია ლოგიკურ ცვლადებზე და მათი შედეგიც არის ტიპის მნიშვნელობა
პირობითი ოპერაცია
პირობითი ოპერაცია იწერება სახით გამოხატვა-1?გამოთქმა-2:გამოხატვა-3. ამ შემთხვევაში, ჯერ ფასდება გამოხატვის გამოხატულება-1, რომელმაც უნდა მისცეს ლოგიკური მნიშვნელობა, შემდეგ კი, თუ გამოხატულება-1 არის ჭეშმარიტი, გამონათქვამი-2 ფასდება და ბრუნდება ოპერაციის შედეგად, ან (თუ გამონათქვამი-1 არის false), ის ფასდება და ოპერაციის შედეგად დაბრუნდა გამოხატულება-3. პირობითი ოპერაციის მაგალითი: x= n> 1 ? 0 : 1 ;x ცვლადს მიენიჭება მნიშვნელობა 0, თუ n>1 (გამოხატვა n>1 არის ჭეშმარიტი) ან 1, თუ n≤1 (გამოხატვა n>1 არის მცდარი).
ოპერაციული ასაკი
გამონათქვამებში ოპერაციები შესრულებულია მარცხნიდან მარჯვნივ, თუმცა მათი პრიორიტეტის შესაბამისად. ასე რომ, გამრავლების მოქმედებები გამოსახულებაში y = x + z* 5;<=
5
)
;
შესრულდება შეკრების ოპერაციამდე, რადგან გამრავლების ოპერაციის პრიორიტეტი უფრო მაღალია, ვიდრე შეკრების ოპერაციის პრიორიტეტი. ჯავაში ოპერაციების პრიორიტეტები (პრიორიტეტის შემცირების მიზნით) მოცემულია ცხრილში. 1.
ფრჩხილები ზრდის მათში მყოფი ოპერაციების უპირატესობას. ასე რომ, თუ ზემოთ მოცემულ გამოსახულებაში ჩასვით ფრჩხილები: y = (x + z) * 5 ; შემდეგ ჯერ შესრულდება შეკრების ოპერაცია, შემდეგ კი გამრავლების ოპერაცია. ზოგჯერ ფრჩხილები გამოიყენება უბრალოდ გამონათქვამის უფრო წასაკითხად გასაკეთებლად, მაგალითად: (x > 1 ) && (xკონვერტაცია და ჩამოსხმა ოპერაციების შესრულებისას დავალების ოპერაციებსა და არითმეტიკულ გამოსახულებებს შეუძლიათ გამოიყენონ ლიტერალები, ცვლადები და სხვადასხვა ტიპის გამონათქვამები, მაგალითად: double y;ბაიტი x; y = x + 5;® ეს მაგალითი ამატებს ბაიტის ცვლადს x-ს int literal 5-ს და შედეგს ანიჭებს ორმაგ ცვლადს y. Java-ში, ისევე როგორც C ენაში, ტიპის კონვერტაციები გამონათქვამების შეფასებისას შეიძლება განხორციელდეს ავტომატურად ან ტიპის cast ოპერატორის გამოყენებით. თუმცა, ტიპების ჩამოსხმის წესები ოდნავ განსხვავდება C ენის წესებისგან და, როგორც წესი, უფრო მკაცრია, ვიდრე C ენაში, დავალების შესრულებისას, ტიპის კონვერტაცია ხდება ავტომატურად, თუ® გაფართოებული ტრანსფორმაცია® (გაფართოების კონვერტაცია) და® ორი ტიპი თავსებადია® . გაფართოებული გარდაქმნები გარდაქმნებია. კონვერტაციების გაფართოებისთვის, რიცხვითი ტიპები, მათ შორის მთელი რიცხვი და მცურავი წერტილი, თავსებადია ერთმანეთთან. თუმცა, რიცხვითი ტიპები არ არის თავსებადი char და boolean ტიპებთან. char და boolean ტიპები ასევე შეუთავსებელია ერთმანეთთან. ჯავა ასევე ახორციელებს ტიპის ავტომატურ კონვერტაციას, როდესაც ინახავს ლიტერალური მთელი რიცხვის მუდმივობას (რომელიც ნაგულისხმევია int) ტიპის ბაიტის, მოკლე ან გრძელი ცვლადში (თუმცა, თუ ლიტერალს აქვს მნიშვნელობა ამ ტიპის მოქმედი მნიშვნელობების დიაპაზონის მიღმა, გაიცემა შეცდომის შეტყობინება: სიზუსტის შესაძლო დაკარგვა). თუ კონვერტაცია არის შევიწროებული კონვერტაცია, ანუ შესრულებულია ბაიტი ¬ მოკლე ¬ ჩანაწერი ¬ ინტი ¬ გრძელი ¬ float ¬ ორმაგი კონვერტაცია, მაშინ ასეთმა კონვერტაციამ შეიძლება გამოიწვიოს რიცხვის სიზუსტის დაკარგვა ან მისი დამახინჯება. ამიტომ, კონვერტაციების შევიწროებისას, პროგრამის შედგენისას, გამოჩნდება დიაგნოსტიკური შეტყობინება ტიპების შეუთავსებლობის შესახებ და არ იქმნება კლასის ფაილები. ეს შეტყობინება ასევე გაიცემა, თუ თქვენ ცდილობთ გადაიყვანოთ ბაიტის ან მოკლე ტიპის გამოხატულება char ტიპის ცვლადად. თუ ჯერ კიდევ აუცილებელია ასეთი კონვერტაციების განხორციელება, გამოიყენება cast ოპერაცია, რომელსაც აქვს შემდეგი ფორმატი: ( ტიპის კონვერტაცია) მნიშვნელობა, სად ტიპის კონვერტაციაგანსაზღვრავს რა ტიპს უნდა გადაიყვანოს მოცემული მონაცემები მნიშვნელობა, მაგალითად, ოპერატორების შესრულების შედეგად: ბაიტი x = 71 ; char სიმბოლო = (char ) x;სიმბოლოს ცვლადი მიიღებს მნიშვნელობას "G". თუ მცურავი წერტილის მნიშვნელობა ენიჭება მთელ რიცხვს, მაშინ (თუ მცურავი წერტილის მნიშვნელობას აქვს წილადი ნაწილი) ასევე ხდება აშკარა ტიპის კონვერტაცია. შეკვეცა , მაშინ ტრანსფორმაციის შედეგი იქნება მნიშვნელობის დაყოფის დარჩენილი ნაწილი მინიჭებული ტიპის დიაპაზონის მოდულზე (ბიტის ტიპის რიცხვებისთვის დიაპაზონის მოდული იქნება 256, მოკლედ - 65536, ინტ. – 4294967296 და ხანგრძლივი – 18446744073709551616). მაგალითად, ოპერატორის შესრულების შედეგად byte x = (byte ) 514; (შეკვეცა) ნომრები. ასე რომ, ოპერატორის შესრულების შედეგად int x = (int) 77.85;ცვლადი x მიიღებს მნიშვნელობას 77 . თუ მინიჭებული მნიშვნელობა სცილდება დიაპაზონს
ტიპის კონვერტაცია
ბმული პირველზე
ოპერატორები ჯავაში
შემდეგი არითმეტიკული ოპერატორები მხარდაჭერილია ჯავაში (ცხრილი 2.4).
ცხრილი 2.4. არითმეტიკული ოპერატორები
დამატება
- გამოკლება
* გამრავლება
/ განყოფილება
% ბალანსის გაანგარიშება
++ ზრდა
-- კლება
+= დავალება დამატებით
-= დავალება გამოკლებით
*= დავალება გამრავლებით
ერთი მათგანი (ნამატი) ერთს ამატებს ცვლადის მნიშვნელობას, მეორე (შემცირება), პირიქით, აკლებს ერთს.
ეს ოპერატორები მითითებულია ცვლადის მნიშვნელობის გვერდით სივრცის გარეშე. თუ ისინი გამოჩნდებიან ცვლადის მარცხნივ, მაშინ ამას ეწოდება ნამატის ან შემცირების პრეფიქსის ფორმა და ეს ნიშნავს, რომ ჯერ ემატება (ან აკლდება) ცვლადს და შემდეგ გამოიყენება გამოხატვაში. თუ ნამატი (ან კლება) მოთავსებულია ცვლადის სახელის შემდეგ, მაშინ ამას ეწოდება პოსტფიქსის ფორმა და ეს ნიშნავს, რომ ცვლადი ჯერ გამოიყენება გამონათქვამში, შემდეგ კი მას ემატება (ან აკლდება).
დანარჩენი ხუთი ოპერატორი გამოიყენება შემდეგნაირად:
a += b
ჩანაწერის მსგავსი:
a = a + b
ყველა ამ ოპერატორის მაგალითი ნაჩვენებია სიაში 2.9.
ჩამონათვალი 2.9.
არითმეტიკული ოპერატორების გამოყენების მაგალითი
კლასის მაგალითი (
{
int a,b,c,d,e;
a=10
b= 11;
c= 12;
a+ = b; // a=21
a *= c; // a = 252
a = a - c; // a = 240
a -= c; // a = 228
d = 5;
e = 10;
System.out.println(++d); 6 გამოჩნდება
System.out.println(d++); 6 გამოჩნდება
System.out.println(e--) ; 10 გამოჩნდება
System.out.println (--e) ; 8 გამოჩნდება
}
}
ახლა მოდით შევხედოთ ბიტვურ (ბიტიურ) ოპერატორებს (ცხრილი 2.5).
ცხრილი 2.5. Bitwise (bitwise) ოპერატორები
ოპერატორის აღწერა
- უნარული უარყოფა
& ბიტური და
| ბიტალურად OR
^ Bitwise ექსკლუზიური OR
<< Сдвиг битов влево
>> ბიტების გადატანა მარჯვნივ
>>> გადაიტანეთ ბიტები მარჯვნივ ყველაზე მნიშვნელოვანი ბიტის ნულით შევსებით
&=, | =, ^=, <<=, >>=, >>>= დავალება მსგავსი ოპერაციით
ამ ოპერატორების გამოყენებით, ჩვენ ვმუშაობთ რიცხვებზე მათ ბინარულ წარმოდგენაში. განვიხილოთ, მაგალითად, დაწერეთ რიცხვი 15 ორობითი ფორმით. 00001111
პირველი ოპერატორი, რომელსაც უნიალური უარყოფა ჰქვია, აქცევს 0-ს 1-ად და 1-ს 0-ად. ბიტიური ოპერატორი „და“ აწარმოებს სულ 1-ს, თუ შედარებული რიცხვების ორივე მსგავსი ბიტი ასევე არის 1. თუ მათ აქვთ რიცხვების განსხვავებული კომბინაცია, მაშინ შედეგი იქნება 0. მაგალითად:
C = A & B
ვთქვათ A = 15 (00001111) და B არის 10 (00001010). რიცხვი C ამ შემთხვევაში უდრის 10-ს (00001010). Bitwise "OR" ნიშნავს შემდეგს: თუ ერთი ბიტი მაინც არის 1-ის ტოლი, მაშინ შედეგი ასევე არის 1. ბიტიური ექსკლუზიური "OR" აბრუნებს 1-ს, თუ შედარებული რიცხვებიდან მხოლოდ ერთი ბიტი უდრის 1-ს. შემდეგი სამი ოპერატორი ბიტებს მარცხნივ გადააქვს ციფრების მითითებული რაოდენობით, სადაც ბიტების მარცხნივ გადანაცვლება ავსებს ცარიელ პოზიციებს ნულებით. ამ ოპერატორების გამოყენების მაგალითი მოცემულია ცხრილში. 2.6 და ჩამონათვალი 2.10.
ცხრილი 2.6. ბიტის ცვლის ოპერატორები
ჩამონათვალი 2.10.
ბიტის ცვლის ოპერატორების გამოყენების მაგალითი
კლასის მაგალითი
{
საჯარო სტატიკური სიცარიელე მთავარი (სტრიქონი არგები)
{
int a=3, b=4, c=5;
int d = a * b;
System.out.println(d);
d = a | გ;
System.out.println(d);
d&=a;
System.out.println(d);
}
}
Java ასევე მხარს უჭერს ცხრილში წარმოდგენილ ლოგიკურ ოპერატორებს. 2.7.
ცხრილი 2.7. ლოგიკური ოპერატორები
ოპერატორის აღწერა
= = თანაბარი
!= არ არის თანაბარი
< Меньше
< = Меньше или равно
> მეტი
> = მეტი ან ტოლი
& ლოგიკური და
| ლოგიკური ან
^ ლოგიკური ექსკლუზიური ან
! უარყოფა
&& პირობითი და
| | პირობითი ან
&=, |=, ^= დავალება მსგავსი ოპერატორით
პირველ ექვს ოპერატორს შედარების ოპერატორებს უწოდებენ. ისინი საშუალებას გაძლევთ შეადაროთ რიცხვები და დააბრუნოთ ჭეშმარიტი ან ყალბი. შემდეგი ოთხი ოპერატორი მუშაობს ლოგიკური მონაცემებით, მაგრამ მოქმედებით მსგავსია მსგავსი ბიტიანი ოპერატორების (თქვენ უბრალოდ უნდა შეცვალოთ ბიტი 0 false-ით და ბიტი 1 true-ით).
შემდეგი ორი ოპერატორი გამოიყენება ერთდროულად ორი პირობისთვის, ე.ი. მითითებულია ორი პირობა და მათ შორის მოთავსებულია ოპერატორი „პირობითი და“. თუ ორივე მართალია, მაშინ იბეჭდება true; თუ ერთი მათგანი მაინც ყალბია, მაშინ შედეგი მცდარი იქნება.
პირობითი ან ოპერატორი დაბრუნდება true, თუ ერთ-ერთი პირობა მაინც შეესაბამება სიმართლეს. ისინი ჩვეულებრივ გამოიყენება if დებულებაში (ამაზე ვისაუბრებთ შემდეგ თავში). ყველა ამ ოპერატორის გამოყენების მაგალითი წარმოდგენილია სიაში 2.11.
ჩამონათვალი 2.11.
ლოგიკური ოპერატორების გამოყენების მაგალითი
კლასის მაგალითი
{
საჯარო სტატიკური სიცარიელე მთავარი (სტრიქონი არგები)
{
int a = 10, b=15, c=20;
ლოგიკური b1 = a != b;
ლოგიკური b2 = c > a;
ლოგიკური b3 = b1 & b2;
ლოგიკური b4 = b3 ^ b1;
თუ (b1 && b4 = = მცდარი) // თუ b1 != b4, მაშინ:
bЗ = ჭეშმარიტი;
სხვა // თუ ეს ასე არ არის, მაშინ:
b2 = ყალბი;
}
}
აქ მოცემულია ლოგიკური ოპერატორების გამოყენების დიაგრამა (ცხრილი 2.8).
ცხრილი 2.8. ლოგიკური ოპერატორების მნიშვნელობები ორი ცვლადისთვის
მეჩვენება, რომ დროა დავიწყოთ დოკუმენტის შემუშავება, რომელიც მკაფიოდ დაადგენს, რისი გაკეთება შეუძლიათ მოქალაქეებს თავისუფალ დროს და რა არა.
ფილმიდან "დავიწყებული მელოდია ფლეიტისთვის"
ჯავის ყველა ოპერატორი შეიძლება დაიყოს ოთხ ჯგუფად: არითმეტიკული, ლოგიკური, ბიტური და შედარება. განვიხილოთ ოპერატორების თითოეული ჯგუფი თანმიმდევრულად. დავიწყოთ არითმეტიკით. ეს ოპერატორები ჩამოთვლილია ცხრილში. 1.2.
ცხრილი 1.2.ჯავის არითმეტიკული ოპერატორები
| ოპერატორი | სახელი | ახსნა |
| + | დამატება | ორობითი ოპერატორი. a+b ბრძანების შედეგი არის a და b ცვლადების მნიშვნელობების ჯამი |
| - | გამოკლება | ორობითი ოპერატორი. a-b ბრძანების შედეგი არის განსხვავება a და b ცვლადების მნიშვნელობებს შორის |
| * | გამრავლება | ორობითი ოპერატორი. a*b ბრძანების შედეგი არის a და b ცვლადების მნიშვნელობების ნამრავლი |
| / | განყოფილება | ორობითი ოპერატორი. a/b ბრძანების შედეგი არის a და b ცვლადების მნიშვნელობების კოეფიციენტი. მთელი რიცხვის ოპერანდებისთვის, მთელი რიცხვის დაყოფა ხდება ნაგულისხმევად |
| % | დარჩენილი | ორობითი ოპერატორი. a%b ბრძანების შედეგი არის a და b ცვლადების მნიშვნელობების მთელი რიცხვის დაყოფის დარჩენილი ნაწილი. |
| += | დამატება (გამარტივებული ფორმა დავალებით) | დამატების ოპერატორის გამარტივებული ფორმა დავალებით. ბრძანება a+=b უდრის ბრძანებას a=a+b |
| -= | გამოკლება (გამარტივებული ფორმა დავალებით) | გამოკლების ოპერატორის გამარტივებული ფორმა მინიჭებით. a-=b ბრძანება არის a=a-b ბრძანების ექვივალენტური |
| *= | გამრავლება (გამარტივებული ფორმა დავალებით) | გამრავლების ოპერატორის გამარტივებული ფორმა მინიჭებით. ბრძანება a*=b უდრის a=a*b ბრძანებას |
| /= | დაყოფა (გამარტივებული ფორმა დავალებით) | გაყოფის ოპერატორის გამარტივებული ფორმა დავალებით. a/=b ბრძანება არის a=a/b ბრძანების ექვივალენტური |
| %= | დარჩენილი (გამარტივებული ფორმა) | დარჩენილი ოპერატორის გამარტივებული ფორმა დავალებით. ბრძანება a%=b უდრის ბრძანებას a=a%b |
| ++ | მატება | უნიალური ოპერატორი. a++ (ან ++a) ბრძანება არის a=a+1-ის ექვივალენტი |
| -- | შემცირება | უნივერსალური ოპერატორი. a-- (ან --a) ბრძანება უდრის a=a-1-ს |
ამ ოპერატორებს აქვთ გარკვეული განსაკუთრებული მახასიათებლები. უპირველეს ყოვლისა, ჩვენ ყურადღებას ვაქცევთ განყოფილების ოპერატორს /. თუ ოპერანდები მთელი რიცხვებია, მთელი რიცხვის გაყოფის შედეგი ბრუნდება მნიშვნელობად. განვიხილოთ ბრძანებების თანმიმდევრობა:
int a=5,b=2; ორმაგი x=a/b;
ამ მაგალითში, ცვლადი x იღებს მნიშვნელობას 2.0 და არა 2.5, როგორც თქვენ შეიძლება მოელოდეთ. საქმე იმაშია, რომ პირველ რიგში ფასდება გამოთქმა a/b. მას შემდეგ, რაც
ოპერანდები მთელი რიცხვია, შესრულებულია მთელი რიცხვის დაყოფა. და მხოლოდ ამის შემდეგ მიღებული მნიშვნელობა გარდაიქმნება ორმაგ ფორმატში და ენიჭება x ცვლადს.
იმისათვის, რომ ნორმალური გაყოფა განხორციელდეს მთელი რიცხვის ოპერანდებისთვის, გაყოფის ოპერატორთან გამოხატვის წინ ფრჩხილებში მითითებულია ორმაგი (ან float) ტიპის იდენტიფიკატორი. მაგალითად, ასე:
ორმაგი x=(ორმაგი)a/b;
ახლა x ცვლადის მნიშვნელობა არის 2.5.
ჯავას, ისევე როგორც C++, აქვს გამარტივებული არითმეტიკული ოპერატორების ჯგუფი დავალებით. თუ op არის შეკრების, გამრავლების, გაყოფის და დარჩენილი ოპერატორებიდან, მაშინ ამ ოპერატორის გამარტივებული ფორმა მინიჭებით არის op=. ეს ასევე ორობითი ოპერატორია, როგორც op ოპერატორი, და x op=y ფორმის ბრძანება ექვივალენტურია x=x op y ბრძანებისა.
კიდევ ორი უაღრესად სასარგებლო უნარული ოპერატორია increment (++) და decrement (--) ოპერატორები. შემცირების ოპერატორის მოქმედება არის ოპერანდის მნიშვნელობის გაზრდა ერთით, ხოლო შემცირების ოპერატორი ერთით ამცირებს ოპერანდს. სხვა სიტყვებით რომ ვთქვათ, x++ ბრძანება არის x=x+1 ბრძანების, ხოლო x-- ბრძანება x=x-1 ბრძანების ექვივალენტური. ინკრემენტისა და შემცირების ოპერატორებს აქვთ არა მხოლოდ აქ წარმოდგენილი პოსტფიქსის ფორმა (ოპერატორი მოდის ოპერანდის შემდეგ: x++ ან x--), არამედ პრეფიქსის ფორმაც (ოპერატორი ოპერანდამდე მოდის:
X ან --x). ოპერანდზე ზემოქმედების თვალსაზრისით, არ აქვს მნიშვნელობა, გამოყენებული იქნება ოპერატორის პრეფიქსი თუ პოსტფიქსის ფორმა. თუმცა, თუ ნამატი ან კლების ოპერატორის მქონე გამოხატულება უფრო რთული გამონათქვამის ნაწილია, განსხვავებაა ნამატი და შემცირების ოპერატორების პრეფიქსისა და პოსტფიქსის ფორმებში. თუ გამოიყენება ოპერატორის პრეფიქსის ფორმა, ჯერ იცვლება ოპერანდის მნიშვნელობა, შემდეგ კი ფასდება გამოხატულება. თუ გამოიყენება ოპერატორის პოსტფიქსის ფორმა, ჯერ ფასდება გამოხატვა და შემდეგ იცვლება ოპერანდის მნიშვნელობა. მოდით შევხედოთ პატარა მაგალითს:
ამ შემთხვევაში, ბრძანებების შესრულების შემდეგ, n ცვლადს ექნება მნიშვნელობა 11, ხოლო ცვლადს m ექნება მნიშვნელობა 10. ბრძანების m=n++ შესრულების დროს, n ცვლადის მნიშვნელობა არის 10. ვინაიდან m=n++ ბრძანებაში გამოიყენება increment ოპერატორის პოსტფიქსის ფორმა, მნიშვნელობა ენიჭება ჯერ m ცვლადს, შემდეგ კი n ცვლადის მნიშვნელობა იზრდება ერთით.
განსხვავებული შედეგი შემდეგი ბრძანებების გაშვებისგან:
ორივე ცვლადს (n და m) ამ შემთხვევაში აქვს მნიშვნელობა 11. ვინაიდან ბრძანება m=++n იყენებს პრეფიქსის გაზრდის ფორმას, n ცვლადის მნიშვნელობა ჯერ ერთით იზრდება, შემდეგ კი n ცვლადის მნიშვნელობა. ენიჭება m ცვლადს.
შემდეგი ჯგუფი შედგება ლოგიკური ოპერატორებისგან. ლოგიკური ოპერატორების ოპერანდები არის ლოგიკური ტიპის ცვლადები და ლიტერალები. ჯავის ლოგიკური ოპერატორები ჩამოთვლილია ცხრილში. 1.3.
ცხრილი 1.3.ჯავის ლოგიკური ოპერატორები
| ოპერატორი | სახელი | ახსნა |
| & | ლოგიკური და | ორობითი ოპერატორი. A&B ოპერაციის შედეგი არის ჭეშმარიტი, თუ ორივე ოპერანდი მართალია. წინააღმდეგ შემთხვევაში, false ბრუნდება |
| && | მოკლე ლოგიკური და | ორობითი ოპერატორი. ოპერატორის თავისებურება, & ოპერატორთან შედარებით, არის ის, რომ თუ პირველი ოპერანდის მნიშვნელობა არის false, მაშინ მეორე ოპერანდის მნიშვნელობა არ შემოწმდება. |
| | | ლოგიკური ან | ორობითი ოპერატორი. A|B ოპერაციის შედეგი არის ჭეშმარიტი, თუ მინიმუმ ერთი ოპერანდის მნიშვნელობა არის true. წინააღმდეგ შემთხვევაში, false ბრუნდება |
| || | მოკლე ლოგიკური OR | ორობითი ოპერატორი. ოპერატორის თავისებურება, ოპერატორთან შედარებით, არის ის, რომ თუ პირველი ოპერანდის მნიშვნელობა მართალია, მაშინ მეორე ოპერანდის მნიშვნელობა არ არის შემოწმებული. |
| ^ | ექსკლუზიური OR | ორობითი ოპერატორი. A^B ოპერაციის შედეგი მართალია, თუ ერთი და მხოლოდ ერთი ოპერანდის მნიშვნელობა არის true. წინააღმდეგ შემთხვევაში, false ბრუნდება |
| ! | ლოგიკური უარყოფა | უნივერსალური ოპერატორი. !A ბრძანების შედეგი მართალია თუ ოპერანდი A არის მცდარი. თუ ოპერანდ A-ს მნიშვნელობა არის true, ბრძანების შედეგი!A არის false |
ლოგიკური ოპერატორები ჩვეულებრივ გამოიყენება როგორც პირობები პირობით და მარყუჟის განცხადებებში.
მაგიდაზე 1.4 ჩამოთვლილია ჯავაში გამოყენებული შედარების ოპერატორები.
ცხრილი 1.4.ჯავის შედარების ოპერატორები
| ოპერატორი | სახელი | ახსნა |
| < | ნაკლები | ოპერაციის შედეგი ა |
| <= | ნაკლები ან ტოლი | ოპერაციის შედეგი ა<=B является значения true, если значение операнда A не больше значения операн- да B. В противном случае значением является false |
| > | მეტი | A>B შედეგი არის ჭეშმარიტი, თუ ოპერანდ A-ს მნიშვნელობა B-ის მნიშვნელობაზე მეტია. წინააღმდეგ შემთხვევაში, მნიშვნელობა მცდარია. |
| >= | მეტი ან ტოლი | A>=B მოქმედების შედეგი არის ჭეშმარიტი, თუ ოპერანდ A-ს მნიშვნელობა არ არის ნაკლები ოპერანდის B-ის მნიშვნელობაზე. წინააღმდეგ შემთხვევაში, მნიშვნელობა არის false. |
| != | არა თანაბარი | ოპერაცია A!=B ფასდება ჭეშმარიტად, თუ ოპერანდებს A და B აქვთ განსხვავებული მნიშვნელობები. წინააღმდეგ შემთხვევაში, მნიშვნელობა ყალბია |
შედარების ოპერატორები ჩვეულებრივ გამოიყენება ლოგიკურ ოპერატორებთან ერთად.
ბიტიური ოპერატორების მოქმედების პრინციპების გასაგებად, თქვენ უნდა გქონდეთ მინიმუმ საბაზისო ცოდნა რიცხვების ორობითი წარმოდგენის შესახებ. შევახსენოთ მკითხველს რამდენიმე ძირითადი პუნქტი.
ბინარული წარმოდგენისას რიცხვის პოზიციური აღნიშვნა შეიცავს ნულებს და ერთეულებს.
ყველაზე მნიშვნელოვანი ბიტი (პირველი მარცხნივ) განსაზღვრავს რიცხვის ნიშანს. დადებითი რიცხვებისთვის ყველაზე მნიშვნელოვანი ბიტი არის ნული, უარყოფითი რიცხვებისთვის ეს არის ერთი.
დადებითი რიცხვის ორობითი რიცხვების სისტემიდან კონვერტაცია პოზიციურიდან
ნოეს შესვლა
ბნბნ-1...ბ 2ბ 1ბ 0
(ბიშეუძლია მიიღოს მნიშვნელობები 0 ან 1, მაღალი
ცოტა დადებითი რიცხვებისთვის ბნ= 0) ათწილადამდე კეთდება ასე:
ნ-1 ნ
+ ... + ბნ-12
უარყოფითი ორობითი რიცხვის ათწილადში გადასაყვანად, შესრულებულია კოდის ბიტური ინვერსია (ბიტური ინვერსიის მოქმედების შესახებ - იხილეთ ქვემოთ), მიღებული ორობითი რიცხვი გარდაიქმნება ათობითი სისტემაში, ემატება მას ერთი (და დამატებულია მინუს ნიშანი).
უარყოფითი რიცხვის ათწილადიდან ორობით სისტემაში გადასაყვანად, ერთი აკლდება რიცხვის მოდულს, შედეგი გარდაიქმნება ორობით კოდში და შემდეგ ეს კოდი ინვერსიულია.
რიცხვის ორზე გამრავლება უდრის დარჩენილი რიცხვის პოზიციური აღნიშვნის ერთი ბიტით გადატანას (პირველი ბიტის შევსება ნულით).
ჯავის ბიტიური ოპერატორები აღწერილია ცხრილში. 1.5.
ცხრილი 1.5.ჯავის ბიტიური ოპერატორები
| ოპერატორი | სახელი | ახსნა |
| & | ბიტალურად და | ორობითი ოპერატორი. ლოგიკური AND ოპერაცია გამოიყენება ოპერანდის ბიტების თითოეულ წყვილზე. შედეგი არის 1, თუ შედარებული ორი ბიტიდან თითოეული არის 1. წინააღმდეგ შემთხვევაში შედეგი იქნება 0 |
| | | ბიტალურად OR | ორობითი ოპერატორი. ლოგიკური OR ოპერაცია გამოიყენება ოპერანდის ბიტების თითოეულ წყვილზე. შედეგი არის 1, თუ შედარებული ორი ბიტიდან ერთი მაინც არის 1. წინააღმდეგ შემთხვევაში შედეგი იქნება 0 |
| ^ | Bitwise EXCLUSIVE OR | ორობითი ოპერატორი. ლოგიკური ოპერაცია EXCLUSIVE OR გამოიყენება ოპერანდების ბიტების თითოეულ წყვილზე. შედეგი არის 1, თუ შედარებული ორი ბიტიდან მხოლოდ ერთი არის 1. წინააღმდეგ შემთხვევაში შედეგი იქნება 0. |
| ~ | ბიტის უარყოფა | უნივერსალური ოპერატორი. ორობითი კოდი ინვერსიულია: 0 იცვლება 1-ზე და 1 იცვლება 0-ზე |
| >> | მარჯვნივ გადაწევა | ორობითი ოპერატორი. შედეგი არის რიცხვი, რომელიც მიიღება პირველი ოპერანდის პოზიციური წარმოდგენის მარჯვნივ გადატანით (ოპერატორის მარცხნივ) მეორე ოპერანდის მიერ მითითებული ბიტების რაოდენობის მიხედვით (ოპერატორის მარჯვნივ). პირველი ოპერანდის საწყისი მნიშვნელობა არ იცვლება. დაბალი რიგის ბიტი იკარგება და მაღალი რიგის ბიტი ივსება ნიშნის ბიტის დუბლირებით |
| << | გადაიტანეთ მარცხნივ | ორობითი ოპერატორი. შედეგი არის რიცხვი, რომელიც მიიღება პირველი ოპერანდის პოზიციური წარმოდგენის მარცხნივ (ოპერატორის მარცხნივ) მეორე ოპერანდით (ოპერატორის მარჯვნივ) განსაზღვრული ბიტების რაოდენობის მიხედვით. პირველი ოპერანდის საწყისი მნიშვნელობა არ იცვლება. დაბალი რიგის ბიტები ივსება ნულებით, ხოლო მაღალი რიგის ბიტები იკარგება |
| >>> | ხელმოუწერელი მარჯვენა ცვლა | ორობითი ოპერატორი. შედეგი არის რიცხვი, რომელიც მიიღება პირველი ოპერანდის (ოპერატორის მარცხნივ) პოზიციური წარმოდგენის მარჯვნივ გადატანით მეორე ოპერანდის მიერ (ოპერატორის მარჯვნივ) მითითებული ბიტების რაოდენობის მიხედვით. პირველი ოპერანდის საწყისი მნიშვნელობა არ იცვლება. ყველაზე ნაკლებად მნიშვნელოვანი ბიტები იკარგება და ყველაზე მნიშვნელოვანი ბიტები ივსება ნულებით. |
| &= | Bitwise & ოპერატორის გამარტივებული ფორმა დავალებით | ბრძანება, როგორიცაა A& A=A&B |
| |= | Bitwise ოპერატორის გამარტივებული ფორმა | დავალებით | A|=B ფორმის ბრძანება უდრის A=A|B ბრძანებას |
| ოპერატორი | სახელი | ახსნა |
| ^= | გამარტივებული | A^=B ფორმის ბრძანება ბრძანების ტოლფასია |
| ნაცემი ფორმა | ||
| პირველი ოპერატორი ^ | A=A^B | |
| დავალებით | ||
| >>= | გამარტივებული | A>>=B ფორმის ბრძანება ბრძანების ტოლფასია |
| ბიტიანი ფორმა | ||
| ოპერატორი >> | A=A>>B | |
| დავალებით | ||
| <<= | გამარტივებული | A ტიპის გუნდი<<=B является эквивалентом команды |
| ბიტიანი ფორმა | ||
| ე ოპერატორი<< | A=A< | |
| დავალებით | ||
| >>>= | გამარტივებული | A>>>=B ფორმის ბრძანება ბრძანების ტოლფასია |
| ბიტიანი ფორმა | ||
| ოპერატორი >>> | A=A>>>B | |
| დავალებით |
იშვიათი გამონაკლისების გარდა, ბიტიური ოპერაციები გამოიყენება იმ შემთხვევებში, როდესაც აუცილებელია პროგრამის ოპტიმიზაცია შესრულებისთვის.
გარდა ზემოთ ჩამოთვლილი ოპერატორებისა, ჯავას აქვს ერთი სამეული ოპერატორი (ოპერატორს აქვს სამი ოპერანდი). ფორმალურად, ოპერატორი აღინიშნება როგორც ?:. ამ ოპერატორის გამოძახების სინტაქსი ასეთია:
მდგომარეობა?მნიშვნელობა_1:მნიშვნელობა_2
პირველი ოპერანდი განსაზღვრავს პირობას - გამონათქვამს, რომელიც აბრუნებს ლოგიკურ მნიშვნელობას მნიშვნელობად. თუ პირობის გამოხატვის მნიშვნელობა არის true, value_1 უბრუნდება მნიშვნელობად სამჯერადი ოპერატორის მიერ. თუ პირობის გამოხატვის მნიშვნელობა მცდარია, სამჯერადი ოპერატორი მნიშვნელობად აბრუნებს value_2-ს.
რამდენიმე შენიშვნა დავალების ოპერატორის შესახებ (= ოპერატორი). ჯავაში მინიჭების ოპერატორი აბრუნებს მნიშვნელობას. x=y ფორმის ბრძანება შესრულებულია შემდეგნაირად. ჯერ ფასდება გამოხატულება y, რის შემდეგაც ეს გამოხატულება გადაიცემა x ცვლადის ტიპზე და შემდეგ იწერება ამ ცვლადზე. გამომდინარე იქიდან, რომ თანაბარი პრიორიტეტის მქონე სხვა ოპერატორებისგან განსხვავებით, მინიჭება ხორციელდება მარჯვნიდან მარცხნივ, ჯავაში მოქმედებს x=y=z ფორმის ბრძანებები. ამ შემთხვევაში, z ცვლადის მნიშვნელობა ენიჭება ჯერ y ცვლადს, შემდეგ კი y ცვლადის მნიშვნელობა ენიჭება x ცვლადს.
კიდევ ერთი შენიშვნა ეხება მინიჭების ოპერატორების გამარტივებულ ფორმებს, ანუ ოპერატორებს, როგორიცაა op=. მიუხედავად იმისა, რომ ამტკიცებდნენ, რომ A op=B ფორმის ბრძანება ექვივალენტურია A=A op B ბრძანებისა, ეს მთლად სიმართლეს არ შეესაბამება. A op=B ფორმის ბრძანების შესრულებისას ჯერ ფასდება გამოთქმა A op B, შემდეგ მიღებული მნიშვნელობა გადადის A ცვლადის ტიპზე და მხოლოდ ამის შემდეგ ენიჭება A ცვლადს. ცვლადი A რეალურად შესრულებულია ცალსახად და ბრძანებაში A= A op B ტიპის ჩამოსხმა არის იმპლიციტური, განსხვავება შეიძლება გამოჩნდეს
დავალების ბრძანებების სრული და გამარტივებული ფორმების გამოყენებაში. მოდით შევხედოთ მარტივ მაგალითს:
// სწორია: a+=20;
// არასწორია: a=a+b;
ამ შემთხვევაში ბრძანება a+=20 სწორია, მაგრამ ბრძანება a=a+b არა. პირველ შემთხვევაში, int ტიპის ლიტერალი 20 „იძულებით“ გარდაიქმნება ტიპის ბაიტად += ოპერატორის თავისებურებების გამო. მეორე შემთხვევაში, a+b გამოხატვის შეფასების შედეგი ავტომატურად გაფართოვდება int-ის ტიპზე და აკრძალულია int ტიპის ავტომატური ჩამოსხმა ტიპის ბაიტზე.
და ბოლოს, ჩვენ წარმოგიდგენთ ცხრილში. 1.6 მონაცემები ჯავაში სხვადასხვა ოპერატორების უპირატესობის შესახებ.
ცხრილი 1.6.ოპერატორის უპირატესობა ჯავაში
| პრიორიტეტი | ოპერატორები |
| ფრჩხილები (), კვადრატული ფრჩხილები და წერტილის ოპერატორი | |
| ზრდა ++, შემცირება --, უარყოფები ~ და! | |
| გამრავლება *, გაყოფა / და ნაშთი % | |
| შეკრება + და გამოკლება - | |
| ბიტის ცვლა >>,<< и >>> | |
| >-ზე მეტი, >=-ის მეტი ან ტოლი, ნაკლები ან ტოლი<= и меньше < | |
| თანაბარი == და არათანაბარი!= | |
| ბიტალურად და & | |
| Bitwise ექსკლუზიური OR ^ | |
| Bitwise OR | | |
| ლოგიკური და && | |
| ლოგიკური ან || | |
| მესამეული ოპერატორი?: | |
| დავალება = და ოპერატორების მოკლე ფორმები, როგორიცაა op= |
თანაბარი პრიორიტეტის ოპერატორები (დავალების გარდა) შესრულებულია მარცხნიდან მარჯვნივ. იმ შემთხვევებში, როდესაც არსებობს ეჭვები ოპერატორების უპირატესობასა და გამონათქვამების შეფასების თანმიმდევრობის შესახებ, რეკომენდებულია ფრჩხილების გამოყენება.
მოკლე ჩართვის ლოგიკური ოპერატორები && და || განკუთვნილია ლოგიკური AND (AND) და OR (OR) ოპერაციებისთვის ლოგიკური ტიპის გამონათქვამებზე. გაითვალისწინეთ, რომ არ არსებობს მალსახმობების ლოგიკური ოპერატორი XOR (ექსკლუზიური OR) ოპერაციისთვის.
შემოკლებული ლოგიკური ოპერატორები ჰგავს & და | ოპერატორებს, მაგრამ ისინი განსხვავებულად გამოიყენება მხოლოდლოგიკური ტიპის გამონათქვამებზე და არასოდეს ვრცელდება ინტეგრალურ ტიპებზე. თუმცა, && და || აქვთ შესანიშნავი თვისება: ისინი ამცირებენ გამოხატვის შეფასებას, თუ შედეგის გამოტანა შესაძლებელია გამონათქვამის ნაწილიდან (ამას მაგალითებით ცოტა მოგვიანებით აგიხსნით). ამ თვისების გამო, && და || ფართოდ გამოიყენება ნულოვანი გამონათქვამების დასამუშავებლად. ისინი ასევე ხელს უწყობენ საერთო პროგრამის ეფექტურობის გაზრდას.
შემოკლების თვისება პირდაპირ გამომდინარეობს განსხვავებებიდან &&/||-ს შორის და &/|: ოპერატორების ბოლო წყვილმა უნდა მიიღოს მარცხენა და მარჯვენა ოპერატორების მნიშვნელობები შეყვანის სახით, ხოლო ოპერატორების პირველი წყვილისთვის ზოგჯერ საკმარისია იცოდეთ მხოლოდ მარცხენა ოპერანდის მნიშვნელობა, რომ დააბრუნოთ მნიშვნელობა. მთელი გამოხატულება. შემცირებული ლოგიკური ოპერატორების ეს ქცევა ემყარება ლოგიკური სიმართლის ცხრილის ორ მათემატიკურ წესს:
- AND ოპერატორის მქონე გამოხატვა მცდარია, თუ მისი მინიმუმ ერთი ოპერანდის მნიშვნელობა არის false;
- OR ოპერატორის მქონე გამონათქვამი მართალია, თუ მისი ერთ-ერთი ოპერანდი მაინც არის true.
- მცდარი და X = მცდარი
- მართალია ან X = მართალია
მოდით შევხედოთ რამდენიმე კოდს, რომელიც ბეჭდავს სტრიქონის შეტყობინებას, თუ სტრიქონი არ არის ნულოვანი და 20 სიმბოლოზე მეტია:
1. თუ ((s != null) && (s.length() > 20)) (
2. System.out.println(s);
3. }
ერთი და იგივე დავალება შეიძლება განსხვავებულად იყოს კოდირებული:
1. თუ (s != null) (
2. თუ (s.length() > 20) (
3. System.out.println(s);
4. }
5. }
თუ სტრიქონი null იყო, მაშინ მივიღებდით NullPointerException-ს s.length() მეთოდის გამოძახებისას. თუმცა, არც ერთ კოდის მაგალითში ეს სიტუაცია არ წარმოიქმნება. კერძოდ, მეორე მაგალითში s.length() არ იძახება, როდესაც s = null შემცირებული && ოპერატორის გამოყენების გამო. თუ ტესტმა (s!=null) დააბრუნა false (false), ანუ s არის არარსებული სტრიქონი, მაშინ მთელი გამოხატულება გარანტირებულია, რომ იქნება false. ეს ნიშნავს, რომ არ არის საჭირო მეორე ოპერანდის, ანუ გამონათქვამის (s.length()>20) მნიშვნელობის გამოთვლა.
თუმცა, ამ ოპერატორებს აქვთ გვერდითი მოვლენები. მაგალითად, თუ მარჯვენა ოპერანდი არის გამონათქვამი, რომელიც ასრულებს გარკვეულ ოპერაციას, მაშინ შემცირებული ოპერატორების გამოყენებისას ეს ოპერაცია შეიძლება ჩავარდეს, თუ მარცხენა ოპერანდი არის false.
მოდით შევხედოთ მაგალითს:
// პირველი მაგალითი 1. int val = (int)(2 * Math.random()); 2. ლოგიკური ტესტი = (val == 0) || (++val == 2); 3. System.out.println(“test = “ + test + “\nval = “ + val); // მეორე მაგალითი 1. int val = (int)(2 * Math.random()); 2. ლოგიკური ტესტი = (val == 0)|(++val == 2); 3. System.out.println(“test = “ + test + “\nval = “ + val);
პირველი მაგალითი ზოგჯერ დაბეჭდავს ამას:
ტესტი = მართალია
val = 0
და ზოგჯერ ეს:
ტესტი = მართალია
val = 2
მეორე მაგალითი ზოგჯერ დაბეჭდავს ამას:
ტესტი = მართალია
val = 1
და ზოგჯერ ეს:
ტესტი = მართალია
val = 2
აი საქმე. თუ val არის 0, მაშინ მეორე ოპერანდი (++val) არასოდეს შეფასდება, რაც ნიშნავს, რომ val ნული დარჩება. თუ თავდაპირველად val უდრის ერთს, მაშინ შედეგად ეს ცვლადი გაიზრდება და ვნახავთ val = 2. მეორე მაგალითში გამოყენებისას არაშემცირებული ოპერატორები, ზრდა ყოველთვის შესრულებულია და შედეგი ყოველთვის იქნება 1 ან 2 პირველ ეტაპზე არჩეული შემთხვევითი მნიშვნელობის მიხედვით. ორივე მაგალითში ცვლადის ტესტი ფასდება ჭეშმარიტად, რადგან val = 0 ან val = 1 და იზრდება 2 მნიშვნელობამდე.
მოდით შევაჯამოთ ინფორმაცია შემოკლებული && და || ოპერატორების შესახებ:
- ისინი მიმართავენ ლოგიკურ ოპერანდებს;
- ისინი აფასებენ მარჯვენა ოპერანდის მნიშვნელობას მხოლოდ იმ შემთხვევაში, თუ შედეგი ვერ გამოითვლება მარცხენა ოპერანდის მნიშვნელობიდან:
- მცდარი და X = მცდარი
- მართალია ან X = მართალია
ლოგიკური ოპერატორები მუშაობენ მხოლოდ ტიპის ოპერანდებთან // isNonEqual = false isGreater = x1 > x3;. ყველა ლოგიკური ოპერატორი ორი ოპერანდით აერთიანებს ორ ლოგიკურ მნიშვნელობას, რათა შექმნას მიღებული ლოგიკური მნიშვნელობა. არ აურიოთ.
ლოგიკური ოპერატორების ცხრილი ჯავაში
ლოგიკური ოპერატორები & , | , ^ ვრცელდება ტიპის მნიშვნელობებზე // isNonEqual = false isGreater = x1 > x3;ზუსტად ისევე, როგორც მთელი რიცხვების ბიტებთან მიმართებაში. ლოგიკური ოპერატორი ! აბრუნებს (აბრუნებს) ლოგიკურ მდგომარეობას: !მართალი == მცდარი// j = -3 k = + i; !ცრუ == მართალია.
მაგიდა. ლოგიკური ოპერატორების შესრულების შედეგები
| ა | ბ | A | ბ | A&B | A^B | ა |
|---|---|---|---|---|---|
| გამოხატვა x | გამოხატვა x | გამოხატვა x | გამოხატვა x | გამოხატვა x | გამოთქმა x >>>= b ნიშნავს x = x >>> b . |
| გამოთქმა x >>>= b ნიშნავს x = x >>> b . | გამოხატვა x | გამოთქმა x >>>= b ნიშნავს x = x >>> b . | გამოხატვა x | გამოთქმა x >>>= b ნიშნავს x = x >>> b . | გამოხატვა x |
| გამოხატვა x | გამოთქმა x >>>= b ნიშნავს x = x >>> b . | გამოთქმა x >>>= b ნიშნავს x = x >>> b . | გამოხატვა x | გამოთქმა x >>>= b ნიშნავს x = x >>> b . | გამოთქმა x >>>= b ნიშნავს x = x >>> b . |
| გამოთქმა x >>>= b ნიშნავს x = x >>> b . | გამოთქმა x >>>= b ნიშნავს x = x >>> b . | გამოთქმა x >>>= b ნიშნავს x = x >>> b . | გამოთქმა x >>>= b ნიშნავს x = x >>> b . | გამოხატვა x | გამოხატვა x |
მალსახმობი ლოგიკური ოპერატორები
სტანდარტული ოპერატორების გარდა და (&)// j = -3 k = + i; ან (|)არის მალსახმობების ოპერატორები && // j = -3 k = + i; || .
თუ დააკვირდებით ცხრილს, ხედავთ, რომ ოპერატორის შესრულების შედეგია ანუდრის გამოთქმა x >>>= b ნიშნავს x = x >>> b . გამოთქმა x >>>= b ნიშნავს x = x >>> b ., B ოპერანდის მნიშვნელობის მიუხედავად. ანალოგიურად, ოპერატორის შესრულების შედეგი დაუდრის გამოხატვა xროდესაც ოპერანდ A-ს მნიშვნელობა არის გამოხატვა x, B ოპერანდის მნიშვნელობის მიუხედავად. გამოდის, რომ არ გვჭირდება მეორე ოპერანდის მნიშვნელობის გამოთვლა, თუ შედეგის დადგენა უკვე შესაძლებელია პირველი ოპერანდიდან. ეს მოსახერხებელი ხდება იმ შემთხვევებში, როდესაც მარჯვენა ოპერანდის მნიშვნელობა დამოკიდებულია მარცხენას მნიშვნელობაზე.
განვიხილოთ შემდეგი მაგალითი. დავუშვათ, შემოვიღეთ წესი - გამოკვება თუ არ გამოკვება კატა კვირაში დაჭერილი თაგვების რაოდენობის მიხედვით. უფრო მეტიც, თაგვების რაოდენობა დამოკიდებულია კატის წონაზე. რაც უფრო დიდია კატა, მით მეტი თაგვი უნდა დაიჭიროს.
კატა, რომელმაც წაიკითხა პრობლემის პირობები, განაწყენებული იყო ჩემზე. მან თქვა, რომ მე ჩამოვრჩი დროს და ეს არის 21-ე საუკუნე - თაგვების დაჭერა შეიძლება თაგვების ხაფანგით. მე უნდა ავუხსნა მისთვის, რომ ეს მხოლოდ პრობლემა იყო და არა მაგალითი ჩემი პირადი ცხოვრებიდან.
Int მაუსი; // თაგვების რაოდენობა წონაში; // კატის წონა გრამებში თაგვი = 5; წონა = 4500; თუ (მაუსი != 0 & წონა / მაუსი< 1000) { mInfoTextView.setText("Можно кормить кота"); }
თუ პროგრამას აწარმოებთ, მაგალითი უპრობლემოდ იმუშავებს - კვირაში ხუთი თაგვი საკმარისია იმისათვის, რომ თქვენი კატა გემრიელი საუზმით განებივროთ. თუ ის ოთხ თაგვს დაიჭერს, მაშინ პრობლემები დაიწყება კატის კვებასთან დაკავშირებით, მაგრამ არა პროგრამაში - ის იმუშავებს, უბრალოდ არ გამოჩნდება შეტყობინება პარაზიტის კვების ნებართვის შესახებ.
ახლა ავიღოთ უკიდურესი შემთხვევა. კატა დაიზარმა და არც ერთი თაგვი არ დაიჭირა. ცვლადი მნიშვნელობა მაუსიიქნება 0-ის ტოლი და გამოხატულება შეიცავს გაყოფის ოპერატორს. მაგრამ თქვენ არ შეგიძლიათ გაყოთ 0-ზე და ჩვენი პროგრამა დაიხურება შეცდომით. როგორც ჩანს, ჩვენ მივაწოდეთ ვარიანტი 0-ით, მაგრამ Java აფასებს ორივე გამონათქვამს მაუსი !=0// j = -3 k = + i; წონა/მაუსი< 1000 მიუხედავად იმისა, რომ უკვე პირველ გამოთქმაში ბრუნდება გამოხატვა x.
მოდით გადავიწეროთ პირობა შემდეგნაირად (დაამატეთ მხოლოდ ერთი სიმბოლო):
თუ (მაუსი != 0 && წონა / მაუსი< 1000) { mInfoTextView.setText("Можно кормить кота"); }
ახლა პროგრამა მუშაობს ავარიის გარეშე. ერთხელ ჯავამ დაინახა, რომ პირველი გამონათქვამი დაბრუნდა გამოხატვა x, მაშინ მეორე განყოფილების გამოხატულება უბრალოდ იგნორირებულია.
ოპერატორის მალსახმობები და// j = -3 k = + i; ანჩვეულებრივ გამოიყენება სიტუაციებში, როდესაც საჭიროა ლოგიკური ლოგიკური ოპერატორები და მათი ერთსიმბოლოიანი ნათესავები გამოიყენება ბიტიური ოპერაციებისთვის.
მესამეული ოპერატორი
ჯავას ასევე აქვს სპეციალური სამჯერადი პირობითი ოპერატორი, რომელსაც შეუძლია შეცვალოს გარკვეული ტიპის ოპერატორები თუ-მაშინ-სხვაარის ოპერატორი ?:
სამმაგი ოპერატორი იყენებს სამ ოპერანდს. გამოთქმა იწერება შემდეგი ფორმით:
ლოგიკური მდგომარეობა? გამოხატვა1: გამოხატულება2
თუ ლოგიკური მდგომარეობაუდრის გამოთქმა x >>>= b ნიშნავს x = x >>> b ., შემდეგ გამოითვლება გამოხატულება 1და მისი შედეგი ხდება მთელი განცხადების შესრულების შედეგი. თუ ლოგიკური მდგომარეობაუდრის გამოხატვა x, შემდეგ გამოითვლება გამოხატულება2და მისი მნიშვნელობა ხდება ოპერატორის შედეგი. ორივე ოპერანდი გამოხატულება 1// j = -3 k = + i; გამოხატულება2უნდა დააბრუნოს იგივე (ან თავსებადი) ტიპის მნიშვნელობა.
განვიხილოთ მაგალითი, რომელშიც ცვლადი აბსვალცვლადის აბსოლუტური მნიშვნელობა ენიჭება ვალ.
ინტ აბსვალ,ვალ; val = 5; აბსვალ = ვალ< 0 ? -val: val; // выводим число mInfoTextView.setText("" + absval); val = -5; absval = val < 0 ? -val: val; mInfoTextView.setText("" + absval);
ცვლადი აბსვალმიენიჭება ცვლადის მნიშვნელობა ვალ, თუ მნიშვნელობა მეტია ან ტოლია ნულის (გამოხატვის მეორე ნაწილი). თუ ცვლადის მნიშვნელობა val უარყოფითი, შემდეგ ცვლადი აბსვალცვლადის მნიშვნელობა ენიჭება, მიღებულია მინუს ნიშნით, მინუს მინუს მისცემს პლუსს, ანუ დადებით მნიშვნელობას. მოდით გადავიწეროთ კოდი გამოყენებით თუ-სხვა:
თუ (ვალ< 0) absval = -val; else absval = val;
თქვენ შეგიძლიათ ნახოთ კიდევ ერთი მაგალითი სამმაგი ოპერატორით.