ஜாவா டெவலப்பர் பதவிக்கான வேலை நேர்காணலில் இருந்து கேள்விகள் மற்றும் பதில்களை ஆராய்தல். பகுதி 1

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

ஜூனியர் டெவலப்பர் பதவிக்கான கேள்வி பதில்

பொதுவான கேள்விகள்

1. உங்களுக்கு என்ன வடிவமைப்பு வடிவங்கள் தெரியும்? உங்கள் வேலையில் நீங்கள் பயன்படுத்திய இரண்டு வடிவமைப்பு வடிவங்களைப் பற்றி எங்களிடம் கூறுங்கள்.

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

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

இது உங்களுக்கு போதுமானதாக இல்லாவிட்டால், வசந்த காலத்தில் கவனம் செலுத்துங்கள் (உங்களுக்கு ஏற்கனவே தெரிந்திருந்தால்), ஏனெனில் இது கட்டமைப்பின் முழு தளமாகும், இது தொடக்கத்தில் இருந்து இறுதி வரை வடிவங்களுடன் ஊடுருவுகிறது. நான் எதைப் பற்றி பேசுகிறேன் என்பதற்கான இரண்டு எடுத்துக்காட்டுகள் இங்கே:

• தொழிற்சாலை - இந்த வடிவத்தை பயன்பாட்டுச் சூழலில் (அல்லது பீன்ஃபேக்டரியில்) காணலாம்;
• சிங்கிள்டன் - அனைத்து பீன்களும் முன்னிருப்பாக சிங்கிள்டன்கள்;
• ப்ராக்ஸி - அடிப்படையில், ஸ்பிரிங் எல்லாம் இந்த மாதிரியை ஒரு வழியில் அல்லது வேறு பயன்படுத்துகிறது, எடுத்துக்காட்டாக, AOP;
• பொறுப்பின் சங்கிலி - வசந்த பாதுகாப்பை உறுதிப்படுத்தும் ஒரு முறை;
• டெம்ப்ளேட் — ஸ்பிரிங் ஜேடிபிசியில் பயன்படுத்தப்பட்டது.

ஜாவா கோர்

2. ஜாவாவில் என்ன தரவு வகைகள் உள்ளன?

ஜாவா பின்வரும் பழமையான தரவு வகைகளைக் கொண்டுள்ளது:

• பைட் - -128 முதல் 127 வரையிலான முழு எண்கள், 1 பைட்டை எடுக்கும்;
• குறுகிய - -32768 முதல் 32767 வரையிலான முழு எண்கள், 2 பைட்டுகளை எடுக்கும்;
• int — -2147483648 முதல் 2147483647 வரையிலான முழு எண்கள், 4 பைட்டுகளை எடுக்கும்;
• நீளமானது - 9223372036854775808 முதல் 9223372036854775807 வரையிலான முழு எண்கள், 8 பைட்டுகளை எடுக்கும்;
• மிதவை - -3.4E+38 முதல் 3.4E+38 வரையிலான மிதக்கும் புள்ளி எண்கள், 4 பைட்டுகள் வரை எடுக்கும்;
• இரட்டை - -1.7E+308 முதல் 1.7E+308 வரையிலான மிதக்கும் புள்ளி எண்கள், 8 பைட்டுகளை எடுக்கும்;
• char - UTF-16 இல் ஒற்றை எழுத்துகள், 2 பைட்டுகள் எடுக்கும்;
• பூலியன் உண்மை/தவறு மதிப்புகள், 1 பைட் எடுக்கும்.

குவியலில் உள்ள பொருட்களை சுட்டிக்காட்டும் குறிப்பு தரவு வகைகள் உள்ளன.

3. ஒரு பொருள் பழமையான தரவு வகைகளிலிருந்து எவ்வாறு வேறுபடுகிறது?

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

4. குறிப்பு மற்றும் மதிப்பு மூலம் வாதங்களை அனுப்புவதற்கு என்ன வித்தியாசம்?

