மற்றபடி ஜாவா அறிக்கைகள்

ஜாவாவில் if else ஸ்டேட்மெண்ட் என்பது நிபந்தனைக்குட்பட்ட அறிக்கை . ஜாவா கணிதம் போன்ற நிலைமைகளைப் பயன்படுத்துகிறது, இது பூலியன் முடிவுகளை வழங்கும் ஒப்பீடுகளை அனுமதிக்கிறது. எனவே உள்ளீடுகளை நீங்கள் குறிப்பிடும் நிலையான மதிப்புகளுடன் அவை எவ்வாறு ஒப்பிடுகின்றன என்பதைப் பார்க்கவும். முடிவு பூலியன் என்பதால், இரண்டு சாத்தியமான முடிவுகள் மட்டுமே உள்ளன: 0 அல்லது 1; அதாவது பொய் , அல்லது உண்மை . if else java அறிக்கை இரண்டு அடிப்படை வழிகளில் கட்டமைக்கப்பட்டுள்ளது. முதலாவது ஜாவாவில் ஒரு எளிமையான அறிக்கை . இரண்டாவது என்றால்-பிறகு வேறு . வேறொரு அறிக்கையை இரண்டாம் நிலை செயலாக்க பாதையாகப் பயன்படுத்துவது இந்த நிபந்தனைக் கட்டுப்பாட்டை அதிக நெகிழ்வுத்தன்மையை அளிக்கிறது.

அறிக்கை ஜாவா தொடரியல் என்றால்

Java இல் if அறிக்கை பின்வரும் தொடரியல் பயன்படுத்துகிறது:

If (condition) {
	//do this code
}

நிபந்தனை உண்மையின் பூலியன் மதிப்பை வழங்கினால் , அடைப்புக்குறிக்குள் உள்ள குறியீடு செயல்படுத்தப்படும். மதிப்பு தவறு என திரும்பினால் , அடைப்புக்குறியிடப்பட்ட குறியீடு தவிர்க்கப்படும். இந்த குறியீட்டு பகுதியைக் கவனியுங்கள்.

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

மேலே உள்ள குறியீட்டின் வெளியீடு "20 is even" என்று இருக்கும். ஏனென்றால், முழு எண் a ஐ 2 ஆல் வகுக்கும் போது மீதமுள்ளவை என்னவாக இருக்கும் என்பது சோதிக்கப்பட்ட நிபந்தனையாகும். பிழைத்திருத்த குறியீட்டின் போது என்ன நடக்கிறது என்பதைச் சரிபார்க்க Java if அறிக்கையைப் பயன்படுத்துவது ஒரு சிறந்த வழியாகும். உங்கள் குறியீடு சரியாகப் பதிலளிக்கவில்லை எனில், எதிர்பார்த்தபடி செயல்பட்டால் உறுதிப்படுத்தலை அச்சிட உங்கள் குறியீட்டைச் சொல்லும் நிபந்தனையை நீங்கள் செருகலாம். இந்த வழியில், குறியீடு தவறாக செயல்படும் இடத்தை நீங்கள் சுருக்கலாம்.

If Else அறிக்கைகளுக்கான ஜாவா தொடரியல்

if else java தொடரியல் பின்வருமாறு:

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

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

…
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 ஸ்டேட்மெண்ட்டைத் தவிர்த்துவிட்டு வேறு அறிக்கையைத் தூண்டுகிறது. எனவே இந்த வளையத்திற்கான வெளியீடு இருக்கும்:

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 அறிக்கையை மீண்டும் செய்யலாம் , மேலும் கணினி உள்ளீட்டை தொடர்ந்து சோதிக்கும். ஒரு நிபந்தனை உண்மையான பூலியனைத் தந்தவுடன் , அந்த அடைப்புக்குறியிடப்பட்ட குறியீட்டின் பிரிவு செயல்படுத்தப்படும் மற்றும் நிரல் வேறு குறியீடு பிரிவை முழுவதுமாக விட்டுவிடும் என்பதைக் கவனத்தில் கொள்ள வேண்டும்.

Nested If Java Statements

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

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

இறுதி அடைப்புக்குறி குறியீடு இயங்குவதற்கு முன், குறியீடு மூன்று வெவ்வேறு நிபந்தனைகளைச் சரிபார்க்கிறது என்பதை நீங்கள் பார்க்கலாம். ஒரு எண் முதன்மையானதா இல்லையா என்பதைச் சரிபார்க்க இதைப் பயன்படுத்தலாம். பின்வரும் போலிக் குறியீட்டைப் பார்க்கவும், இது nested 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 முதல் ஒன்று வரை உள்ள வேறு எந்த முழு எண்ணையும் சமமாகப் பிரிக்க முடியுமா?

மூன்று நிபந்தனைகளும் பூர்த்தி செய்யப்பட்டால், எண் முதன்மையானது. நீங்கள் கற்றுக்கொண்டதை வலுப்படுத்த, எங்கள் ஜாவா பாடத்திட்டத்திலிருந்து வீடியோ பாடத்தைப் பார்க்க பரிந்துரைக்கிறோம்