Mga Nuances ng pagtatrabaho sa iba't ibang mga operator

1. Mga pagpapatakbo ng Boolean

Ang |at &operator ay maaaring ilapat hindi lamang sa mga numero, kundi pati na rin sa mga boolean na expression.

Ngunit, tulad ng alam mo na, mayroong &&at ||mga operator. Bakit namin gagamitin |sa halip na ||, at &sa halip na &&? May punto ba ito? Meron daw. Minsan.

Ang ||at &&lohikal na mga operator ay isinasagawa mula kaliwa hanggang kanan kasunod ng tinatawag na lazy principle .

(expression1) || (expression2) || (expression3)

Kung expression1 katumbas ng true, walang saysay ang pagsusuri expression2 at expression3: ang resulta ay magiging trueanuman.

Alinsunod dito, kapag sinusuri ang mga expression (nasusuri ang mga ito mula kaliwa hanggang kanan), sa sandaling makuha namin ang true, nilaktawan ang pagsusuri ng iba pang mga expression . At kung expression2 at expression3isama ang mga tawag sa pamamaraan, ang mga pamamaraang ito ay hindi tatawagin !

Ang parehong napupunta para sa &&lohikal na operator:

(expression1) && (expression2) && (expression3)

Kung expression1katumbas ng false, walang saysay ang pagsusuri expression2at expression3: ang resulta ay magiging falseanuman.

Ito ay isang mahalagang katotohanan na nagbibigay-daan sa iyong magsulat ng mga bagay tulad ng:

String s = null;
if (s != null && s.length() > 0) {

Ang halimbawa sa itaas ay hindi kailanman magbibigay sa iyo ng NullPointerException , dahil s.length()isasagawa lamang kung ang unang bahagi s! = nullay true.

Kung skatumbas ng null, ang bahagi sa kaliwa ng &&operator ay false, kung gayon ang resulta ng buong boolean expression ay false, kaya ang bahagi sa kanan ( s.length() > 0) ay hindi sinusuri.

2. Pangunahing operasyon sa Java

Tulad ng malamang na naaalala mo mula sa iyong klase sa matematika sa high school, ang multiplication operator ay may mas mataas na precedence kaysa sa karagdagan operator. Ang mga panaklong ay may mas mataas na precedence: ang mga expression sa panaklong ay sinusuri muna, pagkatapos ay multiplikasyon at paghahati, at pagkatapos ay pagdaragdag at pagbabawas.

Ang mga operator sa Java ay mayroon ding pagkakasunud-sunod ng pangunguna. Ang pagkakaiba ay ang a) mayroong bahagyang higit pa sa kanila, b) para sa ilang mga operator, ang mga operand ay sinusuri mula kaliwa hanggang kanan, habang para sa iba — mula kanan hanggang kaliwa.

Narito ang isang talahanayan kasama ang lahat ng mga operator ng Java:

Ang nangungunang linya ay naglalaman ng mga operator na may pinakamataas na precedence. ()Ginagamit ang mga panaklong upang tahasang itakda ang priyoridad. Ang mga square bracket []ay ginagamit upang ma-access ang isang elemento sa isang partikular na index ng isang array variable. Ang dot operator ( .) ay ginagamit upang ma-access ang mga field at pamamaraan gamit ang isang reference sa isang bagay o klase.

Kung mas mababa ang mga operator sa talahanayan, mas mababa ang kanilang precedence.

Kung gumagamit ka ng maraming operator sa isang expression, huwag maging tamad: magdagdag ng mga panaklong.

Sa Java, maaari kang magsulat ng isang bagay tulad ng if (a & 1<< b > ~c), ngunit hindi mo dapat. Nagsusulat ka ng code hindi lamang para sa compiler, kundi para din sa iba pang programmer. Kung mas nababasa ang code, mas mabuti.

3. Pagdaragdag ng prefix at postfix

Tulad ng alam mo na, ang Java ay may increment operator ( ++) at isang decrement operator ( --). Alinsunod dito, pinapataas at pinabababa nila ang halaga ng isang variable ng 1.

Ang malamang na hindi mo alam ay mayroong dalawang uri ng mga operator na ito: prefix (inilalagay ang operator bago ang variable) at postfix (inilalagay ang operator pagkatapos ng variable). At ang dalawang uri ng mga operator ay gumagana nang medyo naiiba.

Sa Java, maaari kang magsulat ng isang expression tulad nito:

int a = 5;
int b = a++;

Kung ang ++operator ay lilitaw pagkatapos ng isang variable at ang variable ay bahagi ng ilang expression (tulad ng sa halimbawa sa itaas), pagkatapos ay gagamitin ng expression ang kasalukuyang halaga ng variable, at pagkatapos lamang ay ang variable ay tataas ng 1.

Sa madaling salita, may mangyayaring ganito:

int a = 5;
int b = a;
a = a + 1;

Iyon ay, bmagiging 5, hindi 6gaya ng iniisip mo sa unang tingin.

Kung ang ++operator ay bago ang variable at ang variable ay bahagi ng ilang expression, ito ay tataas muna ng 1at pagkatapos lamang ang halaga nito ay gagamitin sa expression.

int a = 5;
int b = ++a;

int a = 5;
a = a + 1;
int b = a;

Dito, bmagiging katumbas ng 6.

Mayroong kahit isang halimbawa na ginamit ng mga programmer ng Java upang matukoy kung ang ibang tao ay isang Java programmer din:

int a = 5;
int b = ++a + ++a;

Oo, maaari mo ring isulat iyon.

Ang halimbawang ito ay mag-iipon nang maayos at magiging katulad nito:

int a = 5;

a = a + 1;
int v1 = a;

a = a + 1;
int v2 = a;

int b = v1 + v2;

Para sa --operator, ang lahat ay eksaktong pareho.