Mga pagbubukod: may check, walang check, at custom

Hi! Sa huling aralin, nakilala namin ang mga pagbubukod sa wikang Java, at nakakita ng mga halimbawa kung paano magtrabaho sa kanila. Ngayon ay titingnan natin nang mas malalim ang istruktura ng mga eksepsiyon, at matutunan kung paano magsulat ng sarili nating mga eksepsiyon :)

Mga uri ng pagbubukod

Gaya ng sinabi namin dati, maraming exception sa Java, halos 400! Ngunit lahat sila ay nahahati sa mga grupo, kaya medyo madaling matandaan ang mga ito. Ganito ang hitsura nito: Lahat ng exception ay may iisang ninuno sa Throwableklase. Dalawang pangunahing grupo ang hinango dito: mga exception ( Exception ) at mga error ( Error ). Error - Ito ay kumakatawan sa isang kritikal na run-time na error na nauugnay sa pagpapatakbo ng Java virtual machine. Sa karamihan ng mga kaso, ang Error ay hindi kailangang pangasiwaan, dahil ito ay nagpapahiwatig ng ilang mga seryosong depekto sa code. Ang pinakasikat sa mga ito ay ang StackOverflowError (ito ay nangyayari, halimbawa, kapag ang isang pamamaraan ay tumatawag sa sarili nito nang walang hanggan) at OutOfMemoryError(ito ay nangyayari kapag walang sapat na memorya upang lumikha ng mga bagong bagay). Tulad ng nakikita mo, sa mga sitwasyong ito, kadalasan ay wala talagang dapat pangasiwaan sa oras ng pagtakbo: ang code ay naisulat lamang nang hindi tama at kailangang i-rework. Exception - Ito ay kumakatawan, well, isang exception: isang pambihirang, hindi planadong sitwasyon na nangyayari habang tumatakbo ang program. Hindi sila kasingseryoso ng Error, ngunit kailangan pa rin nila ang ating atensyon. Ang lahat ng mga exception ay nahahati sa 2 uri: may check at uncheck . Ang lahat ng may check na exception ay hango sa Exceptionklase. Ano ang ibig sabihin ng "nasuri"? Binanggit namin ito sa huling aralin: "Samakatuwid, alam ng Java compiler ang pinakakaraniwang mga pagbubukod at ang mga sitwasyon kung saan maaaring mangyari ang mga ito." Halimbawa, alam nito na kung ang code ay nagbabasa ng data mula sa isang file, ang file ay madaling hindi umiiral. At mayroong maraming mga ganoong sitwasyon (na maaari nitong ipahiwatig). Alinsunod dito, sinusuri ng compiler ang aming code nang maaga para sa pagkakaroon ng mga potensyal na pagbubukod na ito. Kung mahahanap nito ang mga ito, hindi nito iko-compile ang code hanggang sa mahawakan natin ang mga ito o muling itapon ang mga ito. Ang pangalawang uri ng exception ay "unchecked". Ang mga ito ay hango sa RuntimeExceptionklase. Paano sila naiiba sa mga naka-check na exception? Tila marami ring iba't ibang klase na nagmula saRuntimeException(na naglalarawan ng mga eksepsiyon sa runtime). Ang pagkakaiba ay hindi inaasahan ng compiler ang mga error na ito. Tila sinasabi, "Noong isinulat ang code, wala akong nakitang kahina-hinala, ngunit may nangyaring mali habang tumatakbo ito. Tila, may mga error sa code!" At totoo nga ito. Ang mga hindi na-check na exception ay kadalasang resulta ng mga error sa programmer. At ang compiler ay malinaw na hindi mahuhulaan ang bawat posibleng masamang sitwasyon na maaaring gawin ng mga tao gamit ang kanilang sariling mga kamay. :) Samakatuwid, hindi nito tinitingnan kung ang mga naturang pagbubukod ay pinangangasiwaan sa aming code. Nakatagpo ka na ng ilang hindi na-check na exception:

• Ang ArithmeticException ay nangyayari kapag hinahati sa zero
• Ang ArrayIndexOutOfBoundsException ay nangyayari kapag sinubukan mong i-access ang isang posisyon sa labas ng array.

