IntelliJ ஐடியாவில் பிழைத்திருத்தம்: ஒரு தொடக்க வழிகாட்டி

CodeGym சமூகத்தில் உள்ள அனைவருக்கும் வணக்கம்! இன்று பிழைத்திருத்தம் பற்றி பேசலாம் — அது என்ன மற்றும் IntelliJ IDEA இல் பிழைத்திருத்தம் செய்வது எப்படி. இந்த கட்டுரை ஏற்கனவே ஜாவா கோர் பற்றி குறைந்தபட்ச அறிவு உள்ளவர்களுக்காக வடிவமைக்கப்பட்டுள்ளது. நூலகங்களை வெளியிட எந்த கட்டமைப்புகளும் அல்லது சிக்கலான நடைமுறைகளும் இருக்காது. ஒரு நிதானமான உலா. எனவே உங்களுக்கு வசதியாக இருங்கள் மற்றும் தொடங்குவோம்!

உங்களுக்கு பிழைத்திருத்த முறை ஏன் தேவை

உடனடியாக நமக்காக ஒன்றைத் தெளிவுபடுத்துவோம்: பிழைகள் இல்லாமல் குறியீடு இல்லை... இப்படித்தான் வாழ்க்கை இயங்குகிறது. எனவே, நாம் எதிர்பார்த்தபடி நமது குறியீடு செயல்படவில்லை என்றால் நாம் துண்டு துண்டாக விழுந்து விட்டுவிடக்கூடாது. ஆனால் நாம் என்ன செய்ய வேண்டும்? System.out.printlnசரி, எல்லா இடங்களிலும் அறிக்கைகளை வைத்து, பிழையைக் கண்டறியும் நம்பிக்கையில் கன்சோல் வெளியீட்டின் மூலம் சீப்பு செய்யலாம் . கவனமாக உள்நுழைவதைப் பயன்படுத்தி நீங்கள் பிழைத்திருத்தம் செய்யலாம் (மற்றும் மக்கள் செய்யலாம்). உங்கள் குறியீட்டை உள்ளூர் கணினியில் இயக்க முடிந்தால், பிழைத்திருத்த பயன்முறையைப் பயன்படுத்துவது நல்லது. இந்த கட்டுரையில் IntelliJ IDEA ஐப் பயன்படுத்தி ஒரு திட்டத்தை பிழைத்திருத்தம் செய்வது பற்றி பரிசீலிப்போம் என்பதை இப்போதே கவனிக்க விரும்புகிறேன்.

பிழைத்திருத்த முறை என்றால் என்ன?

பிழைத்திருத்த பயன்முறை என்பது இயங்கும் குறியீட்டை பிழைத்திருத்தம் செய்வதற்கான (சரிபார்ப்பு) ஆகும். நியமிக்கப்பட்ட இடங்களில் செயல்படுத்துவதை நிறுத்தி, விஷயங்கள் எவ்வாறு முன்னேறுகின்றன என்பதைப் பார்ப்பதை இது சாத்தியமாக்குகிறது. குறியீட்டில் ஒரு குறிப்பிட்ட இடத்தில் நிரலின் நிலையைப் புரிந்துகொள்ள இது உதவுகிறது. கடிகாரத்தை நிறுத்திவிட்டு எல்லாவற்றையும் பக்கத்தில் இருந்து பார்க்க முடியும் போல. குளிர், சரியா? எங்கள் அன்பான IntelliJ IDEA மேம்பாட்டு சூழலைப் பயன்படுத்தி பயன்பாடுகளை எவ்வாறு பிழைத்திருத்தம் செய்வது என்பதை விரைவாகவும் எளிதாகவும் கற்றுக்கொள்வதே எங்கள் நோக்கம்.

நீங்கள் பிழைத்திருத்தத்தைத் தொடங்க வேண்டும்

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

1. IntelliJ IDEA பதிப்பு 2019.3.1 அல்லது அதற்கு மேற்பட்டது. யாரிடமாவது இது இல்லை என்றால், நீங்கள் பதிவிறக்கம் செய்யக்கூடிய இணைப்பு இங்கே உள்ளது . சமூகப் பதிப்பைப் பதிவிறக்கவும் - அதுதான் நான் பயன்படுத்தும் பதிப்பாகும்.
2. இந்த GitHub திட்டத்தை குளோன் செய்து IDEA மூலம் இறக்குமதி செய்யவும்.

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

ஒரு பிட் தியரி... நான் உறுதியளிக்கிறேன் :D

சிறிது கூட பிழைத்திருத்தத்தைத் தொடங்க, பிரேக் பாயிண்ட் என்றால் என்ன என்பதை நீங்கள் புரிந்து கொள்ள வேண்டும் மற்றும் சில ஹாட் கீகளை நன்கு அறிந்திருக்க வேண்டும். பிரேக்பாயிண்ட் என்பது ஒரு சிறப்பு மார்க்கர் ஆகும், இது பயன்பாட்டின் செயல்பாட்டினை எங்கு நிறுத்த விரும்புகிறீர்கள் என்பதைக் குறிக்கிறது, இது பயன்பாட்டின் நிலையை அடிப்படையாகக் கொண்டது . இடது பக்க பேனலில் இடது கிளிக் செய்வதன் மூலமோ அல்லது குறியீடு இருப்பிடத்தைக் கிளிக் செய்து Ctrl+F8 ஐ அழுத்துவதன் மூலமோ பிரேக்பாயிண்ட்டை அமைக்கலாம் . மூன்று வகையான முறிவுப் புள்ளிகளைப் பார்ப்போம்: வரி முறிவுப் புள்ளிகள், புலக் கண்காணிப்புப் புள்ளிகள் மற்றும் முறை முறிவுப் புள்ளிகள். இது எப்படி இருக்கிறது:

• ஒரு வரியில்:

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

• ஒரு முறையில்:

• ஒரு வகுப்பில்:

பிரேக் பாயின்ட்களைச் சேர்ப்பதற்குப் பயன்படுத்தப்படும் அதே படிகளைப் பின்பற்றுவதன் மூலம் அவற்றை அகற்றலாம். நீங்கள் அவற்றை செயலிழக்க (முடக்க) விரும்பும் சூழ்நிலைகள் உள்ளன. இதைச் செய்ய, பிழைத்திருத்த பிரிவில் உள்ள ஐகானைக் கண்டறியவும். இது அனைத்து முறிவு புள்ளிகளையும் முடக்கும். என்ன பிரேக் பாயிண்ட்கள் அமைக்கப்பட்டுள்ளன என்பதைப் பார்க்க, நீங்கள் கீழ் இடது மூலையில் உள்ள பிழைத்திருத்தப் பகுதிக்குச் சென்று ஐகானைக் கண்டறியலாம் அல்லது Ctrl+Shift+F8 ஐ அழுத்தவும் : பிரேக் பாயின்ட்களின் பட்டியலுக்குச் சென்றால், பின்வருவனவற்றைக் காண்போம்: இரண்டு பிரேக் பாயிண்டுகள் உள்ளன. இங்கே:

• Bee.java:24 — வரி 24 இல் தேனீ வகுப்பில்
• Main.java:14 — வரி 14 இல் முதன்மை வகுப்பில்

ப்ராஜெக்ட்டை குளோன் செய்திருந்தால், இந்த பிரேக் பாயிண்ட்டுகள் தானாக அமைக்கப்படாது என்பதை நினைவில் கொள்ளவும்: அவற்றை நீங்களே அமைக்க வேண்டும்! ஜாவா விதிவிலக்கு பிரேக் பாயிண்ட்ஸ் பிரிவும் உள்ளது . இது மிகவும் பயனுள்ளதாக உள்ளது. இங்கே நீங்கள் ஒரு மறைமுகமான பிரேக் பாயிண்ட்டைச் சேர்க்கலாம், இதனால் ஏதேனும் விதிவிலக்கு அல்லது குறிப்பிட்ட விதிவிலக்கு எறிவதற்கு முன் நிரல் நிறுத்தப்படும். RuntimeExceptionக்கு ஒரு மறைமுகமான இடைவெளியைச் சேர்ப்போம். இதைச் செய்வது எளிது. மேல் இடது மூலையில் உள்ள "+" ஐகானைக் கண்டறியவும். அதைக் கிளிக் செய்து, Java Exception Breakpoints என்பதைத் தேர்ந்தெடுக்கவும் : தோன்றும் சாளரத்தில், நீங்கள் சேர்க்க விரும்பும் விதிவிலக்கின் பெயரை எழுதவும், பட்டியலில் இருந்து தேர்ந்தெடுத்து சரி என்பதைக் கிளிக் செய்யவும். சில நடைமுறையில் செல்வேன்.

பிழைத்திருத்தம் என்று அழைக்கப்படும் இந்த விஷயத்தைச் செய்யலாம்!

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

• தேனீ - ஒரு சாதாரண தொழிலாளி தேனீ
• BeeQueen - ராணி தேனீ
• தேன்கூடு - தேன்கூடு
• HoneyPlant - தேன் சேகரிக்கப்படும் ஒரு தேன் ஆலை (அமிர்த ஆதாரம்).
• முக்கிய — இங்கேதான் நாம் கண்டறிகிறோம் public static void main(), செயல்படுத்தல் தொடங்கும் முறை.

நாம் முறையை இயக்கினால் main(), எங்கள் நிரல் தேனின் அளவைக் கணக்கிடவில்லை என்பது மட்டுமல்லாமல், அது ஒரு விதிவிலக்கையும் தருகிறது என்பதைக் காண்கிறோம்... பிரச்சனை என்ன என்பதை ஆராய்ந்து தீர்மானிக்க வேண்டும். கீழ் வலது மூலையில் உள்ள ட்ரேஸ் ஸ்டேக்கிலிருந்து, ஒரு RuntimeException இல் எறியப்பட்டிருப்பதைக் காணலாம் HoneyPlant.java:20: அதைத்தான் மேலே பேசிக் கொண்டிருந்தோம். main()பிழைத்திருத்த பயன்முறையில் முறையை இயக்குவதன் மூலம் இந்த RuntimeException ஐ பார்க்கலாம் . இதைச் செய்ய, IntelliJ IDEA இல் உள்ள பச்சை முக்கோண அம்புக்குறியைக் கிளிக் செய்யவும் main(). இதன் விளைவாக, விதிவிலக்கு எறியப்படுவதற்கு முன்பே நிரலை நிறுத்துவோம், மேலும் இந்த ஐகானைக் காண்போம்: கிடைக்கக்கூடிய அனைத்து தகவல்களையும் பெற, பிழைத்திருத்தப் பிரிவில் பார்க்க வேண்டும். இது ஒரு மாறிகளைக் கொண்டுள்ளதுபயன்பாட்டின் இந்தப் பகுதியில் கிடைக்கும் அனைத்து மாறிகளையும் காட்டும் பலகம்:

• தேன் = 1.0;
• தேன் கொள்ளளவு = -1.0.

விதிவிலக்கை எறிவது அர்த்தமுள்ளதாக இருக்கிறது, ஏனென்றால் ஒரு தேன் ஆலைக்கு எதிர்மறையான அளவு தேன் இருக்க முடியாது. ஆனால் இது ஏன் நடக்கிறது? எல்லாவற்றிற்கும் மேலாக, 15-17 வரிகளில், தேன் வழங்கல் தீர்ந்துவிட்டதா என்பதைச் சரிபார்த்து, அது இருந்தால் பூஜ்ஜியத்தைத் திருப்பித் தருகிறோம்:

	if (nectar == 0) {
   	     return 0;
}

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

	if (nectarCapacity == 0) {
   	     return 0;
}

main()இப்போது முறையை சாதாரண முறையில் இயக்கவும் (Run 'Main.main()'). விதிவிலக்கு எதுவும் இல்லை, மேலும் நிரல் வேலை செய்கிறது: பயன்பாடு முடிவடையும் வரை இயங்குகிறது மற்றும் பின்வரும் பதிலை அளிக்கிறது:

"33.0 honey was produced by 7 bees from 2 honey plants"

இப்போது எல்லாம் சரியாகிவிடும், ஆனால் இந்த பதில் தவறானது... README ஆவணத்தின் படி , தேன் 2 முதல் 1 என்ற விகிதத்தில் தேனாக மாற்றப்படுகிறது:

## Documentation
Presentation based on honey production.

**Note**: 2 units of nectar = 1 unit of honey

முக்கிய முறையானது, முறையே 30 மற்றும் 40 அலகுகள் தேன் கொண்ட இரண்டு தேன் செடிகளைக் கொண்டுள்ளது. எனவே நாம் இறுதியில் 35 யூனிட் தேனுடன் முடிக்க வேண்டும். ஆனால் நிரல் நமக்கு 33 என்று சொல்கிறது. மற்ற இரண்டு யூனிட்கள் எங்கே போனது? நாம் கண்டுபிடிக்கலாம்! இதைச் செய்ய, Main.main()வரி 28 இல் உள்ள முறையில் ஒரு முறிவுப் புள்ளியை அமைக்கவும், அங்கு beeHive.populateHoney()அழைக்கப்படுகிறது மற்றும் main()பிழைத்திருத்த பயன்முறையில் முறையை இயக்கவும்: இந்த புள்ளியை இன்னும் விரிவாகக் கருதுவோம். நிரல் 28 வரியை இயக்குவதற்கு முன் செயல்படுத்துவதை நிறுத்தியது. கீழ் பகுதியில், பிழைத்திருத்தப் பகுதியைக் காண்கிறோம், இது இயங்கும் பயன்பாட்டைப் பற்றிய அனைத்து தகவல்களையும் காட்டுகிறது. ஏற்கனவே குறிப்பிட்டுள்ளபடி, மாறிகள் பலகத்தில் பயன்பாட்டின் இந்தப் பகுதியிலிருந்து கிடைக்கும் அனைத்து மாறிகள் மற்றும் பொருள்கள் உள்ளன. ஃபிரேம்கள் பலகம் பயன்பாடு கடந்து செல்லும் படிகளைக் காட்டுகிறது - நீங்கள் முந்தைய (பிரேம்கள்) படிகளைப் பார்க்கலாம் மற்றும் எல்லா உள்ளூர் தரவையும் பார்க்கலாம். நிரலை தொடர்ந்து இயக்க, கீழே காட்டப்பட்டுள்ளபடி, F9 அல்லது பச்சை ஐகானை அழுத்தவும் : நிரலை நிறுத்த, சிவப்பு சதுரத்தில் கிளிக் செய்யவும்: பிழைத்திருத்த பயன்முறையில் பயன்பாட்டை மறுதொடக்கம் செய்ய, அம்புக்குறியைக் கிளிக் செய்யவும்: மேலும், நீங்கள் தொடரலாம் இரண்டு விசைகளைப் பயன்படுத்தி படிப்படியாக பயன்பாடு:

• F8 - முறைகளுக்குள் நுழையாமல் குறியீட்டின் மூலம் படி;
• F7 - குறியீட்டின் மூலம் படி மற்றும் முறைகளில் படி.

எங்கள் விஷயத்தில், முறைக்குள் நுழைய, F7 ஐ அழுத்த வேண்டும் beeHive.populateHoney(). அதில் அடியெடுத்து வைக்கும்போது, ​​​​நாம் பெறுகிறோம்: இப்போது நாம் F8 ஐப் பயன்படுத்தி இந்த முறையைப் பயன்படுத்தி அதில் என்ன நடக்கிறது என்பதை விவரிப்போம்:

• வரி 25 - அனைத்து தேனீக்களிடமிருந்தும் தேன் சேகரிக்க ஸ்ட்ரீம் API பயன்படுத்தப்படுகிறது
• வரி 26 - புதிதாக உருவாக்கப்பட்ட தேன் ஏற்கனவே உள்ள தேனுடன் சேர்க்கப்படுகிறது;
• வரி 27 - ராணிக்கு 2 யூனிட் தேன் ஒதுக்கப்படுகிறது
• வரி 28 - இந்த இரண்டு அலகுகளும் மொத்த தேனில் இருந்து அகற்றப்படுகின்றன
• வரி 29 - இந்த தேனை ராணி சாப்பிடுகிறாள்.

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

## Documentation
Presentation based on honey production.

**Note**:
* 2 units of nectar = 1 unit of honey
* The queen bee eats 2 units of honey every time when beehive is replenished with honey.

செய்யப்பட்டது. நாங்கள் கண்டறிந்த அனைத்து பிழைகளையும் சரிசெய்துள்ளோம். நாம் அமைதியாக ஒரு ஸ்மக் தோற்றத்துடன் தொடரலாம், கொஞ்சம் காபி பருகலாம் மற்றும் ஸ்டாக் ஓவர்ஃப்ளோ கோட்ஜிம் பற்றிய கட்டுரைகளைப் படிக்கலாம் :)

சுருக்கமாகக் கூறுவோம்

இந்த கட்டுரையில், நாங்கள் கற்றுக்கொண்டோம்:

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

படிக்க வேண்டிய கட்டுரை

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