பழமையான புலங்கள் அவற்றின் மதிப்பை சேமிக்கின்றன: எடுத்துக்காட்டாக, நாம் int i = 9 என அமைத்தால்; , பின்னர் i புலம் மதிப்பை 9 சேமிக்கிறது. ஒரு பொருளைப் பற்றிய குறிப்பு நம்மிடம் இருக்கும்போது, ​​​​அந்தப் பொருளைக் குறிக்கும் புலம் நம்மிடம் உள்ளது. வேறு வார்த்தைகளில் கூறுவதானால், பொருளின் முகவரியை நினைவகத்தில் சேமிக்கும் புலம் எங்களிடம் உள்ளது.

Cat cat = new Cat();

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

5. JVM, JDK மற்றும் JRE என்றால் என்ன?

JVM என்பது Java Virtual Machine ஐக் குறிக்கிறது , இது கம்பைலரால் முன்பே உருவாக்கப்பட்ட ஜாவா பைட்கோடை இயக்குகிறது. JRE என்பது Java Runtime Environment என்பதன் சுருக்கம் . அடிப்படையில், இது ஜாவா பயன்பாடுகளை இயக்குவதற்கான சூழல். இது JVM, நிலையான நூலகங்கள் மற்றும் ஜாவா நிரலாக்க மொழியில் எழுதப்பட்ட ஆப்லெட்டுகள் மற்றும் பயன்பாடுகளை இயக்குவதற்கான பிற கூறுகளை உள்ளடக்கியது. வேறு வார்த்தைகளில் கூறுவதானால், JRE என்பது ஒரு தொகுக்கப்பட்ட ஜாவா நிரலை இயக்க தேவையான எல்லாவற்றின் தொகுப்பாகும், ஆனால் பயன்பாடுகளை உருவாக்குவதற்கு கம்பைலர்கள் அல்லது பிழைத்திருத்தங்கள் போன்ற கருவிகள் மற்றும் பயன்பாடுகள் இதில் இல்லை. ஜேடிகே என்பது ஜாவா டெவலப்மென்ட் கிட் , இது ஜேஆர்இயின் நீட்டிப்பாகும். அதாவது, ஜாவா அப்ளிகேஷன்களை இயக்குவதற்கு மட்டுமல்ல, அவற்றை உருவாக்குவதற்கும் இது ஒரு சூழல். JDK ஆனது JRE இல் உள்ள அனைத்தையும் கொண்டுள்ளது, மேலும் பல்வேறு கூடுதல் கருவிகள் - கம்பைலர்கள் மற்றும் பிழைத்திருத்திகள் - ஜாவா பயன்பாடுகளை உருவாக்கத் தேவை (ஜாவா டாக்ஸ் அடங்கும்).

6. JVMஐ ஏன் பயன்படுத்த வேண்டும்?

மேலே குறிப்பிட்டுள்ளபடி, ஜாவா மெய்நிகர் இயந்திரம் என்பது கம்பைலரால் முன்பே உருவாக்கப்பட்ட ஜாவா பைட்கோடை இயக்கும் ஒரு மெய்நிகர் இயந்திரமாகும். இதன் பொருள் ஜேவிஎம் ஜாவா மூலக் குறியீட்டைப் புரிந்து கொள்ளவில்லை. எனவே, முதலில், நாம் .java கோப்புகளை தொகுக்கிறோம் . தொகுக்கப்பட்ட கோப்புகளில் .class உள்ளதுநீட்டிப்பு மற்றும் இப்போது பைட்கோட் வடிவத்தில் உள்ளது, இது JVM புரிந்துகொள்கிறது. ஒவ்வொரு OS க்கும் JVM வேறுபட்டது. JVM பைட்கோட் கோப்புகளை இயக்கும் போது, ​​அது இயங்கும் OSக்கு அவற்றை மாற்றியமைக்கிறது. உண்மையில், வெவ்வேறு JVMகள் இருப்பதால், JDK (அல்லது JRE) வெவ்வேறு OS க்கும் வேறுபடுகிறது (ஒவ்வொரு பதிப்பிற்கும் அதன் சொந்த JVM தேவை). பிற நிரலாக்க மொழிகளில் வளர்ச்சி எவ்வாறு செயல்படுகிறது என்பதை நினைவில் கொள்வோம். நீங்கள் ஒரு நிரலை எழுதுகிறீர்கள், அதன் குறியீடு ஒரு குறிப்பிட்ட OS க்கான இயந்திரக் குறியீட்டில் தொகுக்கப்படுகிறது, பின்னர் நீங்கள் அதை இயக்கலாம். வேறு வார்த்தைகளில் கூறுவதானால், ஒவ்வொரு தளத்திற்கும் நிரலின் வெவ்வேறு பதிப்புகளை நீங்கள் எழுத வேண்டும். ஆனால் ஜாவாவின் குறியீட்டின் இரட்டைச் செயலாக்கம் (மூலக் குறியீட்டை பைட்கோடாகத் தொகுத்தல், பின்னர் JVM மூலம் பைட்கோடைச் செயலாக்குதல்) குறுக்கு-தளம் தீர்வின் பலன்களை அனுபவிக்க உங்களை அனுமதிக்கிறது. நாம் ஒரு முறை குறியீட்டை உருவாக்கி அதை பைட்கோடில் தொகுக்கிறோம். பின்னர் எந்த OS க்கும் எடுத்துச் செல்லலாம், சொந்த JVM அதை இயக்க முடியும். மேலும் இது துல்லியமாக ஜாவாவின் புகழ்பெற்றதாகும்ஒருமுறை எழுதவும், எங்கும் இயக்கவும் அம்சம்.

