మినహాయింపులు: తనిఖీ చేయబడినవి, ఎంపిక చేయబడలేదు మరియు అనుకూలమైనవి

హాయ్! చివరి పాఠంలో, మేము జావా భాషలో మినహాయింపులతో పరిచయం పొందాము మరియు వారితో ఎలా పని చేయాలో ఉదాహరణలను చూశాము. ఈ రోజు మనం మినహాయింపుల నిర్మాణాన్ని లోతుగా పరిశీలిస్తాము మరియు మన స్వంత మినహాయింపులను ఎలా వ్రాయాలో నేర్చుకుంటాము :)

మినహాయింపుల రకాలు

మేము ఇంతకు ముందు చెప్పినట్లుగా, జావాలో చాలా మినహాయింపులు ఉన్నాయి, దాదాపు 400! కానీ అవన్నీ సమూహాలుగా విభజించబడ్డాయి, కాబట్టి వాటిని గుర్తుంచుకోవడం చాలా సులభం. ఇది ఇలా కనిపిస్తుంది: అన్ని మినహాయింపులు తరగతిలో సాధారణ పూర్వీకులను కలిగి ఉంటాయి Throwable. రెండు ప్రధాన సమూహాలు దాని నుండి ఉద్భవించాయి: మినహాయింపులు ( మినహాయింపు ) మరియు లోపాలు ( లోపం ). లోపం - ఇది జావా వర్చువల్ మెషీన్ యొక్క ఆపరేషన్‌కు సంబంధించిన క్లిష్టమైన రన్-టైమ్ లోపాన్ని సూచిస్తుంది. చాలా సందర్భాలలో, కోడ్‌లో కొన్ని తీవ్రమైన లోపాలను సూచిస్తున్నందున, లోపం నిర్వహించాల్సిన అవసరం లేదు. వీటిలో అత్యంత ప్రసిద్ధమైనవి StackOverflowError (ఉదాహరణకు, ఒక పద్ధతి తనను తాను అనంతంగా పిలిచినప్పుడు ఇది సంభవిస్తుంది) మరియు OutOfMemoryError(కొత్త వస్తువులను సృష్టించడానికి తగినంత మెమరీ లేనప్పుడు ఇది జరుగుతుంది). మీరు చూడగలిగినట్లుగా, ఈ పరిస్థితులలో, సాధారణంగా రన్ సమయంలో నిర్వహించడానికి ఖచ్చితంగా ఏమీ లేదు: కోడ్ కేవలం తప్పుగా వ్రాయబడింది మరియు తిరిగి పని చేయవలసి ఉంటుంది. మినహాయింపు - ఇది ఒక మినహాయింపును సూచిస్తుంది: ప్రోగ్రామ్ నడుస్తున్నప్పుడు సంభవించే అసాధారణమైన, ప్రణాళిక లేని పరిస్థితి. అవి ఎర్రర్ అంత తీవ్రమైనవి కావు, కానీ వాటికి ఇప్పటికీ మన శ్రద్ధ అవసరం. అన్ని మినహాయింపులు 2 రకాలుగా విభజించబడ్డాయి: తనిఖీ చేయబడ్డాయి మరియు ఎంపిక చేయబడలేదు . తనిఖీ చేయబడిన అన్ని మినహాయింపులు తరగతి నుండి తీసుకోబడ్డాయి Exception. "చెక్ చేయబడింది" అంటే ఏమిటి? మేము దీనిని చివరి పాఠంలో సూచించాము: "జావా కంపైలర్‌కు అత్యంత సాధారణ మినహాయింపులు మరియు అవి సంభవించే పరిస్థితుల గురించి తెలుసు." ఉదాహరణకు, కోడ్ ఫైల్ నుండి డేటాను చదివితే, ఫైల్ సులభంగా ఉనికిలో ఉండదని దానికి తెలుసు. మరియు అలాంటి పరిస్థితులు చాలా ఉన్నాయి (ఇది ఊహించగలదు). దీని ప్రకారం, ఈ సంభావ్య మినహాయింపుల ఉనికి కోసం కంపైలర్ మా కోడ్‌ను ముందుగానే తనిఖీ చేస్తుంది. అది వాటిని కనుగొంటే, మేము వాటిని నిర్వహించే వరకు లేదా వాటిని మళ్లీ విసిరే వరకు అది కోడ్‌ను కంపైల్ చేయదు. రెండవ రకం మినహాయింపు "చెక్ చేయబడలేదు". అవి తరగతి నుండి ఉద్భవించాయి RuntimeException. తనిఖీ చేయబడిన మినహాయింపుల నుండి అవి ఎలా విభిన్నంగా ఉన్నాయి? నుండి ఉద్భవించిన వివిధ తరగతులు కూడా చాలా ఉన్నాయని తెలుస్తోందిRuntimeException(ఇది రన్‌టైమ్ మినహాయింపులను వివరిస్తుంది). తేడా ఏమిటంటే కంపైలర్ ఈ లోపాలను ఊహించలేదు. "కోడ్ రాసినప్పుడు అనుమానాస్పదంగా ఏమీ కనిపించలేదు, కానీ అది నడుస్తున్నప్పుడు ఏదో తప్పు జరిగింది, స్పష్టంగా, కోడ్‌లో లోపాలు ఉన్నాయి!" మరియు నిజానికి ఇది నిజం. ఎంపిక చేయని మినహాయింపులు చాలా తరచుగా ప్రోగ్రామర్ లోపాల ఫలితంగా ఉంటాయి. మరియు కంపైలర్ స్పష్టంగా ప్రజలు తమ స్వంత చేతులతో సృష్టించగల ప్రతి చెడు పరిస్థితిని ఊహించలేరు. :) కాబట్టి, అటువంటి మినహాయింపులు మా కోడ్‌లో నిర్వహించబడుతున్నాయో లేదో తనిఖీ చేయదు. మీరు ఇప్పటికే అనేక ఎంపిక చేయని మినహాయింపులను ఎదుర్కొన్నారు:

