Isang Gabay ng Baguhan sa Mga Lohikal at Kaugnay na Operator sa Java

Ang mga operator ay simbolo na ginamit upang maisagawa ang mga pagpapatakbo sa mga halaga, variable, o pahayag. Ang mga expression kung saan nila isinagawa ang mga pagkilos na ito ay tinatawag na operand. Ang mga operasyon ay nagbabalik ng isang boolean na resulta (totoo o hindi) para sa mga pakikipag-ugnay, pagkakapantay-pantay, at lohikal na mga operator.

Ang bilang ng mga pagpapatakbo na kinukuha ng isang operator ay tumutukoy sa uri nito. Ang isang operator na tumatagal ng isang operand ay tinatawag na 'unary'. Ang isang operator na tumatagal ng dalawang pagpapatakbo ay tinatawag na 'binary'.

Magbasa pa upang malaman kung paano mo magagamit ang mga lohikal at pang-ugnayang mga operator sa Java. Mas mabuti pa, ang karamihan sa mga wika ng programa ay gumagamit ng parehong mga operator upang mailapat mo ang kaalamang ito sa ibang lugar.

Mga Lohikal na Operator

Ginagamit ang mga ito upang makabuo ng mga lohikal na pahayag habang nagprogram. Mayroong anim na lohikal na mga operator sa Java. Ang talahanayan sa ibaba ay nagbubuod sa kanila.

Operator	Pangalan	Uri
\|	Lohikal na Boolean O	Binary
&	Lohikal na Boolean AT	Binary
^	Boolean Logical Exclusive O	Binary
\|\|	Kundisyon O	Binary
&&	Kundisyon AT	Binary
!	Lohikal HINDI	Hindi nag-iingat

Kung nais mong suriin kung ang isa o parehong kondisyon ay totoo, pagkatapos ay gamitin ang operator na ito. Ang isang kundisyon ay isang expression na maaaring alinman sa totoo o mali.

Boolean Logical Inclusive O (|)

Sinusuri ng lohikal na OR kung ang parehong pagpapatakbo ay totoo bago suriin ang expression.

if ( dob <2005 | height <= 5){  
money++;  
}

Ang halimbawa sa itaas ay magbibigay sa isang tao ng mas maraming pera kung ang kanilang petsa ng kapanganakan (dob) ay mas mababa sa 2005 o kung ang kanilang taas ay mas mababa sa o katumbas ng 5 talampakan.

Lohikal na Boolean AT (&)

Ginagamit ang operator na ito upang suriin kung ang parehong mga kondisyon ay totoo bago kumuha ng isang tiyak na landas ng pagpapatupad sa programa. Sinusuri muna nito kung ang parehong mga kundisyon ay totoo bago suriin ang buong expression.

Kaugnay: Paano Patunayan ang Mga String Gamit ang Mga Pamamaraan ng Boolean sa Python

Boolean Logical Exclusive O (^)

Kung nais mong suriin kung ang isa sa mga kundisyon ay totoo, ngunit hindi pareho, kung gayon ito ang gagamitin ng operator. Ang talahanayan ng katotohanan sa ibaba ay nagbubuod ng mga resulta na makikita mo kapag ginamit mo ito.

ekspresyon1	ekspresyon2	expression1 ^ expression2
hindi totoo	hindi totoo	hindi totoo
hindi totoo	totoo	totoo
totoo	hindi totoo	totoo
totoo	totoo	hindi totoo

Kundisyon ng Boolean AT (&&)

Ang operator na ito ay katulad ng lohikal na AND. Ang pagkakaiba ay sinusuri muna kung ang kondisyon sa kaliwa ay totoo bago magpatuloy upang suriin ang isa sa kanan.

Kung ang kaliwang bahagi ay napatunayang hindi totoo, pagkatapos ay tumitigil kaagad. Kung hindi man, magpapatuloy ang pagsusuri ng tamang bahagi. Ang tampok na ito ay kilala bilang pagsusuri sa maikling circuit.

Tingnan ang talahanayan ng katotohanan sa ibaba upang mabawasan ang iyong pagkaunawa sa operator na ito.

