பல்வேறு ஆபரேட்டர்களுடன் பணிபுரியும் நுணுக்கங்கள்

1. பூலியன் செயல்பாடுகள்

தி |மற்றும் &ஆபரேட்டர்கள் எண்களுக்கு மட்டுமல்ல, பூலியன் வெளிப்பாடுகளுக்கும் பயன்படுத்தப்படலாம்.

ஆனால், உங்களுக்கு ஏற்கனவே தெரியும், ஆபரேட்டர்கள் &&உள்ளனர் ||. |அதற்கு பதிலாக ||, மற்றும் &அதற்கு பதிலாக நாம் ஏன் பயன்படுத்த வேண்டும் &&? இதில் ஏதாவது பயன் உண்டா? இருப்பதாகத் தெரிகிறது. சில சமயம்.

மற்றும் லாஜிக்கல் ஆபரேட்டர்கள் சோம்பேறிக் கொள்கை என்று அழைக்கப்படுவதைப் பின்பற்றி இடமிருந்து வலமாக ||இயக்கப்படுகின்றன .&&

(expression1) || (expression2) || (expression3)

expression1 சமமாக இருந்தால் true, மதிப்பீடு செய்வதில் எந்த அர்த்தமும் இல்லை expression2 மற்றும் expression3: விளைவு trueபொருட்படுத்தாமல் இருக்கும்.

அதன்படி, வெளிப்பாடுகளை மதிப்பிடும்போது (அவை இடமிருந்து வலமாக மதிப்பிடப்படுகின்றன), நாம் பெற்றவுடன் true, மீதமுள்ள வெளிப்பாடுகளின் மதிப்பீடு தவிர்க்கப்படுகிறது . முறை அழைப்புகளைச் சேர்த்தால், இந்த expression2 முறைகள் அழைக்கப்படாது !expression3

தருக்க ஆபரேட்டருக்கும் இதுவே செல்கிறது &&:

(expression1) && (expression2) && (expression3)

expression1சமமாக இருந்தால் false, மதிப்பீடு செய்வதில் எந்த அர்த்தமும் இல்லை expression2மற்றும் expression3: விளைவு falseபொருட்படுத்தாமல் இருக்கும்.

இது போன்ற விஷயங்களை எழுத உங்களை அனுமதிக்கும் முக்கியமான உண்மை இது:

String s = null;
if (s != null && s.length() > 0) {

மேலே உள்ள உதாரணம் உங்களுக்கு ஒருபோதும் NullPointerException கிடைக்காது , ஏனெனில் முதல் பகுதி இருந்தால் s.length()மட்டுமே செயல்படுத்தப்படும் .s! = nulltrue

sக்கு சமமாக இருந்தால் , nullஆபரேட்டரின் இடதுபுறம் &&உள்ள பகுதி false, முழு பூலியன் வெளிப்பாட்டின் முடிவு false, எனவே வலதுபுறம் ( s.length() > 0) பகுதி மதிப்பீடு செய்யப்படாது.

2. ஜாவாவில் செயல்பாட்டு முன்னுரிமை

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

ஜாவாவில் உள்ள ஆபரேட்டர்களுக்கும் முன்னுரிமை வரிசை உள்ளது. வித்தியாசம் என்னவென்றால், அ) அவற்றில் சற்று அதிகமாக உள்ளன, ஆ) சில ஆபரேட்டர்களுக்கு, இயக்கங்கள் இடமிருந்து வலமாக மதிப்பிடப்படுகின்றன, மற்றவர்களுக்கு - வலமிருந்து இடமாக.

அனைத்து ஜாவா ஆபரேட்டர்களுடன் ஒரு அட்டவணை இங்கே:

மேல் வரிசையில் அதிக முன்னுரிமை கொண்ட ஆபரேட்டர்கள் உள்ளனர். முன்னுரிமையை வெளிப்படையாக அமைக்க அடைப்புக்குறிகள் ()பயன்படுத்தப்படுகின்றன. ஒரு வரிசை மாறியின் குறிப்பிட்ட குறியீட்டில் ஒரு உறுப்பை அணுக சதுர அடைப்புக்குறிகள் []பயன்படுத்தப்படுகின்றன. புள்ளி ஆபரேட்டர் ( .) என்பது ஒரு பொருள் அல்லது வகுப்பின் குறிப்பைப் பயன்படுத்தி புலங்கள் மற்றும் முறைகளை அணுக பயன்படுகிறது.

