Sa Java, ang ' Hindi 'operator na may ' kung ' binabaligtad ng kundisyon ang kinalabasan na ibinalik bilang resulta ng ' kung ” kondisyon na pahayag. Lalo na, kapag nakikitungo sa mga kumplikadong kondisyon, ang hindi operator ay maaaring gawing simple ang lohika. Ang paggamit ng operator na 'Hindi' sa kondisyong 'kung' ay maaaring gawing mas maigsi at mas madaling maunawaan ang code, lalo na kapag nagpapahayag ng mga negatibong kundisyon.
Ang artikulong ito ay nagpapakita ng pamamaraan upang gamitin ang Hindi operator sa kung kundisyon sa Java.
Paano Gamitin ang Not Operator sa If Conditions sa Java?
Ang operator na 'Hindi' ay kinakatawan ng tandang padamdam (!). Ito ay isang uri ng lohikal na operator sa Java na tinatanggihan ang ibinigay na halaga ng Boolean, at ito ay ginagamit sa ' kung ” kundisyon upang suriin ang kabaligtaran na sagot/halaga para sa isang ibinigay na kundisyon. Ito ay kapaki-pakinabang sa pagsasagawa ng isang partikular na aksyon o pagpapatupad ng isang bloke ng code kapag ang isang partikular na kundisyon ay hindi natugunan.
Syntax
Ang syntax ay naglalaman ng ' kung ' kondisyon na pahayag na may ' Hindi ” operator. Gayundin, ipagpalagay natin na ang ' gumawa ng anumang bagay() ” function ay nagbabalik ng true o false lamang:
kung ( ! gumawa ng anumang bagay ( ) )
{
// magsagawa ng ilang piraso ng code
}
iba pa {
// magsagawa ng ilang piraso ng code
}
Sa itaas na syntax:
- Una, ang ibinalik na halaga para sa ' gumawa ng anumang bagay() Ang function na ” ay tinanggihan at ang halagang ito ay ipinasa bilang isang kundisyon sa “ kung ” pahayag.
- Susunod, ang ilang code ay ipinasok sa ibang bahagi na gagana lamang kung ang ' kung ” mali ang pahayag.
Halimbawa 1: Pagsusuri ng Dibisyon Gamit ang Not Operator sa Kondisyong Kung
Upang ipaliwanag ang konsepto ng ' Hindi 'operator sa ' kung ” kondisyon, sundin ang code sa ibaba:
Dibisyon ng klase {pampublikong static void main ( String [ ] args ) {
int na numero = 19 ;
int div = 5 ;
kung ( sa isa % div ! = 0 ) {
System.out.println ( num + 'ay Hindi Nahahati ng' + div ) ;
} iba pa {
System.out.println ( num + 'ay Ganap na Nahati sa pamamagitan ng ' + div ) ;
}
}
}
Paliwanag ng code sa itaas:
- Una, lumikha ng dalawang variable na pinangalanang ' sa isa 'at' div ” at magbigay ng mga dummy na halaga sa kanila.
- Susunod, ang ' kung 'Ang pahayag ay ginagamit na unang nagsasagawa ng dibisyon sa parehong mga operator at pagkatapos ay gumagamit ng ' Hindi pantay ' tanda.
- ito' Hindi 'Ginagawa ng operator ang pagtanggi sa kundisyon at magiging totoo lamang kung ang resulta ay hindi katumbas ng ' 0 ”.
- Sa huli, lumikha ng ibang bahagi para sa paghawak kung ang resulta ay katumbas ng ' 0 ”.
Pagkatapos ng pagpapatupad ng nakasaad sa itaas na code:
Ipinapakita ng snapshot sa itaas na ang mga ibinigay na halaga ay hindi mahahati kaya naman ang ' kung ” bahagi ay naisakatuparan.
Halimbawa 2: Paghahanap ng Mas Malaking Numero Gamit ang Not Operator sa If Condition
Sa pamamagitan ng paggamit ng ' Hindi 'operator sa ' kung ” conditional statement, ang mas malaking bilang sa pagitan ng maramihang mga variable ay maaari ding matagpuan.
Bisitahin natin ang code sa ibaba para sa isang mas mahusay na paliwanag:
class Greater {pampublikong static void main ( String [ ] args ) {
int a = dalawampu ;
int b = 10 ;
kung ( ! ( a > = b ) ) {
System.out.println ( isang + ' ay mas kaunti sa ' + b ) ;
} iba pa {
System.out.println ( isang + 'ay mas malaki kaysa sa' + b ) ;
}
}
}
Paliwanag ng code sa itaas:
- Una, dalawang variable ang sinisimulan. Pagkatapos, ang ' Hindi Ang operator ay inilapat sa isang kundisyon upang suriin kung ang ' a Ang variable ay mas malaki kaysa sa o katumbas ng ' b ” variable.
- Pagkatapos nito, mag-print ng kamag-anak na mensahe sa ' kung ” block ng pahayag.
- Sa huli, nagpi-print ng mensahe na nasa ' iba pa ” bahagi.
Pagkatapos ng pagpapatupad ng code sa itaas:
Ang snapshot sa itaas ay nagpapakita na ang mas malaking halaga ay natagpuan sa tulong ng ' Hindi ” operator.
Konklusyon
Ang ' Hindi 'operator sa' kung ” Ang mga kundisyon ay nagbibigay ng flexibility at kalinawan sa pagpapahayag ng mga negadong kundisyon, pagpapasimple ng kumplikadong lohika, at pagpapahusay sa pagiging madaling mabasa ng code. Sa pamamagitan ng paggamit nito, ang mga linya ng code ay bumaba nang husto, nakakatipid ng maraming oras ng programmer, at binabawasan ang mga pagkakataon ng mga lohikal na error. Ipinakita ng artikulong ito ang pamamaraan upang magamit ang operator na Hindi sa kung kundisyon sa Java.