Siyempre, maaari mong isipin na ang mga tagalikha ng Java ay maaaring nagpasimula ng mandatoryong paghawak sa pagbubukod, ngunit sa kasong ito ang code ay magiging masyadong kumplikado. Para sa anumang operasyon ng paghahati, kailangan mo bang magsulat ng isang try-catchbloke upang suriin kung hindi mo sinasadyang nahati sa zero? Anumang oras na na-access mo ang isang array, kailangan mong magsulat ng isang try-catchbloke upang suriin kung ang iyong index ay wala sa hangganan. Ang lahat ay magiging spaghetti code at magiging ganap na hindi nababasa. Makatuwiran na ang ideyang ito ay inabandona. Bilang resulta, ang mga hindi na-check na exception ay hindi kailangang pangasiwaan sa try-catchmga bloke o muling itapon (bagama't ito ay posible sa teknikal, tulad ng sa Error).

Paano magtapon ng iyong sariling pagbubukod

Siyempre, hindi mahuhulaan ng mga tagalikha ng Java ang bawat pambihirang sitwasyon na maaaring lumitaw sa mga programa. Napakaraming programa sa mundo, at ang mga ito ay masyadong magkakaibang. Ngunit hindi ito dapat ipag-alala, dahil maaari kang lumikha ng iyong sariling pagbubukod, kung kinakailangan. Ito ay napakadaling gawin. Ang kailangan mo lang gawin ay lumikha ng iyong sariling klase. Dapat mong siguraduhin na ang pangalan nito ay nagtatapos sa "Exception". Ang compiler ay hindi nangangailangan nito, ngunit ang ibang mga programmer na nagbabasa ng iyong code ay agad na mauunawaan na ito ay isang exception class. Bilang karagdagan, ipahiwatig na ang klase ay minana mula sa Exceptionklase (ang compiler ay nangangailangan nito). Halimbawa, kumbaga may Dogklase tayo. Maaari nating lakarin ang aso gamit angwalk()paraan. Ngunit bago gawin iyon, kailangan nating suriin kung ang ating alaga ay may suot na kwelyo, tali, at nguso. Kung ang alinman sa gear na ito ay nawawala, itinapon namin ang aming sariling exception: DogIsNotReadyException . Mukhang ganito ang code nito:

public class DogIsNotReadyException extends Exception {

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

Upang ipahiwatig na ang klase ay isang exception, kailangan mong isulat ang " extends Exception " pagkatapos ng pangalan ng klase (ito ay nangangahulugan na "ang klase ay nagmula sa Exception class"). Sa constructor, tinatawagan lang namin ang Exceptionclass constructor na may String message (kung nangyari ang exception, ipapakita namin ang mensahe, isang paglalarawan ng error, sa user). Ganito ang hitsura nito sa aming code ng klase:

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!");
   }
 }

}

Ngayon ang aming walk()pamamaraan ay nagtatapon ng isang DogIsNotReadyException . Ginagawa ito gamit ang keyword throw. Tulad ng sinabi namin kanina, ang isang pagbubukod ay isang bagay. Kaya, kapag may naganap na pagbubukod (ang aso ay may nawawala) sa aming pamamaraan, gumawa kami ng bagong DogIsNotReadyExceptionbagay at itatapon ito gamit ang keyword throw. Nagdagdag kami ng " throws DogIsNotReadyException " sa deklarasyon ng pamamaraan. Sa madaling salita, alam na ngayon ng compiler na ang pagtawag sa walk()pamamaraan ay maaaring maging isang pambihirang sitwasyon. Alinsunod dito, ang pagbubukod na ito ay dapat pangasiwaan kung tatawagin natin ang pamamaraang ito sa isang lugar sa ating programa. Subukan nating gawin ito sa main()pamamaraan:

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

Hindi ito mag-compile. Ang pagbubukod ay hindi pinangangasiwaan! Ibinalot namin ang aming code sa isang try-catchbloke upang mahawakan ang pagbubukod:

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);
   }
}

Ngayon tingnan natin ang output ng console: Naka-on ang kwelyo! Nakabukas ang busal! Naghahanda na kami sa paglalakad! Hindi pa handang maglakad si Buddy! Suriin ang gear! Sinusuri ang gear! Naka-collar ba? totoo Nakasuot ba ang tali? false Nakabukas ba ang nguso? totoo Tingnan kung gaano karaming impormasyon ang output ng console! Nakikita namin ang bawat hakbang na ginawa sa programa; nakikita natin kung saan naganap ang error, at makikita rin natin kung ano mismo ang nawawala sa ating aso. :) At ganyan ka gumawa ng sarili mong mga exception. Tulad ng nakikita mo, walang kumplikado tungkol dito. At kahit na ang mga tagalikha ng Java ay hindi nag-abala na isama sa wika ang isang espesyal na pagbubukod para sa mga asong mahina ang gamit, naayos namin ang kanilang pangangasiwa. :)