ஆபரேட்டர்கள் அட்டவணையில் குறைவாக இருப்பதால், அவர்களின் முன்னுரிமை குறைவாக இருக்கும்.

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

ஜாவாவில், நீங்கள் ஏதாவது எழுதலாம் if (a & 1<< b > ~c), ஆனால் நீங்கள் எழுதக்கூடாது. நீங்கள் கம்பைலருக்கு மட்டுமல்ல, மற்ற புரோகிராமர்களுக்கும் குறியீட்டை எழுதுகிறீர்கள். குறியீட்டை எவ்வளவு படிக்க முடியுமோ அவ்வளவு சிறந்தது.

3. முன்னொட்டு மற்றும் பின்னொட்டு அதிகரிப்பு

உங்களுக்கு ஏற்கனவே தெரியும், ஜாவாவில் இன்கிரிமென்ட் ஆபரேட்டர் ( ++) மற்றும் டிகிரிமென்ட் ஆபரேட்டர் ( --) உள்ளது. முறையே, அவை ஒரு மாறியின் மதிப்பை அதிகரிக்கவும் குறைக்கவும் செய்கின்றன 1.

இந்த ஆபரேட்டர்களில் இரண்டு வகைகள் உள்ளன என்பது உங்களுக்குத் தெரியாதது: முன்னொட்டு (ஆபரேட்டர் மாறிக்கு முன் வைக்கப்படுகிறது) மற்றும் போஸ்ட்ஃபிக்ஸ் (ஆபரேட்டர் மாறிக்குப் பிறகு வைக்கப்படுகிறது). இரண்டு வகையான ஆபரேட்டர்கள் சற்று வித்தியாசமாக வேலை செய்கிறார்கள்.

ஜாவாவில், நீங்கள் இது போன்ற ஒரு வெளிப்பாட்டை எழுதலாம்:

int a = 5;
int b = a++;

ஆபரேட்டர் ++ஒரு மாறிக்குப் பிறகு தோன்றி, மாறி சில வெளிப்பாட்டின் ஒரு பகுதியாக இருந்தால் (மேலே உள்ள எடுத்துக்காட்டில் உள்ளது), பின்னர் வெளிப்பாடு மாறியின் தற்போதைய மதிப்பைப் பயன்படுத்தும், அதன் பிறகுதான் மாறி 1.

வேறு வார்த்தைகளில் கூறுவதானால், இதுபோன்ற ஒன்று நடக்கும்:

int a = 5;
int b = a;
a = a + 1;

அதாவது, முதல் பார்வையில் நீங்கள் நினைப்பது போல் bஇருக்காது .56

ஆபரேட்டர் ++மாறிக்கு முன் இருந்தால் மற்றும் மாறி சில வெளிப்பாட்டின் ஒரு பகுதியாக இருந்தால், அது முதலில் அதிகரிக்கப்படும் 1, பின்னர் மட்டுமே அதன் மதிப்பு வெளிப்பாட்டில் பயன்படுத்தப்படும்.

int a = 5;
int b = ++a;

int a = 5;
a = a + 1;
int b = a;

இங்கே, bசமமாக இருக்கும் 6.

ஜாவா புரோகிராமர்கள் யாரேனும் ஒருவர் ஜாவா புரோகிராமர் என்பதை தீர்மானிக்க ஒரு உதாரணம் கூட உள்ளது:

int a = 5;
int b = ++a + ++a;

ஆம், நீங்களும் எழுதலாம்.

இந்த உதாரணம் நன்றாக தொகுத்து இது போன்றதாக மாறும்:

int a = 5;

a = a + 1;
int v1 = a;

a = a + 1;
int v2 = a;

int b = v1 + v2;

ஆபரேட்டரைப் பொறுத்தவரை --, எல்லாம் ஒரே மாதிரியாக இருக்கும்.