பிழை: சுருக்க வகுப்பை உடனடியாக உருவாக்க முடியாது

தொடரியல்

எங்கள் பிழையின் பிழை செய்தி பின்வருமாறு:

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

இது போன்ற பிழையை சந்திக்கும் போது கம்பைலரில் இருந்து நமக்குக் கிடைக்கும் மற்றொரு செய்தி இதுவாகும்.

எடுத்துக்காட்டு # 01:

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

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

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

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

எடுத்துக்காட்டு # 02:

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

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

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

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

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

முடிவுரை

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