7. பைட்கோட் என்றால் என்ன?

நான் மேலே கூறியது போல், கம்பைலர் ஜாவா குறியீட்டை இடைநிலை பைட்கோடாக மாற்றுகிறது (நாம் .java நீட்டிப்பு உள்ள கோப்புகளிலிருந்து .class நீட்டிப்பு கொண்ட கோப்புகளுக்கு செல்கிறோம்). பல வழிகளில், பைட்கோட் இயந்திரக் குறியீட்டைப் போன்றது, அதன் அறிவுறுத்தல் தொகுப்பு உண்மையான செயலிக்கானது அல்ல, ஆனால் மெய்நிகர் ஒன்று. இது ஒரு JIT கம்பைலருக்காக வடிவமைக்கப்பட்ட பிரிவுகளை உள்ளடக்கியிருக்கலாம், இது நிரல் இயங்கும் உண்மையான செயலிக்கான கட்டளை செயலாக்கத்தை மேம்படுத்துகிறது. JIT தொகுப்பு, ஆன்-தி-ஃப்ளை தொகுத்தல் என்றும் அழைக்கப்படுகிறது, இது நிரல் இயங்கும் போது பைட்கோடை இயந்திரக் குறியீடு அல்லது வேறு வடிவத்தில் தொகுப்பதன் மூலம் பைட்கோட் நிரலின் செயல்திறனை அதிகரிக்கும் தொழில்நுட்பமாகும். நீங்கள் யூகித்துள்ளபடி, JVM ஆனது பைட்கோடு இயங்கும் போது JIT கம்பைலரைப் பயன்படுத்துகிறது. சில மாதிரி பைட்கோடுகளைப் பார்ப்போம்: அதிகம் படிக்க முடியவில்லை, இல்லையா? நல்ல செய்தி என்னவென்றால், இந்த அறிவுறுத்தல் எங்களுக்கானது அல்ல. இது ஜே.வி.எம்.

8. ஜாவாபீனின் அம்சங்கள் என்ன?

ஜாவாபீன் என்பது சில விதிகளைப் பின்பற்றும் ஜாவா வகுப்பு. ஜாவாபீன் எழுதுவதற்கான சில விதிகள் இங்கே :

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

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

3. வகுப்பு சமம்() , hashCode() , மற்றும் toString() முறைகளை மேலெழுத வேண்டும்.

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

9. OutOfMemoryError என்றால் என்ன?

OutOfMemoryError என்பது Java Virtual Machine (JVM) தொடர்பான முக்கியமான இயக்க நேரப் பிழையாகும். ஜேவிஎம் ஒரு பொருளை ஒதுக்க முடியாதபோது இந்த பிழை ஏற்படுகிறது, ஏனெனில் அதற்கு போதுமான நினைவகம் இல்லை, மேலும் குப்பை சேகரிப்பாளரால் அதிக நினைவகத்தை ஒதுக்க முடியாது. OutOfMemoryError இன் சில வகைகள் :

