பிழை

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

ஜாவாவின் விதிவிலக்கு படிநிலையின் உச்சியில் எறியக்கூடிய வகுப்பு உள்ளது, இதில் இரண்டு சந்ததியினர் உள்ளனர்:

• விதிவிலக்கு , இது உங்கள் திட்டத்தில் பிழைகளுக்கு பொறுப்பாகும்.
• இன்றைய நமது ஹீரோ - பிழை , இது JVM இல் உள்ள பிழைகளுக்கு பொறுப்பாகும்.
  இவை அநேகமாக குறியீட்டு பிழைகள் அல்ல, மாறாக பொதுவாக டெவலப்பரைச் சார்ந்து இல்லாத சிக்கல்கள் என்பது குறிப்பிடத் தக்கது.

பிழை ஏற்பட்டால் என்ன செய்வது

"பிழைகளை" பிடிக்கும்போது, ​​ஜேவிஎம்மில் உள்ள சிக்கல்களைப் பற்றி நாங்கள் பேசுவதால், பதிவு செய்வதைத் தவிர , கேட்ச் பிளாக்கில் நீங்கள் எந்தச் செயலையும் செய்ய முடியாது.

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

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

அதன்படி, தூக்கி எறியக்கூடிய வகுப்பைப் பயன்படுத்துவது நல்லது , இது பிழை மற்றும் விதிவிலக்கு இரண்டையும் பிடிக்கலாம் . இது நடைமுறையில் எப்படி இருக்கிறது?

try {
    // Your code
} catch (OutOfMemoryError outOfMemoryError) {
    // Code to catch OutOfMemoryError
}

try {
    // Your code
} catch (Error error) {
    // Code to catch all Errors
}

try {
    // Your code
} catch (Throwable throwable) {
    // Code to catch all Throwables
}

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

பொதுவான பிழைகள்

OutOfMemoryError மற்றும் StackOverflowError வகுப்புகள் மிகவும் பிரபலமான சில பிழைகள் .

OutOfMemoryError அடிக்கடி தோன்றும் போது, ​​நிரலில் பொருட்களை உருவாக்க போதுமான நினைவகம் இல்லை மற்றும் குப்பை சேகரிப்பாளரால் அதைத் தொடர முடியாது. விளைவு OutOfMemoryError ஆகும் .

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

எடுத்துக்காட்டாக, இது போன்ற குறியீடு நினைவகத்தில் நிறைய குப்பைகளை உருவாக்கும்:

while (true) {
    new Object();
}

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

public void foo() {
    foo();
}

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

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

பிழை மற்றும் விதிவிலக்கு வகைகளுக்கு இடையே உள்ள வேறுபாடு

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