Mga operator ng paghahambing at mga lohikal na operator. Sumasanga sa programa. May kondisyong operator

Mga lohikal na operator

Mayroong ilang mga binary logical operator at isang unary isa. Ang mga argumento para sa lahat ng mga operator na ito ay mga lohikal na literal (constants), mga lohikal na variable at mga expression na may lohikal na halaga. Mga operator:

• !- Ang "negation", isang unary operator, ay nagbabago ng kahulugan sa kabaligtaran (inverts: turns a lie into truth, and turns truth into a lie).
• &&- lohikal na “at” (“conjunction”, “intersection”), isang binary operation, ay nagbabalik ng true kung at kung ang parehong operand ay totoo.
• ||- lohikal na “o” (“disjunction”, “union”), binary operation, ay nagbabalik ng totoong halaga kapag kahit isa sa mga operand ay totoo.

Ang mga lohikal na operator ay may sumusunod na priyoridad: negation, conjunction, disjunction. Tulad ng sa kaso ng mga operator ng aritmetika, ang mga panaklong ay ginagamit upang iwasto ang precedence. Kung ang isang pares ng panaklong ay naka-nest sa loob ng isa pang pares ng mga panaklong, ang halaga sa mga panloob na panaklong ay susuriin muna. Mga halimbawa:

boolean a = true;
boolean b;
b = a || true; // b истинно
b = !b; // b ложно
System.out.println(b); // выведет false
a = a || b; // a истинно
boolean c;
c = a && (a||b); //с истинно
System.out.println(c); // выведет true

Sa Java, ang mga boolean at numeric na uri ay hindi mako-convert sa isa't isa.

Mga Operator ng Paghahambing

Karamihan sa mga operator ng paghahambing ay nalalapat sa mga numerong halaga. Ito ang lahat ng mga binary operator na mayroong dalawang numeric na argumento ngunit nagbabalik ng Boolean na halaga.

• >— ang operator na "higit pa sa".
• >=— “mas malaki kaysa o katumbas” na operator.
• <— “mas mababa sa” operator.
• <=— “mas mababa sa o katumbas” na operator.
• !=— “hindi pantay” na operator.
• ==— equivalence (equality) operator.

Ang huling dalawang operator ay maaaring gamitin hindi lamang para sa mga numerong halaga, kundi pati na rin, halimbawa, para sa mga lohikal. Mga halimbawa:

boolean m;
m = 5 >= 4; // истина
m = 5 != 5 || false; // ложь
boolean w;
w = m == false; // истина
System.out.println(w); // выведет true

Napakahalaga na huwag malito ang equivalence operator sa assignment operator. Sa mga expression na naglalaman ng mga operator ng iba't ibang uri, ang mga pagpapatakbo ng aritmetika ay unang ginagawa, pagkatapos ay ang mga pagpapatakbo ng paghahambing, pagkatapos ay mga lohikal na pagpapatakbo, at panghuli ang pagtatalaga.

May kundisyon kung pahayag

Tinitiyak ng operator ifna ang isang pagtuturo ay naisakatuparan o nilaktawan depende sa isang tinukoy na lohikal na kondisyon. Kung totoo ang kundisyon, ipapatupad ang pagtuturo .

if (condition) инструкция;

Sa halip ng isang pagtuturo, maaaring mayroong alinman sa isang regular na pagtuturo (isang utos) o isang tambalang pagtuturo (isang bloke na naglalaman ng ilang mga utos, kabilang ang iba pang mga conditional na pahayag). Mga halimbawa (kung ang zero ay tinukoy bilang mga variable na halaga, ang paghahati ay hindi isasagawa at ang resulta nito ay hindi ipapakita sa screen):

// Пример 1
int a = 25;
if (a != 0) System.out.println( 100/a );
// Пример 2
int b = 25;
if (b != 0) {
  System.out.println( 100/b );
}

Sa kabila ng katotohanan na ang code sa unang halimbawa ay mukhang mas compact, tanging sa pangalawang halimbawa ay posible na magsagawa ng ilang mga tagubilin kung ang kundisyon ay totoo. Ang operator ifay may format na may karagdagang bahagi else:

if (condition)
инструкция1;
else
инструкция2;

Kung totoo ang kundisyon , isasagawa ang simple o tambalang pagtuturo1 , at kung mali ang kundisyon, isasagawa ang simple o tambalang pagtuturo2 . Halimbawa:

int a = 0;
if (a != 0) System.out.println( 100/a );
else System.out.println("На нуль делить нельзя");