• OutOfMemoryError: ஜாவா ஹீப் ஸ்பேஸ் — போதிய நினைவகம் இல்லாததால் ஜாவா குவியலில் பொருளை ஒதுக்க முடியாது. இந்த பிழை நினைவக கசிவு அல்லது தற்போதைய பயன்பாட்டிற்கு மிகவும் சிறியதாக இருக்கும் இயல்புநிலை குவியல் அளவு காரணமாக ஏற்படலாம்.

• OutOfMemoryError: GC ஓவர்ஹெட் வரம்பு மீறப்பட்டுள்ளது — ஏனெனில் பயன்பாட்டின் தரவு குவியல்களில் சரியாகப் பொருந்தவில்லை, குப்பை சேகரிப்பான் எல்லா நேரத்திலும் இயங்குகிறது, இதனால் ஜாவா நிரல் மிக மெதுவாக இயங்கும். இதன் விளைவாக, குப்பை சேகரிப்பான் மேல்நிலை வரம்பை மீறுகிறது மற்றும் இந்த பிழையால் பயன்பாடு செயலிழக்கிறது.

• OutOfMemoryError: கோரப்பட்ட வரிசை அளவு VM வரம்பை மீறுகிறது - இது குவியல் அளவைத் தாண்டிய வரிசைக்கு நினைவகத்தை ஒதுக்க பயன்பாடு முயற்சித்ததைக் குறிக்கிறது. மீண்டும், இது முன்னிருப்பாக போதுமான நினைவகம் ஒதுக்கப்படவில்லை என்று அர்த்தம்.

• OutOfMemoryError: Metaspace — குவியல் மெட்டாடேட்டாவுக்காக ஒதுக்கப்பட்ட இடம் இல்லாமல் போய்விட்டது (மெட்டாடேட்டா என்பது வகுப்புகள் மற்றும் முறைகளுக்கான வழிமுறைகள்).

• OutOfMemoryError: காரணத்திற்காக அளவு பைட்டுகளைக் கோருங்கள். இடமாற்று இடம் இல்லை - குவியலில் இருந்து நினைவகத்தை ஒதுக்க முயற்சிக்கும்போது சில பிழை ஏற்பட்டது, இதன் விளைவாக, குவியலில் போதுமான இடம் இல்லை.

10. ஸ்டாக் ட்ரேஸ் என்றால் என்ன? நான் அதை எப்படி பெறுவது?

ஸ்டேக் ட்ரேஸ் என்பது ஒரு அப்ளிகேஷனை செயல்படுத்துவதில் இது வரை அழைக்கப்பட்ட வகுப்புகள் மற்றும் முறைகளின் பட்டியலாகும். இதைச் செய்வதன் மூலம் பயன்பாட்டில் ஒரு குறிப்பிட்ட புள்ளியில் ஸ்டாக் ட்ரேஸைப் பெறலாம்:

StackTraceElement[] stackTraceElements =Thread.currentThread().getStackTrace();

இது லாஸ்ட் இன் ஃபர்ஸ்ட் அவுட் (LIFO) வரிசையில் வரிசைப்படுத்தப்பட்ட StackTraceElements வரிசையைப் பெறுகிறது . ஜாவாவில், மக்கள் ஸ்டாக் ட்ரேஸைப் பற்றி பேசும்போது, ​​​​பொதுவாக ஒரு பிழை (அல்லது விதிவிலக்கு) நிகழும்போது கன்சோலில் காட்டப்படும் ஸ்டாக் ட்ரேஸ் என்று அர்த்தம். இது போன்ற விதிவிலக்குகளிலிருந்து ஸ்டாக் ட்ரேஸைப் பெறலாம்:

StackTraceElement[] stackTraceElements;
try{
                ...
} catch (Exception e) {
   stackTraceElements = e.getStackTrace();
}

கன்சோலில் விதிவிலக்கின் ஸ்டாக் ட்ரேஸைக் காட்ட விரும்பினால்:

try{
                ...
} catch (Exception e) {
  e.printStackTrace();
}

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