Mga pagbubukod: may check, walang check at sa iyo

Kamusta! Sa huling panayam, nakilala namin ang isang aspeto ng wikang Java bilang mga eksepsiyon at nakakita ng mga halimbawa ng pakikipagtulungan sa kanila. Ngayon ay titingnan natin nang mas malalim ang kanilang istraktura, at matututunan din kung paano magsulat ng sarili nating mga pagbubukod :)

Mga uri ng pagbubukod

Gaya ng sinabi namin, maraming exception class sa Java, halos 400! Ngunit lahat sila ay nahahati sa mga grupo, kaya medyo madaling matandaan ang mga ito. Narito kung ano ang hitsura nito: Ang lahat ng mga pagbubukod ay may isang karaniwang ancestor class Throwable. Dalawang malalaking grupo ang nanggaling dito - mga exception (Exception) at mga error (Error). Ang error ay isang kritikal na error sa panahon ng pagpapatupad ng programa 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 pinakatanyag na mga error: StackOverflowError- nangyayari, halimbawa, kapag ang isang pamamaraan ay walang katapusang tumatawag sa sarili nito, at OutOfMemoryError- nangyayari kapag walang sapat na memorya upang lumikha ng mga bagong bagay. Tulad ng nakikita mo, sa mga sitwasyong ito, kadalasan ay walang espesyal na iproseso - ang code ay naisulat lamang nang hindi tama at kailangang muling ayusin. Ang mga pagbubukod ay, sa katunayan, mga pagbubukod: isang pambihirang, hindi planadong sitwasyon na naganap habang tumatakbo ang programa. Hindi ito mga error na kasingseryoso ng Error, ngunit nangangailangan ito ng ating atensyon. Ang lahat ng mga pagbubukod ay nahahati sa 2 uri - may check ( may check ) at walang check ( walang check ). Lahat ng may check na exception ay nagmula sa Exception. Ano ang ibig sabihin ng "napapatunayan"? Bahagyang binanggit namin ito sa huling lecture : "...alam ng Java compiler ang tungkol sa mga pinakakaraniwang exception, at alam kung anong mga sitwasyon ang maaaring mangyari." Halimbawa, alam niya na kung ang isang programmer ay nagbabasa ng data mula sa isang file sa code, ang sitwasyon ay madaling lumitaw na ang file ay hindi umiiral. At maraming mga ganoong sitwasyon na maaari niyang mahulaan nang maaga. Samakatuwid, sinusuri ng compiler ang aming code nang maaga para sa mga potensyal na pagbubukod. Kung mahahanap nito ang mga ito, hindi nito iko-compile ang code hanggang sa iproseso namin ang mga ito o ipasa ang mga ito sa itaas. Ang pangalawang uri ng exception ay "unchecked". Galing sila sa klase RuntimeException. Paano sila naiiba sa mga sinusuri? Mukhang mayroon ding grupo ng iba't ibang klase na nagmumula RuntimeExceptionat naglalarawan ng mga partikular na eksepsiyon sa runtime. Ang pagkakaiba ay hindi inaasahan ng compiler ang mga error na ito. Mukhang sinasabi niya: "Sa oras ng pagsulat ng code, wala akong nakitang kahina-hinala, ngunit may nangyaring mali habang ito ay gumagana. Tila may mga error sa code!" At totoo nga. Ang mga hindi na-check na exception ay kadalasang resulta ng mga error sa programmer. At ang compiler ay malinaw na hindi makakapagbigay para sa lahat ng posibleng maling sitwasyon na maaaring gawin ng mga tao gamit ang kanilang sariling mga kamay :) Samakatuwid, hindi nito susuriin ang paghawak ng mga naturang eksepsiyon sa aming code. Nakatagpo ka na ng ilang hindi na-check na exception:

• ArithmeticExceptionnangyayari kapag hinati sa zero
• ArrayIndexOutOfBoundsExceptionNangyayari kapag sinusubukang i-access ang isang cell sa labas ng array.

Sa teoryang, siyempre, maaaring ipinakilala ng mga tagalikha ng Java ang mandatoryong paghawak sa mga naturang eksepsiyon, ngunit ano kaya ang magiging code noon? Sa anumang operasyon ng paghahati ng mga numero, kailangan mong magsulat ng try-catch upang masuri kung hindi mo sinasadyang nahati sa zero? Sa tuwing nag-a-access ng array, kailangan mong magsulat ng try-catch para tingnan kung lumampas ka sa mga limitasyong ito. Ang anumang code na nakasulat ay magiging spaghetti at ganap na hindi nababasa. Ito ay lohikal na ang ideyang ito ay inabandona. Samakatuwid, ang mga hindi na-check na mga pagbubukod ay hindi kailangang pangasiwaan sa mga bloke ng try-catch o itapon sa itaas, bagaman posible ito sa teknikal, tulad ng sa Error.

