பூலியன் வகை

Java தொடரியல்
நிலை 4 , பாடம் 7
கிடைக்கப்பெறுகிறது

கோட்ஜிம் பல்கலைக்கழகப் பாடத்தின் ஒரு பகுதியாக வழிகாட்டியுடன் விரிவுரைத் துணுக்கு. முழு பாடத்திற்கும் பதிவு செய்யவும்.


"வணக்கம், அமிகோ. புதிய தரவு வகையைப் பற்றி நான் உங்களுக்குச் சொல்கிறேன். பூலியன் . இந்த வகையின் மாறிகள் இரண்டு மதிப்புகளை மட்டுமே எடுக்க முடியும்: உண்மை மற்றும் தவறு . "

"அதை எப்படிப் பயன்படுத்துவது?"

"இந்த வகை பல இடங்களில் மறைமுகமாகப் பயன்படுத்தப்படுகிறது. எந்தக் கூட்டல் செயல்பாடும் எண்ணை உருவாக்குவது போல, எந்த ஒப்பீட்டின் விளைவும் பூலியன் ஆகும் . இங்கே சில எடுத்துக்காட்டுகள் உள்ளன:"

குறியீடு விளக்கம்
1
boolean m;
இந்த இரண்டு வெளிப்பாடுகளும் சமமானவை. பூலியன் மாறியின் இயல்புநிலை மதிப்பு தவறானது .
2
boolean m = false;
3
if (a > b)
    System.out.println(a);
ஒப்பீட்டின் முடிவு ( உண்மை அல்லது தவறானது ) மாறிக்கு ஒதுக்கப்படும் m. வெளிப்பாடு உண்மைக்கு மதிப்பிட்டால் நிபந்தனை திருப்தி அடையும் .
4
boolean m = (a > b);
if (m)
    System.out.println(a);
5
boolean m = (a > b);
if (m == true)
    System.out.println(a);
ஒரு தருக்க ( பூலியன் ) மாறியை உண்மை அல்லது பொய்யுடன் ஒப்பிட வேண்டிய அவசியமில்லை . ஒப்பீட்டின் விளைவாக மற்ற மாறியுடன் பொருந்தக்கூடிய பூலியனாக இருக்கும். எடுத்துக்காட்டாக, உண்மை == உண்மை என்பது உண்மைக்கு மதிப்பீடு செய்கிறது; உண்மை == பொய்யானது பொய்யை மதிப்பிடுகிறது .
6
boolean m = (a > b);
if (m)
    System.out.println(a);

"மேலும் எடுத்துக்காட்டுகள்:"

குறியீடு விளக்கம்
1
public boolean isALessThanB (int a, int b)
{
    if (a < b)
        return true;
    else
        return false;
}
இந்த முறை a எண் b எண்ணைக் காட்டிலும் குறைவாக இருப்பதைச் சரிபார்க்கிறது.

இங்கே நான்கு சமமான ஒப்பீடுகள் உள்ளன. கடைசியானது மிகவும் கச்சிதமானது மற்றும் சரியானது. எப்பொழுதும் சிறிய குறியீட்டைப் பயன்படுத்த முயற்சிக்கவும் .

2
public boolean isALessThanB (int a, int b)
{
   boolean m = (a < b);
    if (m)
        return true;
    else
        return false;
}
3
public boolean isALessThanB (int a, int b)
{
    boolean m = (a < b);
    return m;
}
4
public boolean isALessThanB (int a, int b)
{
    return a < b;
}

"நான் 0<a<b எழுத விரும்பினால் என்ன செய்வது?"

"ஜாவாவில் மூன்று செயல்களை எடுக்கும் ஒப்பீட்டு ஆபரேட்டர் இல்லை. எனவே, நீங்கள் இதை இப்படி செய்ய வேண்டும்: (0<a) மற்றும் (a<b) ."

"நான் AND என்ற வார்த்தையை எழுதுகிறேனா?"

"காத்திருங்கள். நான் அதை விளக்குகிறேன். ஜாவாவில் மூன்று லாஜிக்கல் ஆபரேட்டர்கள் உள்ளன: மற்றும் , அல்லது மற்றும் இல்லை . பல்வேறு சிக்கலான நிலைமைகளை உருவாக்க நீங்கள் அவற்றைப் பயன்படுத்தலாம். இந்த ஆபரேட்டர்களை பூலியன் வெளிப்பாடுகளுடன் மட்டுமே பயன்படுத்த முடியும். எனவே, உங்களால் எழுத முடியாது ( a+1) மற்றும் (3) , ஆனால் (a>1)AND (a<3) சரி."

" NOT ஆபரேட்டர் அசாதாரணமானது: இது வலதுபுறத்தில் உள்ள வெளிப்பாட்டை மட்டுமே பாதிக்கிறது. இது இரண்டு எண்களுக்கு இடையே உள்ள பெருக்கல் குறியை விட எதிர்மறை எண்ணுக்கு முன் உள்ள கழித்தல் குறி போன்றது."

"நீங்கள் பூலியன் (தர்க்கரீதியான) மாறிகளில் பல்வேறு செயல்பாடுகளைச் செய்யலாம் ."

"என்ன மாதிரி?"

"பார்ப்போம்:"

தருக்க ஆபரேட்டர் ஜாவா குறியீடு வெளிப்பாடு விளைவாக
மற்றும் && உண்மை  &&  உண்மை உண்மை
உண்மை &&  பொய் பொய்
பொய்  &&  உண்மை பொய்
பொய் && பொய் பொய்
அல்லது || உண்மை || உண்மை உண்மை
உண்மை || பொய் உண்மை
பொய் || உண்மை உண்மை
பொய் || பொய் பொய்
இல்லை ! ! உண்மை பொய்
! பொய் உண்மை
பொதுவான சேர்க்கைகள் மற்றும் வெளிப்பாடுகள் மீ && !மீ பொய்
மீ || !மீ உண்மை
! (a && b) !அ || !பி
! (அ || ஆ) !a && !b

"இன்னும் உதாரணங்கள் தர முடியுமா?"

"நிச்சயம்:"

ஜாவா குறியீடு தருக்கக் குறியீடு
(a<3) && (a>0) (a < 3) மற்றும் (a>0)
(a>10) || (அ<100) (a>10) அல்லது (a<100)
(a<b) && (!(c<=d)) (a<b) மற்றும் (இல்லை (c<=d))

"இப்போது, ​​சில பணிகளைச் செய்யுங்கள்."

கருத்துக்கள்
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION