ఒకవేళ జావా స్టేట్‌మెంట్‌లు

జావాలో if else స్టేట్‌మెంట్ షరతులతో కూడిన ప్రకటన . జావా గణితం వంటి పరిస్థితులను ఉపయోగిస్తుంది, బూలియన్ ఫలితాలను ఇచ్చే పోలికలను అనుమతిస్తుంది. కాబట్టి మీరు ఇన్‌పుట్‌లను మీరు పేర్కొన్న స్టాటిక్ విలువల సెట్‌తో ఎలా పోలుస్తారో చూడడానికి మీరు పరీక్షించవచ్చు. ఫలితం బూలియన్ అయినందున, కేవలం రెండు ఫలితాలు మాత్రమే ఉన్నాయి: 0 లేదా 1; అంటే తప్పు , లేదా నిజం . if else java స్టేట్‌మెంట్ రెండు ప్రాథమిక మార్గాల్లో రూపొందించబడింది. జావాలో మొదటిది సింపుల్ అయితే స్టేట్‌మెంట్. రెండవది అయితే-అప్పుడు-ఎక్కువ . వేరే స్టేట్‌మెంట్‌ను సెకండరీ ఎగ్జిక్యూషన్ పాత్‌గా ఉపయోగించడం వల్ల ఈ షరతులతో కూడిన నియంత్రణకు చాలా సౌలభ్యం లభిస్తుంది.

స్టేట్‌మెంట్ జావా సింటాక్స్ అయితే

జావాలోని if స్టేట్‌మెంట్ కింది వాక్యనిర్మాణాన్ని ఉపయోగిస్తుంది:

If (condition) {
	//do this code
}

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

int a = 20;
if (a%2 == 0) {
	System.out.println(a + " is even.");
}
…

పై కోడ్‌లోని అవుట్‌పుట్ "20 ఈజ్ ఈవెన్" అవుతుంది. ఎందుకంటే, పూర్ణాంకం aని 2తో భాగించినప్పుడు మిగిలిన భాగం ఎలా ఉంటుందనేది పరీక్షించబడిన షరతు. డీబగ్గింగ్ కోడ్ సమయంలో ఏమి జరుగుతుందో తనిఖీ చేయడానికి Java if స్టేట్‌మెంట్‌ను ఉపయోగించడం మంచి మార్గం. మీ కోడ్ సరిగ్గా ప్రతిస్పందించనట్లయితే, మీరు ఊహించిన విధంగా పని చేస్తున్నట్లయితే నిర్ధారణను ప్రింట్ చేయమని మీ కోడ్‌కు చెప్పే షరతును చేర్చవచ్చు. ఈ విధంగా, కోడ్ ఎక్కడ తప్పుగా ప్రవర్తిస్తుందో మీరు తగ్గించవచ్చు.

If Else స్టేట్‌మెంట్‌ల కోసం జావా సింటాక్స్

if else java సింటాక్స్ క్రింది విధంగా ఉంది:

if (condition) {
	//do this code
} else {
	//do this code
}

మీరు చూడగలిగినట్లుగా, else స్టేట్‌మెంట్‌ను జోడించడం ద్వారా, మీరు బూలియన్ ప్రతిస్పందన తప్పు అయినప్పుడు ప్రేరేపించే స్టేట్‌మెంట్‌ల యొక్క రెండవ సెట్‌ను సృష్టించవచ్చు . మన ఒరిజినల్ కోడ్ ఫ్రాగ్‌మెంట్‌కి వేరే స్టేట్‌మెంట్‌ను జోడించి , లూప్ కోసం ఒక సాధారణ ఇంక్రిమెంటింగ్ లోపల దానిని గూడు చేద్దాం.

…
for (int x = 1; x <=4; x++) {
	if (x%2 == 0) {
		System.out.println(x + "  is even.");
	} else {
		System.out.println(x + " is odd.");
	}
}

x 1 వద్ద ప్రారంభమై లూప్‌లోకి ప్రవేశించి, అదే షరతులతో పరీక్షించబడుతుందని మీరు చూడవచ్చు . ఎందుకంటే 1ని 2తో భాగించినప్పుడు తిరిగి వచ్చే మాడ్యులస్ సున్నా కాదు, తప్పుడు బూలియన్ తిరిగి ఇవ్వబడుతుంది. అది ఇనీషియల్ if స్టేట్‌మెంట్‌ను దాటవేస్తుంది మరియు else స్టేట్‌మెంట్‌ను ట్రిగ్గర్ చేస్తుంది. కాబట్టి ఈ లూప్ అవుట్‌పుట్ ఇలా ఉంటుంది:

1 is odd.
2 is even.
3 is odd.
4 is even.

ఇది సరదాగా ఉన్నప్పటికీ, జావా యొక్క ప్రాక్టికాలిటీ వేరే స్టేట్‌మెంట్‌లు ఏమిటని మీరు ఆశ్చర్యపోవచ్చు . వాస్తవ ప్రపంచంలో, వారు నిజమైన మరియు తప్పుడు బూలియన్ విలువలపై మాత్రమే ఆధారపడతారు కాబట్టి వారికి భారీ ప్రయోజనాలు ఉన్నాయి . ఫోర్ట్‌నైట్ వంటి వీడియో గేమ్, నిర్ణయించబడిన హిట్‌బాక్స్‌లో షాట్ ల్యాండ్ అయినట్లయితే, ఒక ఆటగాడు మరొక ప్లేయర్‌ను తాకినట్లు నిర్ధారించడానికి if else స్టేట్‌మెంట్‌ను ఉపయోగిస్తుంది. పాస్‌వర్డ్ చెకర్ మీ ఇన్‌పుట్‌ను నిల్వ చేసిన పాస్‌వర్డ్‌తో పోల్చి చూస్తుంది మరియు అది సరిపోలితే, అది మిమ్మల్ని లోపలికి అనుమతిస్తుంది. లేదంటే, పాస్‌వర్డ్‌లు సరిపోలడం లేదని మీకు చెబుతుంది. కాబట్టి, if else java స్టేట్‌మెంట్ ఎంత బహుముఖంగా ఉందో కూడా పరిగణనలోకి తీసుకుంటే, మీరు మరిన్ని షరతులను జోడించడం ద్వారా దాన్ని మరింత బహుముఖంగా చేయవచ్చు. దీన్నే నెస్టెడ్ ఐతే వేరే అంటారుజావా ప్రకటన.

Nested if else and else if Java Statements

మీరు గూడు కట్టడం ప్రారంభించినప్పుడు లేదా జావా ప్రకటనలను పునరావృతం చేసినప్పుడు , మీరు బూలియన్ విలువ కోసం తనిఖీ చేయబడిన షరతుల గొలుసును సృష్టిస్తారు. వాక్యనిర్మాణం ఇలా కనిపిస్తుంది:

if (condition) {
	//do this code
} else if (condition) {
	//do this code
} else if (condition) {
 		//do this code
} else {
	//do this code
}

మీకు నచ్చినంత కాలం మీరు Java else if స్టేట్‌మెంట్‌ను పునరావృతం చేయవచ్చు మరియు సిస్టమ్ ఇన్‌పుట్‌ను పరీక్షించడాన్ని కొనసాగిస్తుంది. ఒక షరతు నిజమైన బూలియన్‌ను తిరిగి అందించిన వెంటనే, ఆ బ్రాకెట్ కోడ్ విభాగం అమలు చేయబడుతుంది మరియు ప్రోగ్రామ్ పూర్తిగా ఉంటే కోడ్ విభాగాన్ని వదిలివేస్తుందని గమనించడం ముఖ్యం .

జావా స్టేట్‌మెంట్‌లు ఉంటే నెస్టెడ్

వేరే కండిషన్ లేని స్టేట్‌మెంట్‌లు ఉంటే మీరు కూడా గూడు కట్టుకోవచ్చు . కాబట్టి కోడ్, ఇది నిజం అయితే, మరియు ఇది నిజం అయితే దీన్ని చేయండి. ఇక్కడ వాక్యనిర్మాణాన్ని చూడండి:

if (condition) {
	if (condition) {
		if (condition) {
			//do this code
		}
	}
}

చివరి బ్రాకెట్ కోడ్ అమలు కావడానికి ముందు కోడ్ మూడు విభిన్న పరిస్థితులను తనిఖీ చేస్తుందని మీరు చూడవచ్చు. సంఖ్య ప్రధానమైనదా కాదా అని తనిఖీ చేయడానికి మనం దీన్ని ఉపయోగించవచ్చు. నెస్టెడ్ if స్టేట్‌మెంట్‌లను ఉపయోగించి పూర్ణాంకం xని తనిఖీ చేసే క్రింది సూడో కోడ్‌ను చూడండి .

if (x  > 1) {
	if (x is odd) {
		if (x modulo (every integer from 2 to x-1) != 0) {
			// integer is prime
		}
	}
}

ఈ కోడ్ మూడు తనిఖీలను అమలు చేస్తుంది:

• 1 ప్రధానం కానందున పూర్ణాంకం 1 కంటే ఎక్కువగా ఉందా?
• పూర్ణాంకం బేసిగా ఉందా, ఎందుకంటే 2 పైన ఉన్న బేసి సంఖ్యలు మాత్రమే ప్రధానమైనవి?
• x కంటే తక్కువ 2 నుండి ఒకటి వరకు ఏదైనా ఇతర పూర్ణాంకం దానిలోకి సమానంగా విభజించగలదా?

మూడు షరతులు నెరవేరినట్లయితే, అప్పుడు సంఖ్య ప్రధానం. మీరు నేర్చుకున్న వాటిని బలోపేతం చేయడానికి, మా జావా కోర్సు నుండి వీడియో పాఠాన్ని చూడమని మేము మీకు సూచిస్తున్నాము