జావా డెవలపర్ స్థానం కోసం ఉద్యోగ ఇంటర్వ్యూ నుండి ప్రశ్నలు మరియు సమాధానాలను అన్వేషించడం. 1 వ భాగము

హాయ్! కోడ్‌జిమ్ విభిన్న వ్యక్తుల సమూహాన్ని ఒకచోట చేర్చింది. మనలో కొందరు జావా డెవలపర్‌లుగా మారడం కంటే మరేమీ కోరుకోరు మరియు మేము అభివృద్ధి కోసం చాలా సమయం మరియు కృషిని వెచ్చిస్తున్నాము. ఇతరులు ఇప్పటికే జావా డెవలపర్లు. ఏదైనా సందర్భంలో, మీరు సాంకేతిక ఇంటర్వ్యూలలో పరీక్షించబడటానికి సిద్ధంగా ఉండాలి. ఇవి తేలిక కాదు. వారికి భావోద్వేగ మరియు సాంకేతిక తయారీ రెండూ అవసరం. నేను ఇటీవల జావా డెవలపర్ స్థానాల కోసం ఇంటర్వ్యూ ప్రశ్నల యొక్క కొన్ని పెద్ద జాబితాలను చూశాను. ప్రశ్నలు వివిధ స్థాయిలుగా విభజించబడ్డాయి: జూనియర్, మధ్య స్థాయి మరియు సీనియర్. భయపడవద్దు: అన్ని ప్రశ్నలు సులభంగా ఉండవు, కానీ నక్షత్రం గుర్తు ఉన్నవి చాలా అరుదుగా అడిగేవి. ప్రశ్నలు బాగున్నాయి మరియు నేను వాటిలో చాలా వాటికి సమాధానమివ్వడానికి ప్రయత్నించాలనుకుంటున్నాను. స్పష్టంగా, ఇవన్నీ ఒకే కథనంలో సరిపోవు. అన్ని తరువాత, అక్కడ చాలా ప్రశ్నలు ఉన్నాయి. అంటే ఈ ఇంటర్వ్యూ ప్రశ్నలకు సమాధానాలతో కథనాల మొత్తం సిరీస్ ఉంటుంది. నేను వెంటనే కొన్ని అంశాలను నొక్కి చెబుతాను: సమాధానాలు చిన్నవిగా ఉంటాయి, ఎందుకంటే చాలా వివరంగా వ్రాసిన సమాధానాలు ప్రత్యేక కథనంలోకి తీసుకోవచ్చు. అలాగే, ఇంటర్వ్యూలలో చాలా వివరణాత్మకమైన మరియు భారీ సమాధానాలు కోరబడవు, ఎందుకంటే మీ ఇంటర్వ్యూయర్‌కు అవసరమైన అంశాలపై మిమ్మల్ని ఇంటర్వ్యూ చేయడానికి ఒక గంట మాత్రమే ఉంటుంది (మరియు,

జూనియర్ డెవలపర్ స్థానం కోసం Q&A

సాధారణ ప్రశ్నలు

1. మీకు ఏ డిజైన్ నమూనాలు తెలుసు? మీరు మీ పనిలో ఉపయోగించిన రెండు డిజైన్ నమూనాల గురించి మాకు చెప్పండి.

భారీ రకాల నమూనాలు ఉన్నాయి. డిజైన్ నమూనాలతో మిమ్మల్ని మీరు పూర్తిగా పరిచయం చేసుకోవాలనుకునే మీలో, "హెడ్ ఫస్ట్. డిజైన్ ప్యాటర్న్స్" పుస్తకాన్ని చదవమని నేను సిఫార్సు చేస్తున్నాను. ఇది చాలా ప్రాథమిక డిజైన్ నమూనాల వివరాలను సులభంగా తెలుసుకోవడానికి మీకు సహాయం చేస్తుంది. మీరు ఉద్యోగ ఇంటర్వ్యూలో పేర్కొనగల డిజైన్ నమూనాల పరంగా, ఈ క్రిందివి గుర్తుకు వస్తాయి:

• బిల్డర్ — తరచుగా ఉపయోగించే టెంప్లేట్, వస్తువు సృష్టికి క్లాసిక్ విధానానికి ప్రత్యామ్నాయం;
• వ్యూహం — తప్పనిసరిగా పాలిమార్ఫిజమ్‌ను సూచించే నమూనా. అంటే, మనకు ఒక ఇంటర్‌ఫేస్ ఉంది, కానీ ఫంక్షన్‌కు పంపబడిన నిర్దిష్ట ఇంటర్‌ఫేస్ అమలుపై ఆధారపడి ప్రోగ్రామ్ యొక్క ప్రవర్తన మారుతుంది (వ్యూహ నమూనా ఇప్పుడు జావా అప్లికేషన్‌లలో దాదాపు ప్రతిచోటా ఉపయోగించబడుతుంది).

ఇది మీకు సరిపోకపోతే, స్ప్రింగ్‌పై శ్రద్ధ వహించండి (మీకు ఇప్పటికే దాని గురించి తెలిసి ఉంటే), ఎందుకంటే ఇది ఫ్రేమ్‌వర్క్‌ల యొక్క మొత్తం ప్లాట్‌ఫారమ్, ఇది మొదటి నుండి చివరి వరకు నమూనాలతో విస్తరించి ఉంటుంది. నేను మాట్లాడుతున్న దానికి సంబంధించిన కొన్ని ఉదాహరణలు ఇక్కడ ఉన్నాయి:

• కర్మాగారం — ఈ నమూనాను ApplicationContext (లేదా BeanFactoryలో) చూడవచ్చు;
• సింగిల్టన్ - అన్ని బీన్స్ డిఫాల్ట్‌గా సింగిల్‌టన్‌లు;
• ప్రాక్సీ — ప్రాథమికంగా, స్ప్రింగ్‌లోని ప్రతిదీ ఈ నమూనాను ఒక విధంగా లేదా మరొక విధంగా ఉపయోగిస్తుంది, ఉదాహరణకు, AOP;
• చైన్ ఆఫ్ రెస్పాన్సిబిలిటీ — స్ప్రింగ్ సెక్యూరిటీని ఆధారం చేసే నమూనా;
• టెంప్లేట్ — స్ప్రింగ్ JDBCలో ఉపయోగించబడింది.

జావా కోర్

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 బైట్‌లను తీసుకుంటాయి;
• boolean true/false విలువలు, 1 బైట్‌ను తీసుకుంటాయి.

మరియు కుప్పపై ఉన్న వస్తువులను సూచించే రిఫరెన్స్ డేటా రకాలు ఉన్నాయి.

3. ఒక వస్తువు ఆదిమ డేటా రకాల నుండి ఎలా భిన్నంగా ఉంటుంది?

మొదటి వ్యత్యాసం ఆక్రమించబడిన మెమరీ మొత్తం: ఆదిమలు చాలా తక్కువ తీసుకుంటాయి ఎందుకంటే అవి వాటి స్వంత విలువను మాత్రమే కలిగి ఉంటాయి, కానీ వస్తువులు చాలా విభిన్న విలువలను కలిగి ఉంటాయి - రెండు ఆదిమ మరియు ఇతర వస్తువులకు సూచనలు. రెండవ వ్యత్యాసం ఇది: జావా అనేది ఆబ్జెక్ట్-ఓరియెంటెడ్ లాంగ్వేజ్, కాబట్టి జావాలోని ప్రతిదీ వస్తువుల మధ్య పరస్పర చర్య. ఆదిమాంశాలు ఇక్కడ అంతగా సరిపోవు. నిజానికి, అందుకే జావా 100% ఆబ్జెక్ట్ ఓరియెంటెడ్ లాంగ్వేజ్ కాదు. రెండవది నుండి అనుసరించే మూడవ వ్యత్యాసం ఏమిటంటే, జావా ఆబ్జెక్ట్ ఇంటరాక్షన్‌లపై దృష్టి సారించినందున, వస్తువులను నిర్వహించడానికి అనేక విభిన్న విధానాలు ఉన్నాయి. ఉదాహరణకు, కన్స్ట్రక్టర్లు, పద్ధతులు, మినహాయింపులు (ప్రధానంగా వస్తువులతో పని చేస్తాయి) మొదలైనవి. మరియు ఈ ఆబ్జెక్ట్-ఓరియెంటెడ్ ఎన్విరాన్మెంట్‌లో ఏదో ఒకవిధంగా ఆదిమానవులు పని చేయడానికి, జావా సృష్టికర్తలు ముందుకు వచ్చారుఆదిమ రకాల రేపర్లు ( పూర్ణాంకం , అక్షరం , డబుల్ , బూలియన్ ...)

4. రిఫరెన్స్ ద్వారా మరియు విలువ ద్వారా ఆర్గ్యుమెంట్‌లను పాస్ చేయడం మధ్య తేడా ఏమిటి?

ఆదిమ ఫీల్డ్‌లు వాటి విలువను నిల్వ చేస్తాయి: ఉదాహరణకు, మనం int i = 9ని సెట్ చేస్తే; , అప్పుడు i ఫీల్డ్ విలువ 9ని నిల్వ చేస్తుంది. మనకు ఒక వస్తువుకు సూచన ఉన్నప్పుడు, ఆ వస్తువుకు సూచనతో మనకు ఫీల్డ్ ఉందని అర్థం. మరో మాటలో చెప్పాలంటే, ఆబ్జెక్ట్ యొక్క చిరునామాను మెమరీలో నిల్వ చేసే ఫీల్డ్ మనకు ఉంది.

Cat cat = new Cat();

దీనర్థం వస్తువుకు సూచన ఉన్న ఫీల్డ్‌లు కూడా విలువలను నిల్వ చేస్తాయి . వాటి విలువలు మెమరీ చిరునామాలు. అంటే, పిల్లి కొత్త క్యాట్() వస్తువు యొక్క మెమరీ చిరునామాను నిల్వ చేస్తుంది . మేము ఒక పద్ధతికి వాదనను పంపినప్పుడు, దాని విలువ కాపీ చేయబడుతుంది. ఆదిమ విషయంలో, ఆదిమ విలువ కాపీ చేయబడుతుంది. దీని ప్రకారం, పద్ధతి కాపీతో పనిచేస్తుంది. కాపీని మార్చినప్పుడు, అసలు ప్రభావితం కాదు. సూచన రకం విషయంలో, మెమరీ చిరునామా యొక్క విలువ కాపీ చేయబడుతుంది. దీని ప్రకారం, రెండు రిఫరెన్స్ వేరియబుల్స్ ఒకే వస్తువును సూచించే చిరునామాలను నిల్వ చేస్తాయి. మరియు ఆబ్జెక్ట్‌ని మార్చడానికి మనం ఈ కొత్త రిఫరెన్స్‌ని ఉపయోగిస్తే, అది కూడా పాత రిఫరెన్స్‌కి మార్చబడిందని మనం కనుగొంటాము. అన్నింటికంటే, ఇద్దరూ ఒకే వస్తువును సూచిస్తారు.

5. JVM, JDK మరియు JRE అంటే ఏమిటి?

JVM అంటే జావా వర్చువల్ మెషీన్ , ఇది కంపైలర్ ద్వారా ముందుగా రూపొందించబడిన జావా బైట్‌కోడ్‌ని అమలు చేస్తుంది. JRE అంటే జావా రన్‌టైమ్ ఎన్విరాన్‌మెంట్ . ప్రాథమికంగా, ఇది జావా అప్లికేషన్లను అమలు చేయడానికి ఒక పర్యావరణం. ఇది JVM, స్టాండర్డ్ లైబ్రరీలు మరియు జావా ప్రోగ్రామింగ్ లాంగ్వేజ్‌లో వ్రాసిన ఆప్లెట్‌లు మరియు అప్లికేషన్‌లను అమలు చేయడానికి ఇతర భాగాలను కలిగి ఉంటుంది. మరో మాటలో చెప్పాలంటే, JRE అనేది కంపైల్ చేయబడిన జావా ప్రోగ్రామ్‌ను అమలు చేయడానికి అవసరమైన ప్రతిదాని యొక్క ప్యాకేజీ, కానీ ఇది అప్లికేషన్‌లను అభివృద్ధి చేయడానికి కంపైలర్‌లు లేదా డీబగ్గర్స్ వంటి సాధనాలు మరియు యుటిలిటీలను కలిగి ఉండదు. JDK అంటే జావా డెవలప్‌మెంట్ కిట్ , ఇది JRE యొక్క పొడిగింపు. అంటే, ఇది జావా అప్లికేషన్‌లను అమలు చేయడానికి మాత్రమే కాకుండా, వాటిని అభివృద్ధి చేయడానికి కూడా పర్యావరణం. JDK JREలోని అన్నింటినీ కలిగి ఉంటుంది, అలాగే వివిధ అదనపు సాధనాలు — కంపైలర్‌లు మరియు డీబగ్గర్లు — Java అప్లికేషన్‌లను (జావా డాక్స్‌తో సహా) సృష్టించడానికి అవసరం.

6. JVMని ఎందుకు ఉపయోగించాలి?

పైన పేర్కొన్న విధంగా, జావా వర్చువల్ మెషీన్ అనేది కంపైలర్ ద్వారా ముందుగా రూపొందించబడిన జావా బైట్‌కోడ్‌ను అమలు చేసే వర్చువల్ మెషీన్. దీని అర్థం JVM జావా సోర్స్ కోడ్‌ని అర్థం చేసుకోలేదు. కాబట్టి, మొదట, మేము .java ఫైళ్లను కంపైల్ చేస్తాము. కంపైల్ చేయబడిన ఫైల్‌లు .class ని కలిగి ఉంటాయిపొడిగింపు మరియు ఇప్పుడు బైట్‌కోడ్ రూపంలో ఉన్నాయి, దీనిని JVM అర్థం చేసుకుంది. ప్రతి OSకి JVM భిన్నంగా ఉంటుంది. JVM బైట్‌కోడ్ ఫైల్‌లను రన్ చేసినప్పుడు, అది రన్ అవుతున్న OS కోసం వాటిని అడాప్ట్ చేస్తుంది. వాస్తవానికి, వేర్వేరు JVMలు ఉన్నందున, JDK (లేదా JRE) కూడా వేర్వేరు OSకి భిన్నంగా ఉంటాయి (ప్రతి సంస్కరణకు దాని స్వంత JVM అవసరం). ఇతర ప్రోగ్రామింగ్ భాషలలో అభివృద్ధి ఎలా పనిచేస్తుందో గుర్తు చేసుకుందాం. మీరు ప్రోగ్రామ్‌ను వ్రాస్తారు, ఆపై దాని కోడ్ నిర్దిష్ట OS కోసం మెషిన్ కోడ్‌గా కంపైల్ చేయబడుతుంది, ఆపై మీరు దాన్ని అమలు చేయవచ్చు. మరో మాటలో చెప్పాలంటే, మీరు ప్రతి ప్లాట్‌ఫారమ్ కోసం ప్రోగ్రామ్ యొక్క విభిన్న సంస్కరణలను వ్రాయాలి. కానీ జావా కోడ్ యొక్క డబుల్ ప్రాసెసింగ్ (సోర్స్ కోడ్‌ను బైట్‌కోడ్‌గా సంకలనం చేయడం, ఆపై JVM ద్వారా బైట్‌కోడ్‌ను ప్రాసెస్ చేయడం) క్రాస్-ప్లాట్‌ఫారమ్ సొల్యూషన్ యొక్క ప్రయోజనాలను ఆస్వాదించడానికి మిమ్మల్ని అనుమతిస్తుంది. మేము కోడ్‌ను ఒకసారి సృష్టించి బైట్‌కోడ్‌లో కంపైల్ చేస్తాము. అప్పుడు మనం దానిని ఏదైనా OSకి తీసుకెళ్లవచ్చు మరియు స్థానిక JVM దీన్ని అమలు చేయగలదు. మరియు ఇది ఖచ్చితంగా జావా యొక్క లెజెండరీఒకసారి వ్రాయండి, ఎక్కడైనా రన్ చేయి ఫీచర్.

7. బైట్‌కోడ్ అంటే ఏమిటి?

నేను పైన చెప్పినట్లుగా, కంపైలర్ జావా కోడ్‌ను ఇంటర్మీడియట్ బైట్‌కోడ్‌గా మారుస్తుంది (మేము .java పొడిగింపుతో ఉన్న ఫైల్‌ల నుండి .class పొడిగింపుతో ఫైల్‌లకు వెళ్తాము). అనేక విధాలుగా, బైట్‌కోడ్ మెషీన్ కోడ్‌ను పోలి ఉంటుంది, దాని సూచనల సెట్ నిజమైన ప్రాసెసర్ కోసం కాదు, కానీ వర్చువల్ ఒకటి. ఇది JIT కంపైలర్ కోసం రూపొందించబడిన విభాగాలను కలిగి ఉంటుంది, ఇది ప్రోగ్రామ్ రన్ అవుతున్న వాస్తవ ప్రాసెసర్ కోసం కమాండ్ ఎగ్జిక్యూషన్‌ను ఆప్టిమైజ్ చేస్తుంది. JIT కంపైలేషన్, ఆన్-ది-ఫ్లై కంపైలేషన్ అని కూడా పిలుస్తారు, ఇది ప్రోగ్రామ్ నడుస్తున్నప్పుడు బైట్‌కోడ్‌ను మెషిన్ కోడ్ లేదా మరొక ఫార్మాట్‌లో కంపైల్ చేయడం ద్వారా బైట్‌కోడ్ ప్రోగ్రామ్ పనితీరును పెంచే సాంకేతికత. మీరు ఊహించినట్లుగా, JVM బైట్‌కోడ్‌ని అమలు చేస్తున్నప్పుడు JIT కంపైలర్‌ని ఉపయోగిస్తుంది. కొన్ని నమూనా బైట్‌కోడ్‌ను పరిశీలిద్దాం: చాలా చదవగలిగేది కాదు, అవునా? శుభవార్త ఏమిటంటే, ఈ సూచన మాకు ఉద్దేశించినది కాదు. ఇది JVM కోసం.

8. జావాబీన్ యొక్క లక్షణాలు ఏమిటి?

జావాబీన్ అనేది కొన్ని నియమాలను అనుసరించే జావా క్లాస్. జావాబీన్ రాయడానికి ఇక్కడ కొన్ని నియమాలు ఉన్నాయి :

1. క్లాస్ తప్పనిసరిగా పబ్లిక్ యాక్సెస్ మాడిఫైయర్‌తో ఖాళీ (వాదన లేని) కన్స్ట్రక్టర్‌ని కలిగి ఉండాలి. ఈ కన్స్ట్రక్టర్ ఎటువంటి అనవసరమైన సమస్యలు లేకుండా తరగతి యొక్క వస్తువును సృష్టించడాన్ని సాధ్యం చేస్తుంది (తద్వారా వాదనలతో అనవసరమైన ఫిదాలింగ్ ఉండదు).

2. అంతర్గత ఫీల్డ్‌లు గెట్ మరియు సెట్ ఇన్‌స్టాన్స్ మెథడ్స్ ద్వారా యాక్సెస్ చేయబడతాయి , ఇవి ప్రామాణిక అమలును కలిగి ఉండాలి. ఉదాహరణకు, మనకు నేమ్ ఫీల్డ్ ఉంటే, అప్పుడు మనకు getName మరియు setName మొదలైనవి ఉండాలి . ఇది బీన్స్ కంటెంట్‌ను ఎలాంటి ఇబ్బంది లేకుండా స్వయంచాలకంగా పొందడానికి మరియు సెట్ చేయడానికి వివిధ సాధనాలను (ఫ్రేమ్‌వర్క్‌లు) అనుమతిస్తుంది.

3. తరగతి తప్పనిసరిగా సమానం() , hashCode() , మరియు toString() పద్ధతులను భర్తీ చేయాలి.

4. తరగతి తప్పనిసరిగా సీరియల్‌గా ఉండాలి. అంటే, ఇది తప్పనిసరిగా సీరియలైజ్ చేయగల మార్కర్ ఇంటర్‌ఫేస్‌ని కలిగి ఉండాలి లేదా ఎక్స్‌టర్నలైజేబుల్ ఇంటర్‌ఫేస్‌ని అమలు చేయాలి. బీన్ యొక్క స్థితి విశ్వసనీయంగా సేవ్ చేయబడుతుంది, నిల్వ చేయబడుతుంది మరియు పునరుద్ధరించబడుతుంది.

9. OutOfMemoryError అంటే ఏమిటి?

OutOfMemoryError అనేది జావా వర్చువల్ మెషీన్ (JVM)కి సంబంధించిన క్లిష్టమైన రన్‌టైమ్ లోపం. 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();
}

అదనంగా, లోపం, ఎంపిక చేయని మినహాయింపు లేదా హ్యాండిల్ చేయని తనిఖీ చేయబడిన మినహాయింపు సంభవించినట్లయితే, అప్లికేషన్ క్రాష్ అయినప్పుడు మేము స్వయంచాలకంగా కన్సోల్‌లో మినహాయింపు స్టాక్ ట్రేస్‌ను పొందుతాము. ఇక్కడ కన్సోల్‌లో స్టాక్ ట్రేస్‌కి ఒక చిన్న ఉదాహరణ ఉంది: మరియు ఆ గమనికపై, మేము ఈ రోజు ఈ అంశంపై మా చర్చను ముగించాము.