వనరులతో ప్రయత్నించండి ప్రకటన

"అమిగో, టెన్-హట్!"

"జావా నేర్చుకున్నందుకు సంతోషంగా ఉంది, కెప్టెన్!"

"సమస్యగా ఉండండి, అమిగో. ఈ రోజు మనకు చాలా ఆసక్తికరమైన అంశం ఉంది. జావా ప్రోగ్రామ్ బాహ్య వనరులతో ఎలా పరస్పర చర్య చేస్తుందనే దాని గురించి మాట్లాడుతాము మరియు మేము ఒక ఆసక్తికరమైన జావా ప్రకటనను అధ్యయనం చేస్తాము. మీ చెవులను కప్పుకోకపోవడమే మంచిది."

"నేను అన్ని చెవులు."

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

"అప్పుడు అంతర్గత వనరులు ఏమి పరిగణించబడతాయి?"

"అంతర్గత వనరులు జావా మెషీన్ లోపల సృష్టించబడిన వస్తువులు. సాధారణంగా, పరస్పర చర్య ఈ పథకాన్ని అనుసరిస్తుంది:

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

"ఆపరేటింగ్ సిస్టమ్‌లో ప్రోగ్రామ్‌లు వనరులను పొందేందుకు మరియు/లేదా విడుదల చేయడానికి అనుమతించే విధులు (APIలు) ఉన్నాయి. ఒక వనరు బిజీగా ఉంటే, దానిని పొందిన ప్రోగ్రామ్ మాత్రమే దానితో పని చేయగలదు. వనరు ఉచితం అయితే, ఏదైనా ప్రోగ్రామ్ పొందవచ్చు. అది.

"ఒక ఆఫీసు కాఫీ మగ్‌లను పంచుకున్నట్లు ఊహించుకోండి. ఎవరైనా మగ్ తీసుకుంటే, ఇతరులు దానిని తీసుకోలేరు. కానీ ఒకసారి మగ్‌ని ఉపయోగించి, కడిగి, దాని స్థానంలో తిరిగి ఉంచితే, ఎవరైనా దానిని మళ్లీ తీసుకోవచ్చు."

"అర్థమైంది. ఇది సబ్‌వే లేదా ఇతర పబ్లిక్ ట్రాన్స్‌పోర్ట్‌లో సీట్లు లాంటిది. ఒక సీటు ఉచితం అయితే, ఎవరైనా దానిని తీసుకోవచ్చు. ఒక సీటు ఆక్రమించబడి ఉంటే, అది తీసుకున్న వ్యక్తి ద్వారా నియంత్రించబడుతుంది."

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

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

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

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

"ఇది మొత్తం జ్ఞాపకశక్తిని మాయం చేసే ప్రోగ్రామ్‌ల వంటిది..."

"అలాంటిది. శుభవార్త ఏమిటంటే, మీ ప్రోగ్రామ్ ఆగిపోతే, అన్ని వనరులు స్వయంచాలకంగా విడుదల చేయబడతాయి (ఆపరేటింగ్ సిస్టమ్ స్వయంగా దీన్ని చేస్తుంది)."

"అది శుభవార్త అయితే, చెడు వార్త ఉందని అర్థం?"

"ఖచ్చితంగా చెప్పాలంటే. చెడ్డ వార్త ఏమిటంటే, మీరు సర్వర్ అప్లికేషన్ వ్రాస్తున్నట్లయితే..."

"అయితే నేను అలాంటి అప్లికేషన్లు వ్రాస్తానా?"

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

"మరో మాటలో చెప్పాలంటే, ప్రోగ్రామ్ ముగియదు మరియు మెమరీ స్వయంచాలకంగా విడుదల చేయబడదు."

"సరిగ్గా. మరియు మీరు రోజుకు 100 ఫైల్‌లను తెరిచి వాటిని మూసివేయకపోతే, కొన్ని వారాలలో మీ అప్లికేషన్ దాని వనరుల పరిమితిని చేరుకుని క్రాష్ అవుతుంది."

"నెలరోజుల స్థిరమైన పనిలో అది చాలా తక్కువగా ఉంది! ఏమి చేయవచ్చు?"

"బాహ్య వనరులను ఉపయోగించే తరగతులు వాటిని విడుదల చేయడానికి ప్రత్యేక పద్ధతిని కలిగి ఉంటాయి: close().