• సున్నాతో భాగించినప్పుడు అంకగణిత మినహాయింపు ఏర్పడుతుంది
• మీరు శ్రేణి వెలుపల ఉన్న స్థానాన్ని యాక్సెస్ చేయడానికి ప్రయత్నించినప్పుడు ArrayIndexOutOfBoundsException ఏర్పడుతుంది.

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

మీ స్వంత మినహాయింపును ఎలా విసిరేయాలి

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

public class DogIsNotReadyException extends Exception {

   public DogIsNotReadyException(String message) {
       super(message);
   }
}

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

public class Dog {

   String name;
   boolean isCollarPutOn;
   boolean isLeashPutOn;
   boolean isMuzzlePutOn;


   public Dog(String name) {
       this.name = name;
   }

   public static void main(String[] args) {

   }

   public void putCollar() {

       System.out.println("The collar is on!");
       this.isCollarPutOn = true;
   }

   public void putLeash() {

       System.out.println("The leash is on!");
       this.isLeashPutOn = true;
   }

   public void putMuzzle() {
       System.out.println("The muzzle is on!");
       this.isMuzzlePutOn = true;
   }

   public void walk() throws DogIsNotReadyException {

   System.out.println("We're getting ready for a walk!");
   if (isCollarPutOn && isLeashPutOn && isMuzzlePutOn) {
       System.out.println("Hooray, let's go for a walk! " + name + " is very happy!");
   } else {
       throw new DogIsNotReadyException(name + " is not ready for a walk! Check the gear!");
   }
 }

}

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

public static void main(String[] args) {
  
   Dog dog = new Dog("Buddy");
   dog.putCollar();
   dog.putMuzzle();
   dog.walk();// Unhandled exception: DogIsNotReadyException
}

ఇది కంపైల్ చేయదు. మినహాయింపు నిర్వహించబడలేదు! try-catchమినహాయింపును నిర్వహించడానికి మేము మా కోడ్‌ను ఒక బ్లాక్‌లో చుట్టాము :

public static void main(String[] args) {

   Dog dog = new Dog("Buddy");
   dog.putCollar();
   dog.putMuzzle();
   try {
       dog.walk();
   } catch (DogIsNotReadyException e) {
       System.out.println(e.getMessage());
       System.out.println("Checking the gear! Is the collar on? " + dog.isCollarPutOn + "\r\n Is the leash on? "
       + dog.isLeashPutOn + "\r\n Is the muzzle on? " + dog.isMuzzlePutOn);
   }
}

ఇప్పుడు కన్సోల్ అవుట్‌పుట్‌ని చూద్దాం: కాలర్ ఆన్‌లో ఉంది! మూతి ఆన్! మేము నడక కోసం సిద్ధం అవుతున్నాము! బడ్డీ నడకకు సిద్ధంగా లేడు! గేర్‌ని తనిఖీ చేయండి! గేర్‌ని తనిఖీ చేస్తోంది! కాలర్ ఆన్‌లో ఉందా? నిజం పట్టి ఉందా? తప్పు మూతి ఆన్లో ఉందా? కన్సోల్ అవుట్‌పుట్ ఎంత ఎక్కువ సమాచారంతో ఉందో చూడండి ! మేము కార్యక్రమంలో వేసిన ప్రతి అడుగును చూస్తాము; లోపం ఎక్కడ జరిగిందో మేము చూస్తాము మరియు మా కుక్క ఏమి తప్పిపోయిందో కూడా మేము వెంటనే చూడగలము. :) మరియు మీరు మీ స్వంత మినహాయింపులను ఎలా సృష్టించుకుంటారు. మీరు గమనిస్తే, దాని గురించి సంక్లిష్టంగా ఏమీ లేదు. మరియు జావా సృష్టికర్తలు సరిగా లేని కుక్కలకు ప్రత్యేక మినహాయింపును భాషలో చేర్చడానికి ఇబ్బంది పడనప్పటికీ, మేము వారి పర్యవేక్షణను పరిష్కరించాము. :)