Paano itapon ang iyong exception

Siyempre, ang mga tagalikha ng Java ay hindi makakapagbigay para sa lahat ng pambihirang sitwasyon na maaaring lumitaw sa mga programa. Napakaraming programa sa mundo, at masyadong iba ang mga ito. Ngunit okay lang iyon, dahil maaari kang lumikha ng iyong sariling mga pagbubukod kung kinakailangan. Ginagawa ito nang napakadali. Ang kailangan mo lang gawin ay lumikha ng iyong sariling klase. Dapat magtapos ang pangalan nito sa “Exception”. Hindi ito kailangan ng compiler, ngunit ang mga programmer na nagbabasa ng iyong code ay agad na mauunawaan na ito ay isang exception class. Bilang karagdagan, kailangan mong ipahiwatig na ang klase ay nagmula sa klase Exception. Ito ay kinakailangan na para sa compiler at tamang operasyon. Halimbawa, mayroon kaming klaseng Aso - Dog. Maaari nating lakarin ang aso gamit ang walk(). Ngunit bago iyon, kailangan nating suriin kung ang ating alaga ay may suot na kwelyo, tali at nguso. Kung ang alinman sa mga ito ay nawawala, itatapon namin ang sarili naming exception DogIsNotReadyException. Magiging ganito ang code nito:

public class DogIsNotReadyException extends Exception {

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

Upang ipahiwatig na ang isang klase ay isang exception, kailangan mong magsulat ng extends Exception pagkatapos ng pangalan ng klase: nangangahulugan ito na "ang klase ay nagmula sa klase ng Exception." Sa constructor, tatawagin lang natin ang class constructor Exceptionna may linya message- magpapakita ito sa user ng mensahe mula sa system na naglalarawan sa error na naganap. Ito ang magiging 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("Let's go for a walk!");
   if (isCollarPutOn && isLeashPutOn && isMuzzlePutOn) {
       System.out.println("Hurrah, let's go for a walk!" + name + " I am glad!");
   } else {
       throw new DogIsNotReadyException("Dog " + name + "not ready for a walk! Check your gear!");
   }
 }

}

Ngayon ang aming pamamaraan walk()ay nagtatapon ng isang pagbubukod DogIsNotReadyException. Ginagawa ito gamit ang keyword throw. Tulad ng sinabi namin kanina, ang isang pagbubukod ay isang bagay. Samakatuwid, sa aming pamamaraan, kapag nangyari ang isang pambihirang sitwasyon - may nawawala sa aso - lumikha kami ng isang bagong bagay sa klase DogIsNotReadyExceptionat itinapon ito sa programa gamit ang salita throw. walk()Nagdaragdag kami ng mga throws sa lagda ng pamamaraan DogIsNotReadyException. Sa madaling salita, alam na ngayon ng compiler na ang isang method call walk()ay maaaring magresulta sa isang exception. Kaya kapag tinawag namin ito sa isang lugar sa programa, ang pagbubukod ay kailangang pangasiwaan. Subukan nating gawin ito sa pamamaraan main():

public static void main(String[] args) {

   Dog dog = new Dog("Mukhtar");
   dog.putCollar();
   dog.putMuzzle();
   dog.walk();//Unhandled exception: DogIsNotReadyException
}

Hindi nag-compile, hindi pinangangasiwaan ang pagbubukod! I-wrap natin ang ating code sa isang bloke try-catchpara mahawakan ang exception:

public static void main(String[] args) {

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

Ngayon tingnan natin ang output ng console:

Ошейник надет! 
Намордник надет! 
Собираемся на прогулку! 
Собака Мухтар не готова к прогулке! Проверьте экипировку! 
Проверяем снаряжение! Ошейник надет? true
Поводок надет? false 
Намордник надет? true

Tingnan kung gaano naging mas informative ang output ng console! Nakikita namin ang bawat hakbang na nangyari sa programa; Nakikita namin kung saan nangyari ang error at agad naming napansin kung ano ang eksaktong nawawala sa aming aso :) Ganito kami gumawa ng sarili naming mga exception. Tulad ng nakikita mo, walang kumplikado. At kahit na ang mga developer ng Java ay hindi nag-abala na magdagdag ng isang espesyal na pagbubukod sa kanilang wika para sa mga asong hindi tama ang gamit, itinuwid namin ang kanilang pangangasiwa :)