"ఇక్కడ ఒక ప్రోగ్రామ్ యొక్క ఉదాహరణ ఫైల్‌కి ఏదైనా వ్రాసి, అది పూర్తయిన తర్వాత ఫైల్‌ను మూసివేస్తుంది, అనగా ఇది ఆపరేటింగ్ సిస్టమ్ యొక్క వనరులను ఖాళీ చేస్తుంది. ఇది సుమారుగా ఇలా కనిపిస్తుంది:

String path = "c:\\projects\\log.txt";
FileOutputStream output = new FileOutputStream(path);
output.write(1);
output.close();

"ఆహ్... కాబట్టి, ఫైల్ (లేదా ఇతర బాహ్య వనరులు)తో పని చేసిన తర్వాత, close()బాహ్య వనరుకి లింక్ చేయబడిన వస్తువుపై నేను పద్ధతిని కాల్ చేయాలి."

"అవును. అంతా సింపుల్‌గా అనిపిస్తుంది. కానీ ప్రోగ్రామ్ నడుస్తున్నప్పుడు మినహాయింపులు సంభవించవచ్చు మరియు బాహ్య వనరు విడుదల చేయబడదు."

"మరియు అది చాలా చెడ్డది. ఏమి చేయాలి?"

"పద్ధతి ఎల్లప్పుడూ పిలువబడుతుందని నిర్ధారించుకోవడానికి , మేము మా కోడ్‌ను ఒక - - బ్లాక్‌లో close()చుట్టాలి మరియు బ్లాక్‌కి పద్ధతిని జోడించాలి . ఇది ఇలా కనిపిస్తుంది:trycatchfinallyclose()finally

try
{
   FileOutputStream output = new FileOutputStream(path);
   output.write(1);
   output.close();
}
catch (IOException e)
{
   e.printStackTrace();
}
finally
{
   output.close();
}

"హ్మ్మ్... ఇక్కడ ఏదో సమస్య ఉందా?"

"కుడి. ఈ కోడ్ కంపైల్ చేయబడదు, ఎందుకంటే outputవేరియబుల్ బ్లాక్ లోపల ప్రకటించబడింది try{}మరియు బ్లాక్‌లో కనిపించదు finally.

దాన్ని సరిచేద్దాం:

FileOutputStream output = new FileOutputStream(path);

try
{
   output.write(1);
   output.close();
}
catch (IOException e)
{
   e.printStackTrace();
}
finally
{
   output.close();
}

"ఇప్పుడు అంతా బాగానే ఉందా?"

"ఇది ఫర్వాలేదు, కానీ మనం ఆబ్జెక్ట్‌ను సృష్టించినప్పుడు లోపం ఏర్పడితే అది పని చేయదు FileOutputStreamమరియు ఇది చాలా సులభంగా జరగవచ్చు.

దాన్ని సరిచేద్దాం:

FileOutputStream output = null;

try
{
   output = new FileOutputStream(path);
   output.write(1);
   output.close();
}
catch (IOException e)
{
   e.printStackTrace();
}
finally
{
   output.close();
}

"మరియు ఇప్పుడు ప్రతిదీ పని చేస్తుందా?"

"ఇంకా కొన్ని విమర్శలు ఉన్నాయి. మొదట, ఆబ్జెక్ట్‌ను సృష్టించేటప్పుడు లోపం సంభవించినట్లయితే FileOutputStream, outputవేరియబుల్ శూన్యమవుతుంది. ఈ అవకాశాన్ని బ్లాక్‌లో లెక్కించాలి finally.

"రెండవది, close()పద్ధతిని ఎల్లప్పుడూ బ్లాక్‌లో పిలుస్తారు finally, అంటే tryబ్లాక్‌లో ఇది అవసరం లేదు. చివరి కోడ్ ఇలా కనిపిస్తుంది:

FileOutputStream output = null;

try
{
   output = new FileOutputStream(path);
   output.write(1);
}
catch (IOException e)
{
   e.printStackTrace();
}
finally
{
   if (output!=null)
      output.close();
}

"విస్మరించబడే బ్లాక్‌ను మేము పరిగణించనప్పటికీ catch, మా 3 లైన్ల కోడ్ 10 అవుతుంది. కానీ మేము ప్రాథమికంగా ఫైల్‌ని తెరిచి 1ని వ్రాసాము."

"ప్ఫ్... విషయం ముగిస్తే బావుంది. సాపేక్షంగా అర్థమయినా, కాస్త దుర్భరంగా ఉంది కదా?"

