"Greetings, Amigo! Masyado akong nadala sa paglutas ng mga problema sa lohika kaya hindi ko napansin na pumasok ka. Ito ang isa para sa iyo: kung lumipad ang mga buwaya, kung gayon ang niyebe ay puti. May lumilipad na buwaya. Ano ang konklusyon?"
"Um... So we conclude na puti ang snow?"
"Excellent! Naipasa mo ang initiation test. Handa ka nang makabisado ang susunod na paksa. Ito ay tinatawag na 'logical operators'. At magsisimula tayo sa Boolean logic. Instinctively, alam mo na ito. Isa kang robot, kung tutuusin. . Kailangan lang naming i-tweak ang iyong mga setting upang tumugma sa wikang Java."
"Boolean logic? Sinabi sa akin kamakailan ang tungkol sa boolean type..."
"Oo, mayroong direktang koneksyon dito. Ang mga Boolean na expression ay maaari lamang maging totoo o mali. At habang nangyayari ito, ang ganitong uri ng lohika ay tungkol sa mga expression na totoo o mali, at mga kumbinasyon ng gayong mga expression. Halimbawa, ang expression 18 < Ang 25 ay palaging totoo, at ang 7 < 5 ay palaging mali. Ang expression (i < 10) ay nakasalalay sa halaga ng i. At kung ang expression ay nagsusuri, halimbawa, sa totoo, maaari nating hilingin sa programa na gumawa ng isang bagay."
"Ahh, naiintindihan ko. Ang mga expression ng Boolean ay nagpapahintulot sa amin hindi lamang gumawa ng mga lohikal na konklusyon, kundi pati na rin upang lumikha ng mga tinidor sa mga programa."
"Eksakto. Ang pangunahing bagay ay upang matutunan kung paano isulat ang mga ito. Halimbawa, sa Java ay hindi ka maaaring pumunta lamang at isulat ang expression 18 < age <65
. Ito ay magiging syntactically hindi tama at ang programa ay hindi mag-compile.
"Ngunit maaari mong isulat ito tulad nito:
(18 < age) AND (age < 65)
Siyempre, hindi talaga namin ginagamit ang salitang ENGLISH AND
. Sa halip, kailangan mo ng boolean operator . Ibig sabihin, iba ang kinakatawan ng 'AT'.
"Mayroong tatlong lohikal na operator sa Java: AND
(&&), OR
(||), NOT
(!).
Ang mabuting balita ay maaari kang gumamit ng mga panaklong upang bumuo ng mga lohikal na expression ng anumang kumplikado.
Ang masamang balita ay nagpasya ang mga developer ng Java na gumamit ng notasyon mula sa wikang C sa halip na mga salita and
, or
at not
.
Tumingin sa screen:
Lohikal na operator | Inaasahan | Realidad |
---|---|---|
AND (∧) |
and |
&& |
OR (∨) |
or |
|| |
NOT (¬) |
not |
! |
"It's actually not that bad... Medyo compact. Halos kabisado ko na sila."
"Well, iyan ay kahanga-hanga. Narito ang ilang mga halimbawa ng paggamit ng mga lohikal na operator sa Java:
Pagpapahayag | Interpretasyon | Paliwanag |
---|---|---|
(0 < a) && (a < 100) |
(0 < a) and (a < 100) |
(0 < a) AND (a < 100) |
(!a) && (!b) |
(not a) and (not b) |
(NOT a) AND (NOT b) |
!(!a || !b) |
not((not a) or (not b)) |
NOT((NOT a) OR (NOT b)) |
Mga halimbawa ng paggamit ng mga operator ng paghahambing at mga variable ng boolean
"Tandaan, Amigo, kahit saan ka magsulat ng isang lohikal na expression, maaari kang magsulat ng isang lohikal na variable."
"Paano yan?"
"Ibig kong sabihin maaari kang sumulat ng mga lohikal na expression sa iba't ibang paraan. Halimbawa:
Code | Paliwanag |
---|---|
|
Kung ang halaga ng edad ay nasa pagitan 18 ng at 65 , ang pariralang "Maaari kang magtrabaho" ay ipapakita. |
|
Gumawa kami ng isYoung variable at inilipat ang unang bahagi ng expression dito. Pinalitan lang namin age >= 18 ng age < 18 . |
|
Gumawa kami ng isOld na variable at inilipat ang pangalawang bahagi ng expression dito. Bukod pa rito, age <= 65 pinalitan ng age > 65 . |
"Ang tatlong halimbawang ito ay katumbas. Sa pangalawang halimbawa lamang namin inilipat ang bahagi ng expression mula sa if
pahayag sa isang hiwalay na boolean variable ( isYoung
). Sa ikatlong halimbawa, inilipat namin ang pangalawang bahagi ng expression sa pangalawang variable ( isOld
). Sa pamamagitan ng paraan, ang default na halaga ng isang boolean variable ay false
."
"Tatandaan ko yan. Sana."
Lohikal na aritmetika
"Ngayon, dumaan tayo sa madaling sabi sa mga lohikal na operasyon. Sinusunod nila ang napakasimple at lohikal (paano ito kung hindi!) na mga panuntunan.
"Una, tingnan natin kung paano OR
gumagana ang operator. Kilala rin ito bilang ||
o disjunction .
Pagpapahayag | Resulta |
---|---|
true || true |
true |
true || false |
true |
false || true |
true |
false || false |
false |
"Maaari mo bang mahinuha ngayon kung ano ang resulta ng expression a || b
na nakabatay sa talahanayan?"
"Nakita ko!" Ang halaga ng isang expression ay true
kung ang hindi bababa sa isang termino sa expression ay true
. Kung pareho false
, ang resulta ay false
.
"Tama iyan. Dahil napakatalino mo, tingnan mo muli ang talahanayan at isipin na false
0 iyon at true
1. Kapag tiningnan mo ito nang ganoon, ang ||
ugali ba ng operator ay nagpapaalala sa iyo ng anumang bagay mula sa ordinaryong arithmetic?"
"Um... Well, medyo parang karagdagan... Pero kapag nagdagdag ka, hindi katumbas ng 1 ang 1 + 1."
"There is a sense in which it is equal if we are only working with 0 and 1. But don't bother with that right now. Ang mahalaga ay napansin mo ang pagkakapareho ng operasyon ||
at karagdagan. Ibig sabihin, mananalo ka." t mabigla sa katotohanan na ang operasyong ito ay madalas na tinatawag na 'lohikal na karagdagan'.
"Nakuha ko."
"Ngayon ang AND
, aka &&
, aka conjunction operator, ay dumarating sa entablado.
Pagpapahayag | Resulta |
---|---|
true && true |
true |
true && false |
false |
false && true |
false |
false && false |
false |
"Sa pagkakaintindi ko, ang resulta ng isang expression ay true
kung ang parehong value na bumubuo sa expression ay true
. Kung hindi, ito ay palaging false
."
"Well done, Amigo! You're absorbing all this like a sponge. May nakikita ka bang ibang pagkakatulad sa arithmetic?"
"Pagpaparami!"
"Exactly. So eto meron tayong 'logical multiplication'".
"Susunod na titingnan natin ang NOT
operator, aka !
, aka ang logical inverse .
Pagpapahayag | Resulta |
---|---|
!true |
false |
!false |
true |
"Well, everything is quite simple here. The operator change true
to false
and vice versa."
"Eksakto. Narito ang ilang kapaki-pakinabang na expression para sa iyo:"
Pagpapahayag | Resulta |
---|---|
m && !m |
false |
m || !m |
true |
!(a && b) |
!a || !b |
!(a || b) |
!a && !b |
GO TO FULL VERSION