ekspresyon1	ekspresyon2	expression1 && expression2
hindi totoo	hindi totoo	hindi totoo
hindi totoo	totoo	hindi totoo
totoo	hindi totoo	hindi totoo
totoo	totoo	totoo

Kundisyon O (||)

Kung ang alinman sa mga kundisyon ay hindi totoo, pagkatapos ay ang pagpapatupad ay lalaktaw sa susunod na bahagi ng programa. Sa madaling salita, ang parehong mga kondisyon ay dapat na totoo.

Ang operator na ito ay katulad ng Lohikal O. Sinusuri din nito kung alinman sa isa o pareho ng mga kundisyon ay totoo bago ipatupad ang ilang mga code.

Katulad ng kondisyong AT, ang lohikal O gumagamit din ng pagsusuri ng maikling circuit. Sinusuri muna kung ang operan sa kaliwa ay totoo bago suriin ang isa sa kanan.

Kaugnay: Ano ang Isang Tagatayo sa Java at Paano Mo Ito Ginagamit?

pinakamahusay na libreng app ng musika para sa android

Kung ang kundisyon sa kaliwa ay napatunayang totoo, hindi na kailangang suriin ang isa sa kanan. Kung hindi man, magpapatuloy ang pagsusuri sa kanan.

Lohikal HINDI (!)

Ginagamit ang operator na ito upang tanggihan ang isang kundisyon. Binaliktad lamang nito ang kahulugan ng kung ano ito tumatakbo.

if(!(x>5)){  
// statements  
}

Ang pahayag sa itaas ay nangangahulugan na kung ang 'x ay higit sa 5' ay HINDI totoo, pagkatapos ay isagawa ang mga pahayag sa loob ng kung .

Pansinin ang paggamit ng mga bilog na bracket na may expression (x> 5). Kung hindi mo isasama ang mga bracket na ito habang sinusulat ang iyong programa, makakakuha ka ng isang error sa compile-time. Ang dahilan ay dahil ! ay isang unary operator na kumikilos sa isang kundisyon. Kung wala ang mga braket, bibigyan ng kahulugan ng tagatala ito bilang operator na kumikilos sa x, hindi x> 5.

Ang pagsasama ng mga braket ay hindi lamang para sa pagpapagana sa tagatala na wastong bigyang kahulugan ang isang expression. Maaari din silang magamit bilang isang paraan para mas mahusay na maunawaan ng programmer ang mas kumplikadong mga expression. Tingnan ang halimbawa sa ibaba:

age >= 7 && height <5

Ang ilang mga tao ay maaaring nahihirapan na sundin ang mga lohika. Samakatuwid, ginugusto ng ilang mga programmer na magdagdag ng mga labis na panaklong para sa mga kadahilanang madaling mabasa:

(age >= 7) && (height <5)

Mga kaugnay na Operator

Ginagamit ang mga operator na ito upang ihambing ang mga simpleng ugnayan sa pagitan ng mga operan.

Operator	Pangalan
>	Mahigit sa
<	Mas mababa sa
> =	Mas malaki kaysa sa o katumbas ng
<=	Mas mababa sa o katumbas ng

Ang mga kaugnay na operator ay medyo madaling maunawaan dahil lahat sila ay may parehong kahulugan tulad ng karaniwang mga operator ng algebraic na pamilyar na sa iyo. Na ibig sabihin, > at < magkaroon ng parehong kahulugan na alam mo na sa ibinigay sa talahanayan sa itaas.

if( x <= 7 ){  
x++;  
}

Sa itaas kung sinusuri ng pahayag kung ang x ay mas mababa sa o katumbas ng 7. Kung totoo, kung gayon ang mga pahayag sa loob ng mga braket ay isinasagawa, kung hindi man ay hindi.

Ngayon ay magiging isang magandang panahon upang banggitin ang mga operator ng pagkakapantay-pantay. Mayroong dalawa lamang sa kanila (katumbas ng, == at! =, Hindi katumbas ng). Tulad ng iminungkahi ng kanilang pangalan, ginagamit sila upang subukan ang pagkakapantay-pantay sa pagitan ng dalawang opera.

