లోపం

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

జావా యొక్క మినహాయింపు సోపానక్రమం ఎగువన త్రోబుల్ క్లాస్ ఉంది, ఇందులో ఇద్దరు వారసులు ఉన్నారు:

• మినహాయింపు , ఇది మీ ప్రోగ్రామ్‌లోని లోపాలకు బాధ్యత వహిస్తుంది.
• మరియు నేటికి మా హీరో — ఎర్రర్ , ఇది JVM లో లోపాలకు బాధ్యత వహిస్తుంది.
  ఇవి బహుశా కోడింగ్ బగ్‌లు కావు, కానీ సాధారణంగా డెవలపర్‌పై ఆధారపడని సమస్యలు అని పేర్కొనడం విలువ.

లోపంతో ఏమి చేయాలి

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

లాగింగ్ మంచిది: మీకు రన్‌టైమ్ లోపం వచ్చినప్పుడు, మీరు లాగ్‌లను చూడవచ్చు, దాని కారణాన్ని చూడవచ్చు మరియు ఏమి పరిష్కరించాలో తెలుసుకోవచ్చు.

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

దీని ప్రకారం, త్రో చేయగల తరగతిని ఉపయోగించడం ఉత్తమం , ఇది లోపం మరియు మినహాయింపు రెండింటినీ పట్టుకోగలదు . ఇది ఆచరణలో ఎలా కనిపిస్తుంది?

try {
    // Your code
} catch (OutOfMemoryError outOfMemoryError) {
    // Code to catch OutOfMemoryError
}

try {
    // Your code
} catch (Error error) {
    // Code to catch all Errors
}

try {
    // Your code
} catch (Throwable throwable) {
    // Code to catch all Throwables
}

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

సాధారణ లోపాలు

OutOfMemoryError మరియు StackOverflowError తరగతులు అత్యంత ప్రజాదరణ పొందిన దోషాలలో కొన్ని .

ప్రోగ్రామ్‌లో వస్తువులను సృష్టించడానికి తగినంత మెమరీ లేనప్పుడు మరియు చెత్త సేకరించేవాడు కొనసాగించలేనప్పుడు OutOfMemoryError తరచుగా కనిపిస్తుంది. ఫలితం OutOfMemoryError .

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

ఉదాహరణకు, ఇలాంటి కోడ్ మెమరీలో చాలా చెత్తను సృష్టిస్తుంది:

while (true) {
    new Object();
}

నేను మీకు చెప్పాలనుకుంటున్న రెండవ లోపం StackOverflowError , ఇది స్టాక్ ఓవర్‌ఫ్లో అయినప్పుడు విసిరివేయబడుతుంది. స్టాక్ ప్రధానంగా లోకల్ వేరియబుల్స్, పారామీటర్‌లు మరియు మెథడ్ కాల్‌లను స్టోర్ చేస్తుంది కాబట్టి, రికర్షన్ (లేదా రికర్సివ్ మెథడ్ కాల్) ఈ లోపానికి చాలా సాధారణ కారణం:

public void foo() {
    foo();
}

ప్రోగ్రామ్ అమలు సమయంలో సమస్యలను నివారించడానికి, ఆధునిక IDEలు తరచుగా పునరావృతంగా కాల్ చేసే పద్ధతుల గురించి హెచ్చరిస్తాయి.

మీరు లోపాలను విసిరే ప్రోగ్రామ్‌ను పరిష్కరించలేరు , కానీ మీరు ఎర్రర్‌ను విసిరి మీ ప్రోగ్రామ్‌ను విచ్ఛిన్నం చేయని కోడ్‌ను వ్రాయవచ్చు. మీరు మెమరీతో ఏమి చేస్తున్నారో చూడండి, ఆబ్జెక్ట్‌లను జాగ్రత్తగా సృష్టించండి మరియు కాల్ మెథడ్‌లను సరిగ్గా చేయండి. మీరు అలా చేస్తే, మీ కోడ్‌లో మీకు తక్కువ సమస్యలు ఉంటాయి.

లోపం మరియు మినహాయింపు రకాల మధ్య వ్యత్యాసం

మీరు జావాలో మినహాయింపుల నుండి తప్పించుకోలేరు, కానీ మీరు వాటికి భయపడకూడదు. ప్రతి రకం దేనిని సూచిస్తుందో మీరు అర్థం చేసుకోవాలి మరియు దానిని ఎలా నిర్వహించాలో తెలుసుకోవాలి. నేటికీ అంతే! మళ్ళి కలుద్దాం!