Subukan ang Java - Mahuli

Maaaring mangyari ang mga error sa panahon ng pagpapatupad ng programa. Ito ay isang karaniwang problema para sa bawat programmer, mula sa isang baguhan hanggang sa isang tunay na propesyonal. Hindi lahat ng error ay nagmumula sa kasalanan ng developer. Ang ilan sa mga ito ay mahirap hulaan, at kung minsan ay hindi ito posible. Halimbawa, habang nagda-download ng program, maaaring biglang bumaba ang koneksyon sa network o maaaring mawalan ng kuryente. Ang ganitong mga sitwasyon ay tinatawag na mga eksepsiyon. Ang Try and catch ay ang mga bahagi ng construction na ginagamit para sa paghawak ng mga exception.

Subukan ng Java at mahuli ang block

Kapag naganap ang isang error, karaniwang humihinto ang Java at bumubuo ng isang mensahe ng error. Ang prosesong ito ay tinatawag na "Java throws an exception". Nagbibigay ang Java ng mga espesyal na pasilidad para sa paghawak ng mga exception. Isa na rito ay subukan...huli...sa wakas construction. Narito ang syntax ng try block, catch block at sa wakas ay block.

//try block
try {
  // Block of code to try
}
//try catch
catch(Exception e) {
  // Block of code to handle errors
}
finally {
 // Optional block of code
          }

Kapag may naganap na exception sa try block, ang control ay pumasa sa catch block, na maaaring humawak sa exception. Kung walang nakitang block, isang hindi nahawakang mensahe ng exception ang ipapakita sa user at ang karagdagang pagpapatupad ng program ay ititigil. Ito ay upang maiwasan ang naturang emergency stop na kailangan mong gamitin ang try..catch block.

Maikling tungkol sa try, catch, sa wakas, throws keywords

Ang paghawak ng eksepsiyon sa Java ay batay sa paggamit ng mga sumusunod na keyword sa isang programa:

• subukan - tumutukoy sa isang bloke ng code kung saan maaaring mangyari ang isang pagbubukod;
• catch - tumutukoy sa block ng code kung saan pinangangasiwaan ang exception;
• sa wakas — tumutukoy sa isang bloke ng code na opsyonal, ngunit kung mayroon, ay isinasagawa pa rin, anuman ang mga resulta ng pagsubok na bloke.

Ang mga keyword na ito ay ginagamit upang lumikha ng mga espesyal na pagpoproseso ng mga konstruksyon sa program code: subukang mahuli, at subukang mahuli sa wakas}.

• throw - ginagamit upang itaas ang isang exception;
• throws — ginagamit sa mga lagda ng pamamaraan upang bigyan ng babala na ang isang pamamaraan ay maaaring maghagis ng eksepsiyon.

Madaling halimbawa ng try-catch construction

Sabihin nating mayroon tayong program na may ilang array.

public class TryTest {
   public static void main(String[] args) {
       int[] myArray = new int[5];
       myArray[7] = 8;
       System.out.println(myArray[7]);
   }
}

Dahil sinusubukan naming i-access ang isang elemento ng array na may hindi umiiral na index, lalabas ang program nang may error: Baguhin natin ang program na ito at pangasiwaan ang pagbubukod na ito gamit ang isang try-catch. Una ay subukan block, mamaya - catch block.

//try catch example
public class TryTest {
   public static void main(String[] args) {
       try {
           int[] myArray = new int[5];
           myArray[7] = 8;
           System.out.println(myArray[7]);
       } catch (Exception myEx) {
           System.out.println("The exception was handled...");
       }

       System.out.println("This is the end of the program...");
   }
}

