పాఠాలు
ప్రారంభించండి
నేర్చుకోవడం ప్రారంభించండి
CodeGym /కోర్సులు /జావా సింటాక్స్ /బూలియన్ రకం

బూలియన్ రకం

జావా సింటాక్స్
స్థాయి, పాఠం
అందుబాటులో ఉంది

కోడ్‌జిమ్ విశ్వవిద్యాలయం కోర్సులో భాగంగా మెంటర్‌తో ఉపన్యాస స్నిప్పెట్. పూర్తి కోర్సు కోసం సైన్ అప్ చేయండి.

"హాయ్, అమిగో. నేను మీకు కొత్త డేటా రకం గురించి చెబుతాను. బూలియన్ . ఈ రకం వేరియబుల్స్ రెండు విలువలను మాత్రమే తీసుకోగలవు: ఒప్పు మరియు తప్పు . "

"మేము దానిని ఎలా ఉపయోగిస్తాము?"

"ఈ రకం చాలా చోట్ల పరోక్షంగా ఉపయోగించబడుతుంది. ఏదైనా జోడింపు ఆపరేషన్ సంఖ్యను ఉత్పత్తి చేసినట్లే, ఏదైనా పోలిక ఫలితం బూలియన్ . ఇక్కడ కొన్ని ఉదాహరణలు ఉన్నాయి:"

కోడ్ వివరణ
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);
 లాజికల్ ( బూలియన్ ) వేరియబుల్‌ను ట్రూ లేదా ఫాల్స్‌తో పోల్చాల్సిన అవసరం లేదు . పోలిక యొక్క ఫలితం ఇతర వేరియబుల్‌తో సరిపోలే బూలియన్ అవుతుంది. ఉదాహరణకు, true == true మూల్యాంకనం నిజమైనది; true == తప్పుడు మూల్యాంకనం తప్పు .
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 అనే పదాన్ని వ్రాస్తానా?"

"ఆగండి. నేను వివరిస్తాను. జావాలో మూడు లాజికల్ ఆపరేటర్లు ఉన్నాయి: AND , OR మరియు NOT . మీరు వాటిని వివిధ సంక్లిష్టతతో కూడిన పరిస్థితులను రూపొందించడానికి ఉపయోగించవచ్చు. మీరు ఈ ఆపరేటర్‌లను బూలియన్ వ్యక్తీకరణలతో మాత్రమే ఉపయోగించవచ్చు . కాబట్టి, మీరు వ్రాయలేరు ( a+1) AND (3) , కానీ (a>1)AND (a<3) సరే."

" NOT ఆపరేటర్ అసాధారణమైనది: ఇది కుడి వైపున ఉన్న వ్యక్తీకరణను మాత్రమే ప్రభావితం చేస్తుంది. ఇది రెండు సంఖ్యల మధ్య గుణకార చిహ్నం కంటే ప్రతికూల సంఖ్యకు ముందు ఉన్న మైనస్ గుర్తు వలె ఉంటుంది."

"మీరు బూలియన్ (లాజికల్) వేరియబుల్స్‌పై వివిధ కార్యకలాపాలను చేయవచ్చు ."

"ఏంటి ఇష్టం?"

"ఒకసారి చూద్దాము:"

లాజికల్ ఆపరేటర్ జావా సంజ్ఞామానం వ్యక్తీకరణ ఫలితం
మరియు && నిజం  &&  నిజం నిజం
నిజం &&  తప్పు తప్పుడు
తప్పు  &&  నిజం తప్పుడు
తప్పుడు && తప్పుడు తప్పుడు
లేదా || నిజం || నిజం నిజం
నిజం || తప్పుడు నిజం
తప్పుడు || నిజం నిజం
తప్పుడు || తప్పుడు తప్పుడు
కాదు ! ! నిజం తప్పుడు
! తప్పుడు నిజం
సాధారణ కలయికలు మరియు వ్యక్తీకరణలు m && !m తప్పుడు
m || !మీ నిజం
! (a && b) !ఒక || !బి
! (ఎ ​​|| బి) !a && !b

"మీరు నాకు మరిన్ని ఉదాహరణలు ఇవ్వగలరా?"

"తప్పకుండా:"

జావా సంజ్ఞామానం తార్కిక సంజ్ఞామానం
(a<3) && (a>0) (a <3) మరియు (a>0)
(a>10) || (a<100) (a>10) లేదా (a<100)
(a<b) && (!(c<=d)) (a<b) మరియు (కాదు (c<=d))

"ఇప్పుడు, కొన్ని పనులు చేయండి."

4
టాస్క్
జావా సింటాక్స్, స్థాయి, పాఠం
లాక్ చేయబడింది
Labels and numbers
Labels and numbers
తెరవండి
8
టాస్క్
జావా సింటాక్స్, స్థాయి, పాఠం
లాక్ చేయబడింది
Describing numbers
Describing numbers
తెరవండి
4
టాస్క్
జావా సింటాక్స్, స్థాయి, పాఠం
లాక్ చేయబడింది
Positive number
Positive number
తెరవండి
4
టాస్క్
జావా సింటాక్స్, స్థాయి, పాఠం
లాక్ చేయబడింది
Positive and negative numbers
Positive and negative numbers
తెరవండి
2
టాస్క్
జావా సింటాక్స్, స్థాయి, పాఠం
లాక్ చేయబడింది
Code entry
Sometimes you don't need to think, you just need to hammer it out! As paradoxical as it may seem, sometimes your fingers will "remember" better than your conscious mind. That's why while training at the secret CodeGym center you will sometimes encounter tasks that require you to enter code. By entering code, you get used to the syntax and earn a little dark matter. What's more, you combat laziness.
తెరవండి
వ్యాఖ్యలు
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION