ప్రోగ్రామింగ్ క్రొత్తగా, భావన మినహాయింపు నిర్వహణ మీ తలను చుట్టుకోవడం చాలా కష్టం. కాన్సెప్ట్ కూడా కష్టమే కాదు, కానీ పదజాలం దాని కంటే మరింత అధునాతనమైనదిగా అనిపించవచ్చు. మరియు ఇది దుర్వినియోగం మరియు దుర్వినియోగానికి గురయ్యే శక్తివంతమైన లక్షణం.
ఈ ఆర్టికల్లో, మినహాయింపులు ఏమిటి, అవి ఎందుకు ముఖ్యమైనవి, వాటిని ఎలా ఉపయోగించాలి మరియు నివారించడానికి సాధారణ తప్పులు ఏమిటో మీరు నేర్చుకుంటారు. చాలా ఆధునిక భాషలకు ఒక రకమైన మినహాయింపు నిర్వహణ ఉంది, కాబట్టి మీరు ఎప్పుడైనా జావా నుండి వెళ్లినట్లయితే, మీరు ఈ చిట్కాలలో ఎక్కువ భాగాన్ని మీతో తీసుకోవచ్చు.
జావా మినహాయింపులను అర్థం చేసుకోవడం
జావాలో, ఒక మినహాయింపు అనేది మీ అప్లికేషన్ అమలు సమయంలో అసాధారణమైన (లేదా 'అసాధారణమైన') సంభవించిన వస్తువును సూచిస్తుంది. అలాంటి మినహాయింపులు ఉన్నాయి విసిరారు , దీని అర్థం ప్రాథమికంగా ఒక మినహాయింపు వస్తువు సృష్టించబడింది (లోపాలు 'ఎలా లేవనెత్తాయో' లాంటిది).
అందం అనేది మీరు చేయగలరు క్యాచ్ విసిరిన మినహాయింపులు, ఇది మీరు అసాధారణ పరిస్థితిని ఎదుర్కోవటానికి మరియు మీ అప్లికేషన్ ఏమీ తప్పు జరగనట్లుగా నడుస్తూ ఉండటానికి అనుమతిస్తుంది. ఉదాహరణకు, C లోని శూన్య పాయింటర్ మీ అప్లికేషన్ను క్రాష్ చేయవచ్చు, జావా మిమ్మల్ని విసిరేయడానికి మరియు పట్టుకోవడానికి అనుమతిస్తుంది
NullPointerException
శూన్య వేరియబుల్ క్రాష్కు కారణమయ్యే ముందు s.
గుర్తుంచుకోండి, మినహాయింపు కేవలం ఒక వస్తువు, కానీ ఒక ముఖ్యమైన లక్షణంతో: ఇది తప్పక దాని నుండి విస్తరించబడాలి
Exception
తరగతి లేదా ఏదైనా ఉప తరగతి
Exception
. జావాలో అన్ని రకాల అంతర్నిర్మిత మినహాయింపులు ఉన్నప్పటికీ, మీరు కోరుకుంటే మీ స్వంతంగా కూడా సృష్టించవచ్చు. వాటిలో కొన్ని అత్యంత సాధారణ జావా మినహాయింపులు చేర్చండి:
NullPointerException
NumberFormatException
IllegalArgumentException
RuntimeException
IllegalStateException
కాబట్టి మీరు మినహాయింపు ఇచ్చినప్పుడు ఏమి జరుగుతుంది?
ముందుగా, మీరు విసిరిన మినహాయింపును నిర్వహించే కోడ్ ఉందో లేదో చూడటానికి జావా తక్షణ పద్ధతిలో చూస్తుంది. హ్యాండ్లర్ ఉనికిలో లేనట్లయితే, అక్కడ హ్యాండిల్ ఉందో లేదో తెలుసుకోవడానికి ప్రస్తుత పద్ధతిని పిలిచే పద్ధతిని చూస్తుంది. కాకపోతే, అది పిలిచిన పద్ధతిని చూస్తుంది అని పద్ధతి, ఆపై తదుపరి పద్ధతి మొదలైనవి. మినహాయింపు క్యాచ్ కాకపోతే, అప్లికేషన్ స్టాక్ ట్రేస్ను ముద్రించి ఆపై క్రాష్ అవుతుంది. (వాస్తవానికి ఇది క్రాష్ చేయడం కంటే చాలా సూక్ష్మమైనది, కానీ అది ఈ వ్యాసం పరిధికి మించిన అధునాతన అంశం.)
కు స్టాక్ ట్రేస్ మినహాయింపు హ్యాండ్లర్ కోసం చూస్తున్నప్పుడు జావా ప్రయాణించిన అన్ని పద్ధతుల జాబితా. స్టాక్ ట్రేస్ ఎలా ఉంటుందో ఇక్కడ ఉంది:
Exception in thread 'main' java.lang.NullPointerException
at com.example.myproject.Book.getTitle(Book.java:16)
at com.example.myproject.Author.getBookTitles(Author.java:25)
at com.example.myproject.Bootstrap.main(Bootstrap.java:14)
దీని నుండి మనం చాలా పొందవచ్చు. మొదట, విసిరిన మినహాయింపు a
NullPointerException
. లో సంభవించింది
getTitle()
Book.java యొక్క లైన్ 16 లోని పద్ధతి. ఆ పద్ధతి నుండి పిలువబడింది
getBookTitles()
రచయిత.జావా లైన్ 25 లో. ఆ పద్ధతి నుండి పిలువబడింది
main()
Bootstrap.java యొక్క లైన్ 14 లో. మీరు గమనిస్తే, ఇవన్నీ తెలుసుకోవడం వల్ల డీబగ్గింగ్ సులభం అవుతుంది.
కానీ మళ్ళీ, మినహాయింపుల యొక్క నిజమైన ప్రయోజనం ఏమిటంటే, మీరు మినహాయింపును పట్టుకోవడం, విషయాలను సరిచేయడం మరియు క్రాష్ లేకుండా అప్లికేషన్ను తిరిగి ప్రారంభించడం ద్వారా అసాధారణ పరిస్థితిని 'నిర్వహించగలరు'.
కోడ్లో జావా మినహాయింపులను ఉపయోగించడం
మీ వద్ద ఉందని చెప్పండి
someMethod()
ఒక పూర్ణాంకం పడుతుంది మరియు పూర్ణాంకం 0 కన్నా తక్కువ లేదా 100 కంటే ఎక్కువ ఉంటే విచ్ఛిన్నం చేసే కొన్ని తర్కాన్ని అమలు చేస్తుంది. ఇది మినహాయింపును విసిరేందుకు మంచి ప్రదేశం కావచ్చు:
నేను ps4 లో ps3 గేమ్లను డౌన్లోడ్ చేయవచ్చా?
public void someMethod(int value) {
if (value 100) {
throw new IllegalArgumentException
ఈ మినహాయింపును పొందడానికి, మీరు ఎక్కడికి వెళ్లాలి
someMethod()
అంటారు మరియు ఉపయోగించబడుతుంది ప్రయత్నించండి-క్యాచ్ బ్లాక్ :
public void callingMethod() {
try {
someMethod(200);
someOtherMethod();
} catch (IllegalArgumentException e) {
// handle the exception in here
}
// ...
}
లోపల ప్రతిదీ ప్రయత్నించండి మినహాయింపు విసిరే వరకు బ్లాక్ క్రమంలో అమలు చేయబడుతుంది. మినహాయింపు విసిరిన వెంటనే, అన్ని తదుపరి స్టేట్మెంట్లు దాటవేయబడతాయి మరియు అప్లికేషన్ లాజిక్ వెంటనే జంప్ అవుతుంది క్యాచ్ బ్లాక్.
మా ఉదాహరణలో, మేము ట్రై బ్లాక్లోకి ప్రవేశించి వెంటనే కాల్ చేస్తాము
someMethod()
. 200 0 మరియు 100 మధ్య లేనందున, ఒక
IllegalArgumentException
విసిరివేయబడింది. ఇది తక్షణమే అమలును ముగించింది
someMethod()
, ట్రై బ్లాక్లో మిగిలిన లాజిక్ను దాటవేస్తుంది (
someOtherMethod()
ఎప్పుడూ పిలవబడదు), మరియు క్యాచ్ బ్లాక్ లోపల అమలును తిరిగి ప్రారంభిస్తుంది.
మనం పిలిస్తే ఏమవుతుంది
someMethod(50)
బదులుగా? ది
IllegalArgumentException
ఎప్పటికీ విసిరివేయబడదు.
someMethod()
మామూలుగా అమలు చేస్తుంది. ట్రై బ్లాక్ మామూలుగా, కాలింగ్గా అమలు చేస్తుంది
someOtherMethod()
కొన్ని పద్ధతి () పూర్తయినప్పుడు. ఎప్పుడు
someOtherMethod()
ముగుస్తుంది, క్యాచ్ బ్లాక్ దాటవేయబడుతుంది మరియు
callingMethod()
కొనసాగుతుంది.
మీరు ప్రతి బ్లాక్కు బహుళ క్యాచ్ బ్లాక్లను కలిగి ఉండవచ్చని గమనించండి:
public void callingMethod() {
try {
someMethod(200);
someOtherMethod();
} catch (IllegalArgumentException e) {
// handle the exception in here
} catch (NullPointerException e) {
// handle the exception in here
}
// ...
}
ఐచ్ఛికం అని కూడా గమనించండి చివరకు బ్లాక్ కూడా ఉంది:
public void method() {
try {
// ...
} catch (Exception e) {
// ...
} finally {
// ...
}
}
చివరకు బ్లాక్లోని కోడ్ ఎల్లప్పుడూ ఏమైనప్పటికీ అమలు చేయబడింది. మీరు ట్రై బ్లాక్లో రిటర్న్ స్టేట్మెంట్ కలిగి ఉంటే, చివరకు బ్లాక్ మెథడ్ నుండి తిరిగి వచ్చే ముందు అమలు చేయబడుతుంది. మీరు క్యాచ్ బ్లాక్లో మరొక మినహాయింపును విసిరితే, మినహాయింపు విసిరే ముందు చివరకు బ్లాక్ అమలు చేయబడుతుంది.
పద్ధతి ముగిసేలోపు శుభ్రం చేయాల్సిన వస్తువులు ఉన్నప్పుడు మీరు చివరకు బ్లాక్ని ఉపయోగించాలి. ఉదాహరణకు, మీరు ట్రై బ్లాక్లో ఫైల్ని తెరిచి, ఆపై మినహాయింపును విసిరితే, చివరకు బ్లాక్ పద్ధతిని వదిలివేసే ముందు ఫైల్ను క్లోజ్ చేయడానికి మిమ్మల్ని అనుమతిస్తుంది.
క్యాచ్ బ్లాక్ లేకుండా మీరు చివరకు బ్లాక్ను కలిగి ఉండవచ్చని గమనించండి:
public void method() {
try {
// ...
} finally {
// ...
}
}
మెథడ్ ఇన్వొకేషన్ స్టాక్ను ప్రచారం చేయడానికి విసిరిన మినహాయింపులను అనుమతించేటప్పుడు అవసరమైన ఏవైనా క్లీనప్ చేయడానికి ఇది మిమ్మల్ని అనుమతిస్తుంది (అనగా మీరు ఇక్కడ మినహాయింపును నిర్వహించడం ఇష్టం లేదు కానీ మీరు ఇంకా ముందుగా శుభ్రం చేయాలి).
జావాలో తనిఖీ చేయబడిన వర్సెస్ తనిఖీ చేయని మినహాయింపులు
చాలా భాషల మాదిరిగా కాకుండా, జావా మధ్య తేడా ఉంటుంది తనిఖీ మినహాయింపులు మరియు తనిఖీ చేయని మినహాయింపులు (ఉదా. C# మాత్రమే తనిఖీ చేయని మినహాయింపులను కలిగి ఉంది). తనిఖీ చేయబడిన మినహాయింపు తప్పక మినహాయింపు విసిరిన పద్ధతిలో పట్టుబడండి లేదా కోడ్ కంపైల్ చేయబడదు.
తనిఖీ చేయబడిన మినహాయింపును సృష్టించడానికి, నుండి విస్తరించండి
Exception
. తనిఖీ చేయని మినహాయింపుని సృష్టించడానికి, నుండి విస్తరించండి
RuntimeException
.
తనిఖీ చేయబడిన మినహాయింపును విసిరే ఏదైనా పద్ధతి తప్పనిసరిగా దీనిని ఉపయోగించి పద్ధతి సంతకంలో సూచించాలి విసురుతాడు కీవర్డ్. జావా అంతర్నిర్మిత నుండి
IOException
తనిఖీ చేయబడిన మినహాయింపు, కింది కోడ్ కంపైల్ చేయబడదు:
public void wontCompile() {
// ...
if (someCondition) {
throw new IOException();
}
// ...
}
ఇది చెక్ చేసిన మినహాయింపును విసురుతుందని మీరు ముందుగా ప్రకటించాలి:
public void willCompile() throws IOException {
// ...
if (someCondition) {
throw new IOException();
}
// ...
}
ఒక పద్ధతిని మినహాయింపుగా విసురుతున్నట్లు ప్రకటించవచ్చు కానీ వాస్తవానికి ఎప్పుడూ మినహాయింపును విసరవద్దు. అయినప్పటికీ, మినహాయింపు ఇంకా పట్టుకోవలసి ఉంటుంది, లేకపోతే కోడ్ కంపైల్ చేయబడదు.
మీరు తనిఖీ చేసిన లేదా తనిఖీ చేయని మినహాయింపులను ఎప్పుడు ఉపయోగించాలి?
అధికారిక జావా డాక్యుమెంటేషన్ ఒక ఈ ప్రశ్నపై పేజీ . ఇది సంక్షిప్త సూత్రంతో వ్యత్యాసాన్ని సంక్షిప్తీకరిస్తుంది: 'క్లయింట్ సహేతుకంగా మినహాయింపు నుండి కోలుకోవాలని భావిస్తే, దాన్ని తనిఖీ చేసిన మినహాయింపుగా చేయండి. మినహాయింపు నుండి కోలుకోవడానికి క్లయింట్ ఏమీ చేయలేకపోతే, దాన్ని తనిఖీ చేయని మినహాయింపుగా చేయండి. '
కానీ ఈ మార్గదర్శకం పాతది కావచ్చు. ఒక వైపు, తనిఖీ చేయబడిన మినహాయింపులు మరింత బలమైన కోడ్కి దారితీస్తాయి. మరోవైపు, జావా మాదిరిగానే ఏ ఇతర భాష మినహాయింపులను తనిఖీ చేయలేదు, ఇది రెండు విషయాలను చూపుతుంది: ఒకటి, ఫీచర్ ఇతర భాషలకు దొంగిలించడానికి తగినంతగా ఉపయోగపడదు మరియు రెండు, అవి లేకుండా మీరు ఖచ్చితంగా జీవించవచ్చు. అదనంగా, జావా 8 లో ప్రవేశపెట్టిన లాంబ్డా ఎక్స్ప్రెషన్లతో తనిఖీ చేయబడిన మినహాయింపులు చక్కగా ఆడవు.
జావా మినహాయింపుల ఉపయోగం కోసం మార్గదర్శకాలు
మినహాయింపులు ఉపయోగకరంగా ఉంటాయి కానీ సులభంగా దుర్వినియోగం చేయబడతాయి మరియు దుర్వినియోగం చేయబడతాయి. మీరు వాటిని గందరగోళానికి గురికాకుండా ఉండటానికి ఇక్కడ కొన్ని చిట్కాలు మరియు ఉత్తమ పద్ధతులు ఉన్నాయి.
- సాధారణ మినహాయింపుల కంటే నిర్దిష్ట మినహాయింపులకు ప్రాధాన్యత ఇవ్వండి. ఉపయోగించండి | _+_ | పైగా | _+_ | సాధ్యమైనప్పుడు, లేకపోతే | _+_ | ఉపయోగించండి పైగా | _+_ | కుదిరినప్పుడు.
- ఎప్పుడూ పట్టుకోలేదు | _+_ | ! ది | _+_ | తరగతి వాస్తవానికి విస్తరించింది | _+_ | , మరియు క్యాచ్ బ్లాక్ వాస్తవానికి పని చేస్తుంది | _+_ | లేదా త్రోవబుల్ను పొడిగించే ఏదైనా తరగతి. అయితే, ది. _++_ | తరగతి కూడా విస్తరించింది | _+_ | , మరియు మీరు ఎప్పటికీ పట్టుకోవాలనుకోరు | _+_ | ఎందుకంటే | _+_ | లు తిరిగి పొందలేని తీవ్రమైన సమస్యలను సూచిస్తాయి.
- ఎప్పుడూ పట్టుకోలేదు | _+_ | ! | _+_ | విస్తరిస్తుంది | _+_ | , కాబట్టి ఏ బ్లాక్ అయినా పట్టుకుంటుంది | _+_ | కూడా పట్టుకుంటారు | _+_ | , మరియు మీరు ఏమి చేస్తున్నారో మీకు తెలియకపోతే మీరు (ముఖ్యంగా మల్టీ-థ్రెడ్ అప్లికేషన్లలో) గందరగోళం చెందకూడదనుకునే చాలా ముఖ్యమైన మినహాయింపు ఇది. బదులుగా ఏ మినహాయింపుని పట్టుకోవాలో మీకు తెలియకపోతే, ఏదైనా పట్టుకోకుండా పరిగణించండి.
- డీబగ్గింగ్ సులభతరం చేయడానికి వివరణాత్మక సందేశాలను ఉపయోగించండి. మీరు మినహాయింపుని విసిరినప్పుడు, మీరు a | _+_ | అందించవచ్చు వాదనగా సందేశం. ఈ సందేశాన్ని క్యాచ్ బ్లాక్లో యాక్సెస్ చేయవచ్చు | | _+_ | పద్ధతి, కానీ మినహాయింపు ఎప్పుడూ పట్టుకోకపోతే, స్టాక్ ట్రేస్లో భాగంగా సందేశం కూడా కనిపిస్తుంది.
- మినహాయింపులను పట్టుకోకుండా మరియు విస్మరించకుండా ప్రయత్నించండి. తనిఖీ చేసిన మినహాయింపుల యొక్క అసౌకర్యాన్ని అధిగమించడానికి, చాలా మంది క్రొత్త మరియు సోమరితనం ప్రోగ్రామర్లు క్యాచ్ బ్లాక్ను ఏర్పాటు చేస్తారు కానీ దానిని ఖాళీగా వదిలేస్తారు. చెడ్డది! ఎల్లప్పుడూ సరదాగా నిర్వహించండి, కానీ మీరు చేయలేకపోతే, కనీసం స్టాక్ ట్రేస్ను ముద్రించండి, కాబట్టి మినహాయింపు విసిరివేయబడిందని మీకు తెలుసు. మీరు దీనిని | _+_ | ఉపయోగించి చేయవచ్చు పద్ధతి
- మితిమీరిన మినహాయింపుల పట్ల జాగ్రత్త వహించండి. మీకు సుత్తి ఉన్నప్పుడు, ప్రతిదీ గోరులా కనిపిస్తుంది. మీరు మొదట మినహాయింపుల గురించి తెలుసుకున్నప్పుడు, మీరు అన్నింటినీ మినహాయింపుగా మార్చడానికి బాధ్యత వహిస్తారు ... మీ అప్లికేషన్ యొక్క నియంత్రణ ప్రవాహం చాలా వరకు మినహాయింపు నిర్వహణకు వస్తుంది. గుర్తుంచుకోండి, మినహాయింపులు 'అసాధారణమైన' సంఘటనల కోసం ఉద్దేశించబడ్డాయి!
అవి ఏమిటో, అవి ఎందుకు ఉపయోగించబడుతున్నాయో మరియు వాటిని మీ స్వంత కోడ్లో ఎలా చేర్చాలో అర్థం చేసుకోవడానికి మినహాయింపులతో ఇప్పుడు మీరు తగినంత సౌకర్యంగా ఉండాలి. మీరు భావనను పూర్తిగా అర్థం చేసుకోకపోతే, అది సరే! ఇది నా తలపై 'క్లిక్' కావడానికి నాకు కొంత సమయం పట్టింది, కాబట్టి మీరు తొందరపడాల్సిన అవసరం ఉందని భావించవద్దు. మీకు కావలిసినంత సమయం తీసుకోండి.
ఏవైనా ప్రశ్నలు ఉన్నాయా? నేను తప్పిపోయిన ఇతర మినహాయింపు సంబంధిత చిట్కాల గురించి మీకు తెలుసా? దిగువ వ్యాఖ్యలలో వాటిని భాగస్వామ్యం చేయండి!
షేర్ చేయండి షేర్ చేయండి ట్వీట్ ఇమెయిల్ ఏదైనా ప్రాజెక్ట్ యొక్క డేటాను విజువలైజ్ చేయడానికి డేటా-ఫ్లో రేఖాచిత్రాన్ని ఎలా సృష్టించాలి ఏదైనా ప్రక్రియ యొక్క డేటా-ఫ్లో రేఖాచిత్రాలు (DFD) మూలం నుండి గమ్యస్థానానికి డేటా ఎలా ప్రవహిస్తుందో అర్థం చేసుకోవడానికి మీకు సహాయపడుతుంది. దీన్ని ఎలా సృష్టించాలో ఇక్కడ ఉంది!
తదుపరి చదవండి సంబంధిత అంశాలు - ప్రోగ్రామింగ్
- జావా
రచయిత గురుంచి జోయెల్ లీ(1524 కథనాలు ప్రచురించబడ్డాయి) జోయెల్ లీ 2018 నుండి MakeUseOf యొక్క ఎడిటర్ ఇన్ చీఫ్. అతనికి B.S. కంప్యూటర్ సైన్స్ మరియు తొమ్మిది సంవత్సరాల ప్రొఫెషనల్ రైటింగ్ మరియు ఎడిటింగ్ అనుభవం.
మాంగా ఆన్లైన్లో ఉచితంగా చదవడానికి వెబ్సైట్లు
జోయెల్ లీ నుండి మరిన్నిమా వార్తాలేఖకు సభ్యత్వాన్ని పొందండి
టెక్ చిట్కాలు, సమీక్షలు, ఉచిత ఈబుక్లు మరియు ప్రత్యేకమైన డీల్స్ కోసం మా వార్తాలేఖలో చేరండి!
సభ్యత్వం పొందడానికి ఇక్కడ క్లిక్ చేయండి