Kaugnay: Paano Lumikha at Magsagawa ng Mga Operasyon sa Mga Array sa Java

Ang operator ng pagkakapantay-pantay (==) ay hindi dapat malito sa operator ng pagtatalaga (=). Ang mga nagsisimula na programmer ay mahilig sa paghahalo ng dalawa. Makatwiran ito dahil sa algebra ang simbolo (=) ay ginagamit upang ipahayag ang pagkakapantay-pantay. Gayunpaman, hindi iyon tama sa pagprograma.

Ang operator ng pagtatalaga (=) ay nagtatalaga ng isang halaga sa isang variable habang ang operator ng pagkakapantay-pantay (==) ay sumusubok para sa pagkakapantay-pantay. Tingnan ang halimbawa sa ibaba upang maunawaan ang pagkakaiba:

if(x=5){  
// statements  
}

Ang code sa itaas ay palaging isinasagawa hindi alintana kung ang x ay talagang katumbas ng 5. Samantala, ang code sa ibaba ay papatayin lamang kung ang x ay katumbas ng 5. Samakatuwid, mahalagang hindi ihalo ang dalawa.

if(x==5){  
// statements  
}

Ang dalawang operator ng pagkakapantay-pantay na nabanggit ay may parehong antas ng precedence, kahit na mas mababa kaysa sa mga pamanggit na operator.

Ang mga magkakaugnay na operator ay mayroon ding parehong antas ng precedence. Ang pagpapatupad ng mga operator na ito ay nagsisimula mula kaliwa hanggang kanan.

Karagdagang Pagsasaalang-alang ng Mga Operator ng Java

Dapat ay napansin mo na mayroong whitespace sa pagitan ng ilang mga operator at kanilang mga operan sa ilan sa mga halimbawa habang sa iba, wala.

Ang kawalan / pagkakaroon ng puwang na iyon ay hindi dapat mag-alala sa iyo. Hindi ito papansinin ng tagatala. Samakatuwid, ang mga sumusunod na expression ay nangangahulugang magkatulad na bagay:

Y>=7 // no whitespace  
Y >= 7 // with whitespace

Ang mga kaugnay na operator ay karaniwang ginagamit upang ipahayag ang mga simpleng kundisyon. Upang pagsamahin ang mga simpleng kundisyon sa mas kumplikadong mga kondisyon, kakailanganin mong gumamit ng mga lohikal na operator. Ang mga lohikal na operator ay maaaring subukan ang maraming mga kundisyon, hindi tulad ng mga pamanggit na mga operator na sumusubok lamang sa isang kundisyon.

Mahalaga rin na tandaan na ang mga lohikal na operator (|, &, ^) ay maaaring maging mga medyo operator kung mayroon silang mga integral na operan. Kapag ginamit bilang mga bitwise operator, gagana ang mga ito sa mga piraso ng kanilang mga opera.

Sa kaalamang ito ng mga operator, dapat mo na ngayong mahanda upang malaman ang mga klase sa Java.

Magbahagi Magbahagi Mag-tweet Email Alamin Kung Paano Lumikha ng Mga Klase sa Java

Kung natututo kang mag-program sa Java, kakailanganin mong malaman kung paano lumikha ng mga klase.

Basahin Susunod Mga Kaugnay na Paksa

Programming
Java
Mga Tutorial sa Coding

Tungkol sa May-akda Jerome Davidson(22 Mga Artikulo Na-publish)

Si Jerome ay isang Staff Writer sa MakeUseOf. Saklaw niya ang mga artikulo sa Programming at Linux. Siya rin ay isang taong mahilig sa crypto at palaging pinapanatili ang mga tab sa industriya ng crypto.

Higit pa Mula kay Jerome Davidson

Mag-subscribe sa aming newsletter

Sumali sa aming newsletter para sa mga tip sa tech, pagsusuri, libreng ebook, at eksklusibong deal!

Mag-click dito upang mag-subscribe