"అలా ఉంది. అందుకే జావా సృష్టికర్తలు కొన్ని వాక్యనిర్మాణ చక్కెరను జోడించడం ద్వారా మాకు సహాయం చేసారు. ఇప్పుడు ప్రోగ్రామ్ యొక్క ముఖ్యాంశానికి వెళ్దాం లేదా ఈ పాఠం:

try-వనరులతో

"తన 7వ వెర్షన్‌తో ప్రారంభించి, జావా కొత్త tryవనరులతో కూడిన ప్రకటనను కలిగి ఉంది.

"ఇది పద్ధతికి తప్పనిసరి కాల్‌తో సమస్యను పరిష్కరించడానికి ఖచ్చితంగా సృష్టించబడింది close()."

"ఇది ఆశాజనకంగా ఉంది!"

"సాధారణ కేసు చాలా సరళంగా కనిపిస్తుంది:

try (ClassName name = new ClassName())
{
   Code that works with the name variable
}

"కాబట్టి ఇది try ప్రకటన యొక్క మరొక వైవిధ్యం ?"

"అవును. మీరు కీవర్డ్ తర్వాత కుండలీకరణాలను జోడించాలి try, ఆపై కుండలీకరణాల్లో బాహ్య వనరులతో వస్తువులను సృష్టించాలి. కుండలీకరణాల్లోని ప్రతి వస్తువు కోసం, కంపైలర్ పద్ధతికి ఒక finallyవిభాగాన్ని మరియు కాల్‌ను జోడిస్తుంది close().

"క్రింద రెండు సమానమైన ఉదాహరణలు ఉన్నాయి:

FileOutputStream output = null;

try
{
   output = new FileOutputStream(path);
   output.write(1);
}
finally
{
   if (output!=null)
   output.close();
}

try(FileOutputStream output = new FileOutputStream(path))
{
   output.write(1);
}

try"అద్భుతం! వనరులతో కూడిన కోడ్ చాలా చిన్నది మరియు చదవడం సులభం. మరియు మన వద్ద ఉన్న కోడ్ తక్కువ, అక్షర దోషం లేదా ఇతర దోషం చేసే అవకాశం తక్కువ."

"మీకు నచ్చినందుకు నేను సంతోషిస్తున్నాను. మార్గం ద్వారా, మేము వనరులతో కూడిన స్టేట్‌మెంట్‌కి జోడించవచ్చు catchమరియు finallyబ్లాక్ చేయవచ్చు try. లేదా అవి అవసరం లేకుంటే మీరు వాటిని జోడించలేరు.

ఒకే సమయంలో అనేక వేరియబుల్స్

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

"ఈ సందర్భంలో, try-with-resources స్టేట్‌మెంట్ దానిలో ఒకటి కాకుండా అనేక వస్తువులను సృష్టించడానికి మిమ్మల్ని అనుమతిస్తుంది. ఆబ్జెక్ట్‌లను సృష్టించే కోడ్ తప్పనిసరిగా సెమికోలన్‌లతో వేరు చేయబడాలి. ఈ ప్రకటన యొక్క సాధారణ రూపం ఇక్కడ ఉంది:

try (ClassName name = new ClassName(); ClassName2 name2 = new ClassName2())
{
   Code that works with the name and name2 variables
}

ఫైళ్లను కాపీ చేయడానికి ఉదాహరణ:

String src = "c:\\projects\\log.txt";
String dest = "c:\\projects\\copy.txt";

try(FileInputStream input = new FileInputStream(src);

FileOutputStream output = new FileOutputStream(dest))
{
   byte[] buffer = input.readAllBytes();
   output.write(buffer);
}

String src = "c:\\projects\\log.txt";
String dest = "c:\\projects\\copy.txt";

FileInputStream input = null;
FileOutputStream output = null;

try
{
   input = new FileInputStream(src);
   output = new FileOutputStream(dest);

   byte[] buffer = input.readAllBytes();
   output.write(buffer);
}
finally
{
   if (input!=null)
      input.close();
   if (output!=null)
      output.close();
}

"సరే, మనం ఇక్కడ ఏమి చెప్పగలం? try-వనరులతో కూడినది అద్భుతమైన విషయం!"

"మేము చెప్పగలిగేది ఏమిటంటే మనం దానిని ఉపయోగించాలి."