Ngayon ang output ay nagbago: Sa kasong ito, ang programa ay nakumpleto nang tama, ang aming mensahe ay ipinapakita sa screen. Ang tamang pagwawakas ng programa ay sinenyasan ng code 0 sa dulo ng proseso, habang hindi tama — 1. Kapag gumagamit ng try...catch block, lahat ng statement sa pagitan ng try and catch na mga statement ay unang ipapatupad. Kung ang isang exception ay nangyari sa try block, ang normal na execution order ay hihinto at magpapatuloy sa catch statement. Samakatuwid, kapag ang pagpapatupad ng programa ay umabot sa mga numero[7]=8; linya, ang programa ay titigil at pupunta sa catch block Sa aming kaso, idineklara namin ang variable na myEx na may uri na Exception. Ito ang batayang klase para sa lahat ng mga pagbubukod, at sa gayon ay maaaring magkaiba ang mga ito. Halimbawa, may mga pagbubukod na may pananagutan para sa mga stack overflow, na lumalampas sa array indexing, tulad ng sa aming kaso, na tumuturo sa Null, at iba pa. Kung hindi namin nahulaan ang uri ng pagbubukod, kung gayon ang programa ay hindi rin wastong natapos. Gayunpaman, pinili namin ang uri ng Exception para sa pagiging simple ng halimbawa, at ito ang batayang klase para sa lahat ng exception. Kaya ang catch statement (Exception myEx) ay hahawak sa halos lahat ng mga exception. Pangangasiwa sa pagbubukod sa kasong ito Pagkatapos makumpleto ang catch block, ang programa ay magpapatuloy sa trabaho nito, na isinasagawa ang lahat ng iba pang mga tagubilin pagkatapos ng catch block. Kung gusto mong makita ang mga naganap na pagbubukod, maaari mong ipa-print ang program ng isang stack trace ng mga method call. Ito ang ginagawa ng JVM kapag may naganap na hindi nahuhuling pagbubukod: hihinto nito ang pagpapatupad ng programa, at nagpi-print ng stack trace pagkatapos isagawa ang code ng panghuling bloke, kung naroroon.

public class TryTest {
   public static void main(String[] args) {
       try {
           int[] myArray = new int[5];
           myArray[7] = 8;
           System.out.println(myArray[7]);
       } catch (Exception myEx) {

         myEx.printStackTrace();
       }

       System.out.println("This is the end of the program...");
   }
}

Ang paghawak sa exception sa kasong ito ay bumababa sa pag-print ng error trace stack sa console gamit ang printStackTrace() method na tinukoy sa Exception class. Gayunpaman, ang programa ay lumabas nang tama.

Sa wakas! Pagkatapos mahuli

Sa halimbawa at sa mga kahulugan ng mga pangunahing salita para sa paghawak ng pagbubukod, binanggit namin ang panghuling bloke. Ito ay opsyonal, ngunit kung mayroon, ito ay isasagawa anuman ang mga resulta ng try block. Baguhin natin ang uri ng exception sa NullPointerException.

public class TryTest {
   public static void main(String[] args) {
       try {
           int[] myArray = new int[5];
           myArray[7] = 8;
           System.out.println(myArray[7]);
       } catch (NullPointerException myEx) {
           System.out.println("The exception was handled...");

       }

       finally{
           System.out.println(" finally");
       }

       System.out.println("This is the end of the program...");
   }
}

Narito ang output: Sa pamamagitan ng paraan, maaari naming tukuyin ang uri ng pagbubukod upang maging tama. Narito ito ay IndexOutOfBoundsException.

public class TryTest {
   public static void main(String[] args) {
       try {
           int[] myArray = new int[5];
           myArray[7] = 8;
           System.out.println(myArray[7]);
       } catch (IndexOutOfBoundsException myEx) {
           System.out.println("The exception was handled...");

       }

       finally{
           System.out.println(" finally");
       }

       System.out.println("This is the end of the program...");
   }
}

Sa kasong ito, ang output ay magiging tulad ng sumusunod:

Paano gumagana ang mga exception?

Ang punto ay ang lahat ng mga salitang ito —catch, throw, throws ay magagamit lamang sa java.lang.Throwable o sa mga inapo nito. Halimbawa, magagawa mo ito:

public class MyClass {
    public static void main(String[] args) {
        try {
        } catch (Throwable thr) {
}
    }
}

Gayunpaman, hindi mo magagawa ito tulad nito:

public class MyClass {
public static void main(String[] args) {
        try {
        } catch (String thr) {
}
    }
}