స్టాక్ ట్రేస్

"హాయ్! ఈ రోజు నేను మీకు స్టాక్ ట్రేస్ అంటే ఏమిటో చెబుతాను. అయితే ముందుగా నేను మీకు స్టాక్ అంటే ఏమిటో చెప్పాలి."

"పేపర్ల కుప్పను ఊహించుకోండి - ఒక నిర్దిష్ట ఉద్యోగి కోసం ఆదేశాలు. మీరు పైల్ పైన కొత్త పనిని ఉంచవచ్చు లేదా మీరు పై నుండి ఒక పనిని తీసుకోవచ్చు. దీనర్థం పనులు స్వీకరించిన క్రమంలో అమలు చేయబడవు. . పైల్‌పై ఇటీవల ఉంచిన టాస్క్ మొదటగా అమలు చేయబడుతుంది. సేకరణలోని మూలకాలను ఈ విధంగా రూపొందించడం ఒక స్టాక్‌ను ఏర్పరుస్తుంది .

" జావా దాని కోసం ఒక ప్రత్యేక సేకరణను కలిగి ఉంది – స్టాక్ . ఇది 'ఒక మూలకాన్ని జోడించడం' మరియు 'ఒక మూలకాన్ని (పొందండి)' పద్ధతులను కలిగి ఉన్న సేకరణ. మీరు ఊహించినట్లుగా, చివరిగా జోడించిన మూలకం మొదటిది అవుతుంది తీసుకొబొయేది."

"సూటిగా అనిపిస్తుంది."

"గ్రేట్. ఇప్పుడు నేను స్టాక్ ట్రేస్ అంటే ఏమిటో వివరిస్తాను ."

"జావా ప్రోగ్రామ్ మెథడ్‌లో ఎ మెథడ్ బి అని పిలవబడుతుంది , దీనిని మెథడ్ సి అని పిలుస్తారు, దీనిని మెథడ్ డి అని పిలుస్తారు . మెథడ్ బి నుండి నిష్క్రమించడానికి , మనం మొదట మెథడ్ సి నుండి నిష్క్రమించాలి మరియు అలా చేయడానికి - మనం మొదట డి మెథడ్ నుండి నిష్క్రమించాలి . ఇది ప్రవర్తన స్టాక్‌ను పోలి ఉంటుంది."

"దానిని పోలి ఉందని ఎందుకు అంటున్నావు?"

"మా కాగితాల స్టాక్ మధ్యలో ఏదో ఒక పనిని పొందడానికి, ఉదాహరణకు, మీరు మొదట దాని పైన ఉన్న అన్ని టాస్క్‌లను అమలు చేయాలి."

"కొంత సారూప్యత ఉంది, కానీ నేను ప్రతిదీ సరిగ్గా అర్థం చేసుకున్నానని నాకు ఖచ్చితంగా తెలియదు."

"చూడండి. స్టాక్ అనేది మూలకాల సమితి. ఒక కుప్పలో కాగితపు ముక్కల వలె. పై నుండి మూడవ కాగితాన్ని తీసుకోవడానికి, మీరు మొదట రెండవదాన్ని తీసుకోవాలి మరియు దాని కోసం మీరు మొదటిదాన్ని తీసుకోవాలి. మీరు ఎల్లప్పుడూ కాగితం ముక్కలను ఉంచవచ్చు మరియు తీసుకోవచ్చు, కానీ మీరు ఎల్లప్పుడూ మొదటి కాగితాన్ని తీసుకోవాలి."

"ఫంక్షన్ కాల్‌లకు కూడా ఇది వర్తిస్తుంది. మెథడ్ A కాల్స్ మెథడ్ B , ఇది మెథడ్ C అని పిలుస్తుంది. A నుండి నిష్క్రమించడానికి , మీరు ముందుగా B నుండి నిష్క్రమించాలి మరియు అలా చేయడానికి, మీరు C నుండి నిష్క్రమించాలి ."

"ఆగండి. మీరు చెప్పేది నాకు అర్థమైతే, స్టాక్ యొక్క మొత్తం భావన 'చివరగా జోడించిన కాగితాన్ని తీసుకోండి' మరియు 'మీరు ఇటీవల నమోదు చేసిన పద్ధతి నుండి మాత్రమే నిష్క్రమించగలరు'. ఇది సరైనదేనా? "

"అవును. ఫంక్షన్ కాల్‌ల క్రమాన్ని 'కాల్ స్టాక్' లేదా కేవలం 'స్టాక్' అని పిలుస్తారు. చివరిగా పిలిచే ఫంక్షన్ ముగిసే మొదటి ఫంక్షన్. ఒక ఉదాహరణలోకి తీయండి."

public class ExceptionExample
{
  public static void main(String[] args)
  {
    method1();
  }

  public static void method1()
  {
    method2();
  }

  public static void method2()
  {
    method3();
  }

  public static void method3()
  {
     StackTraceElement[] stackTraceElements = Thread.currentThread().getStackTrace();
    for (StackTraceElement element : stackTraceElements)
    {
       System.out.println(element.getMethodName());
    }
  }
}

getStackTrace
method3
method2
method1
main

"సరే. నేను ఫంక్షన్ కాల్స్ గురించి ప్రతిదీ పొందుతాను. అయితే ఈ StackTraceElement ఏమిటి?"

"జావా మెషిన్ అన్ని ఫంక్షన్ కాల్‌లను ట్రాక్ చేస్తుంది. దాని కోసం, దీనికి ప్రత్యేక సేకరణ ఉంది - స్టాక్. ఒక ఫంక్షన్ మరొకదానికి కాల్ చేసినప్పుడు, జావా మెషిన్ స్టాక్‌పై కొత్త StackTraceElement వస్తువును ఉంచుతుంది. ఒక ఫంక్షన్ పూర్తయినప్పుడు, ఆ మూలకం తీసివేయబడుతుంది . స్టాక్ నుండి. దీనర్థం స్టాక్ ఎల్లప్పుడూ 'ఫంక్షన్ కాల్‌ల స్టాక్' యొక్క ప్రస్తుత స్థితి గురించి తాజా సమాచారాన్ని నిల్వ చేస్తుంది .

"ప్రతి StackTraceElement ఆబ్జెక్ట్ కాల్ పద్ధతి గురించి సమాచారాన్ని కలిగి ఉంటుంది. ప్రత్యేకించి, మీరు getMethodName పద్ధతిని ఉపయోగించి పద్ధతి పేరును పొందవచ్చు."

"పై ఉదాహరణలో ఇది ఎలా పని చేస్తుందో మీరు చూడవచ్చు:

1) మేము కాల్ స్టాక్‌ని పొందుతాము.

2) మేము దాని ద్వారా వెళ్ళడానికి ప్రతి లూప్‌ని ఉపయోగిస్తాము . అది ఏమిటో మీరు మరచిపోలేదని నేను ఆశిస్తున్నాను.

3) మేము సిస్టమ్ పేర్లను System.out కు అవుట్‌పుట్ చేస్తాము ."

"మనోహరమైనది! మరియు చాలా క్లిష్టంగా లేదు. ధన్యవాదాలు, రిషీ!"