Coffee break #220. Paano Ayusin ang Mga Pagbubukod sa Java - Isang Detalyadong Gabay

Source: JavaTechOnline Tutulungan ka ng tutorial na ito na matutunan kung paano ayusin ang mga karaniwang exception sa Java. Bilang karagdagan sa teorya, makakakita ka ng mga halimbawa ng code upang ayusin ang mga naturang problema. Tulad ng iba pang mga programming language, ang mga developer ng Java ay maaaring makatagpo ng mga error o pagbubukod kapag nagsusulat ng code. Ang mga pagbubukod ay dapat na seryosohin dahil ang kanilang paglitaw ay tumatagal ng oras ng trabaho. Gayunpaman, sa kaunting kaalaman, maaari mong pabilisin ang paglutas ng karamihan sa mga problemang ito. Kaya, alamin natin kung paano ayusin ang mga karaniwang pagbubukod sa Java.

Pangkalahatang Mga Alituntunin para sa Pag-iwas sa Mga Pagbubukod sa Java

Upang maiwasan ang pagtapon ng anumang mga pagbubukod sa Java, mahalagang maunawaan at sundin ang mga alituntunin sa coding:

1. Palaging i-validate ang input ng user bago ito gamitin sa iyong code.
2. Gumamit ng try-catch , throws , throw blocks , depende sa kung ano ang naaangkop para sa isang partikular na senaryo.
3. Huwag pabayaan ang mga mensahe sa code tungkol sa pagproseso at mga error. Makakatulong ito na matukoy at maitama ang mga problema.
4. Tiyaking mag-log ng mga pagbubukod para sa mga layunin ng pag-debug. Maaari kang gumamit ng mga mensahe ng logger upang tumulong sa pagtukoy ng mga problema.
5. Sundin ang mga pinakamahuhusay na kagawian sa pag-coding upang maiwasan ang mga pagbubukod at masuri ang iyong code nang lubusan.
6. I-update ang iyong mga dependency sa API para matiyak na ginagamit mo ang pinakabago at pinaka-stable na bersyon ng mga library at frameworks.
7. Gamitin ang mga kinakailangang tool at testing framework para matukoy ang mga potensyal na problema sa iyong code bago sila maglabas ng mga exception.
8. Subaybayan ang pagganap at mga log ng iyong application upang mabilis na matukoy at malutas ang anumang mga isyu.
9. Manatiling napapanahon sa mga pinakamahuhusay na kagawian sa seguridad upang matiyak na ligtas at protektado ang iyong code mula sa anumang potensyal na pag-atake.
10. Idokumento nang lubusan ang iyong code at ang mga pagbubukod nito upang gawing mas madali para sa ibang mga developer na maunawaan at mapanatili.

Listahan ng mga pinakakaraniwang eksepsiyon sa Java

Ang Java ay may medyo mahabang listahan ng mga eksepsiyon. Tingnan natin ang ilan sa mga pinakakaraniwan:

NullPointerException

Ang NullPointerException ay isang uri ng RuntimeException exception . Ito ay nangyayari kapag sinubukan naming gumamit ng reference variable na may null value. Nangangahulugan ito na tumuturo ito sa isang bagay o variable na ang halaga ay null . Ang ganitong error ay maaaring mangyari kapag sinubukan naming tumawag sa isang paraan o mag-access ng field ng isang bagay na hindi pa nasimulan, o kapag ipinasa namin ang null bilang parameter sa isang paraan na hindi humahawak nito. Upang maiwasan ang pagtapon ng NullPointerException , maaari mong suriin kung null ang isang reference variable gamit ang == operator . Kung ito ang kaso, ang null case ay kailangang pangasiwaan nang tama. Bilang kahalili, maaari naming simulan ang aming mga variable sa mga default na halaga (kung saan posible) upang matiyak na hindi kami makakatagpo ng null reference. Ang isa pang paraan upang maiwasan ang isang NullPointerException ay ang paggamit ng Opsyonal na klase . Sa Java, ang Opsyonal ay isang lalagyan na bagay na maaari o hindi naglalaman ng hindi null na halaga. Ito ay ginagamit upang kumatawan sa presensya o kawalan ng isang halaga, katulad ng kung paano ginagamit ang null na halaga upang kumatawan sa kawalan ng isang halaga. Kung sinubukan ng isang programmer na i - access ang walang laman na halaga ng isang Opsyonal na bagay , ang programa ay hindi magtapon ng NullPointerException ngunit sa halip ay magbabalik ng walang laman na Opsyonal na bagay . Sa madaling salita, pinipilit ng Opsyonal ang programmer na pangasiwaan ang kaso kung saan nawawala ang halaga, na tumutulong na maiwasan ang isang NullPointerException .

IndexOutOfBoundsException

Ang IndexOutOfBoundsException ay isang runtime exception na itinapon kapag ang index na ginamit upang ma-access ang isang array o koleksyon ay negatibo o mas malaki kaysa o katumbas ng laki ng array o koleksyon. Upang maiwasang mangyari ang pagbubukod na ito, dapat nating tiyakin na ang index na ginamit upang ma-access ang array o koleksyon ay nasa loob ng mga hangganan nito, ibig sabihin, dapat itong mas malaki sa o katumbas ng zero at mas mababa sa laki ng array o koleksyon.

ArrayIndexOutOfBoundsException

Ang ArrayIndexOutOfBoundsException ay isang uri ng IndexOutOfBoundsException na itinapon kapag sinubukang i-access ang isang array sa isang di-wastong index. Sa Java, ang mga indeks ng array ay nagsisimula sa 0 at nagtatapos sa length()-1 , kung saan ang length() ay ang bilang ng mga elemento sa array. Kung susubukan mong i-access ang isang elemento sa isang index sa labas ng saklaw na ito, ang Java ay magtapon ng ArrayIndexOutOfBoundsException . Kapag nakatagpo ng ArrayIndexOutOfBoundsException , dapat mong suriin ang iyong code upang matiyak na ginagamit mo ang mga tamang indeks kapag ina-access ang mga elemento sa array.

StringIndexOutOfBoundsException

Ang StringIndexOutOfBoundsException ay isang uri ng IndexOutOfBoundsException na itinapon kapag sinubukang i-access ang isang character sa isang string na may di-wastong index. Tulad ng nakaraang ArrayIndexOutOfBoundsException , tandaan na sa Java, ang index ng isang string ay nagsisimula sa 0 at nagtatapos sa length()-1 , kung saan ang length() ay ang bilang ng mga character sa string. Kung susubukan mong i-access ang isang character sa isang index sa labas ng saklaw na ito, maaari kang makatagpo ng isang StringIndexOutOfBoundsException . Kung makatagpo ka ng StringIndexOutOfBoundsException , dapat mong suriin ang iyong code upang matiyak na ginagamit mo ang mga tamang indeks kapag nag-a-access ng mga character sa string.

ClassCastException

Ang pagbubukod na ito ay nangyayari kapag sinubukan naming i-cast ang isang bagay sa isang uri na hindi tugma sa aktwal na uri nito. Upang malutas ang isang problemang tulad nito, mahalagang tiyakin na ang iyong Java program ay sumusubok lamang na mag-cast ng mga bagay sa mga klase kung saan ang mga ito ay mga instance. Maaari mong suriin ang uri ng isang bagay gamit ang instanceof operator bago ilapat ang cast.

IllegalArgumentException

Ang IllegalArgumentException ay isang uri ng RuntimeException na itinapon kapag ang isang pamamaraan ay tinawag na may ilegal o hindi naaangkop na argumento. Sa madaling salita, maaaring mangyari ang error na ito kapag tinawag ang isang pamamaraan na may argumento na nasa labas ng inaasahang hanay o walang inaasahang format o istraktura. Halimbawa, ang isang paraan ay nangangailangan ng isang positibong numero bilang isang argumento at nagbibigay kami ng isang negatibong numero, na hindi wastong input. Kung makatagpo ka ng IllegalArgumentException , dapat mong suriin ang iyong code upang matiyak na tumatawag ka ng mga pamamaraan na may wasto at naaangkop na mga argumento.

IllegalStateException

Ang IllegalStateException ay isang uri ng RuntimeException na itinapon kapag ang isang bagay ay nasa hindi naaangkop na estado para sa operasyong ginagawa. Ito ay maaaring mangyari kung ang isang pamamaraan ay tinawag sa isang bagay na wala sa inaasahang estado. Halimbawa, kung lumikha kami ng object ng koneksyon sa database at pagkatapos ay isasara ito. Pagkatapos, kung susubukan naming lumikha ng isang bagay na Pahayag sa isang saradong koneksyon, magtapon ito ng isang IllegalStateException dahil ang paraan ng createStatement() ay nangangailangan ng isang bukas na koneksyon. Kung makatagpo ka ng IllegalStateException , dapat mong suriin ang iyong code upang matiyak na tumatawag ka ng mga pamamaraan sa mga bagay na nasa naaangkop na estado.

UnsupportedOperationException

Ang UnsupportedOperationException ay isang uri ng RuntimeException na itinapon kapag sinubukang magsagawa ng hindi sinusuportahang operasyon sa isang bagay. Maaaring mangyari ang error na ito kapag tinawag namin ang isang pamamaraan na hindi ipinatupad ng object o hindi sinusuportahan ng object. Upang maiwasan ang pagbubukod ng isang pagbubukod, hindi namin dapat tawagan ang mga naturang operasyon na hindi sinusuportahan sa mga bagay. Kailangan naming suriin ang aming code upang matiyak na kami ay tumatawag ng mga pamamaraan sa mga bagay na sumusuporta sa operasyon.

ArithmeticException

Ang ArithmeticException ay isang uri ng RuntimeException na itinapon kapag ang isang arithmetic operation ay nagdulot ng di-wastong resulta. Maaaring mangyari ang pagbubukod na ito kapag sinubukan naming magsagawa ng operasyon ng aritmetika na may di-wasto o di-wastong argumento. Halimbawa, kapag sinusubukang hatiin sa zero. Upang malutas ang problemang ito, maaari kaming magsagawa ng pagpapatunay ng input at matiyak na ang mga argumento ay nakakatugon sa mga kinakailangang kundisyon bago isagawa ang operasyon ng aritmetika.

SecurityException

Ang SecurityException ay isang uri ng RuntimeException na itinapon kapag may naganap na paglabag sa seguridad sa panahon ng pagpapatupad ng programa. Maaaring mangyari ang error na ito kapag sinubukan ng program na magsagawa ng operasyon na hindi pinahihintulutan ng patakaran sa seguridad. Upang malutas ang problema, dapat nating tiyakin na mayroon tayong access sa mga mapagkukunan at magsagawa ng mga operasyon kung saan mayroon tayong partikular na pahintulot.

NumberFormatException

Ang NumberFormatException ay isang uri ng RuntimeException na itinapon kapag tinawag ang isang paraan upang i-convert ang isang string sa isang format ng numero, ngunit ang string ay wala sa naaangkop na format. Upang malutas ang problemang ito, kailangan muna nating i-validate ang input ng user bago ito subukang i-convert. Suriin din ang iyong code upang matiyak na sinusubukan mong i-convert ang mga string na na-format nang naaangkop para sa target na uri ng numero.

InterruptedException

Ang InterruptedException ay isang may check na exception na itinapon kung naghihintay, natutulog, o nakaharang ang isang thread para sa ilang kaganapan at ang kaganapang iyon ay naantala ng isa pang thread. Maaaring mangyari ang error kapag naghihintay ng input ang isang thread, naglalabas ng lock, o nakumpleto ang ilang iba pang operasyon, at naantala ng isa pang thread ang naghihintay na thread. Upang malutas ang isyung ito, maaari mong mahuli ang InterruptedException at tumugon sa pamamagitan ng paglilinis ng mga mapagkukunan, paghinto sa thread, o paggawa ng iba pang naaangkop na aksyon. Kung makatagpo ka ng InterruptedException , dapat mong suriin ang iyong code upang matiyak na pinangangasiwaan mo nang tama ang mga pagkagambala sa thread.

FileNotFoundException

Ang FileNotFoundException ay isang may check na exception na itinapon kapag sinubukan ng isang program na i-access ang isang file na wala o hindi mahanap sa tinukoy na lokasyon. Maaari itong lumitaw kung ang isang file ay mali ang spelling, inilipat o tinanggal, o kahit na ang isang programa ay walang kinakailangang mga pahintulot upang ma-access ang file. Upang ayusin ang error, maaari kang magsagawa ng pagpapatunay ng input upang matiyak na tama ang landas ng file at ang programa ay may mga kinakailangang pahintulot upang ma-access ang file.

IOException

Ang IOException ay isang may check na exception sa Java na kumakatawan sa isang error na nakatagpo habang nagsasagawa ng input o output operations, gaya ng pagbabasa o pagsusulat sa isang file o network socket. Maaari itong mangyari sa ilang kadahilanan, tulad ng nawawala o hindi naa-access ang tinukoy na file, isang error sa network, o hindi sapat na mga pahintulot. Upang ayusin ang problema, kailangan mong magsagawa ng ilang mga aksyon tulad ng pagsuri sa mensahe ng error, paghawak sa exception gamit ang try-catch , pagsasara ng mga mapagkukunan, pagsuri sa pahintulot ng file, at iba pa.

NoSuchMethodException

Ang NoSuchMethodException ay isang pagbubukod na itinapon sa runtime kapag sinubukan naming tumawag ng isang paraan na wala sa klase. Karaniwang nangyayari ang pagbubukod na ito kung tatawag tayo ng isang pamamaraan gamit ang Class.getMethod() o Class.getDeclaredMethod() at ang tinukoy na pangalan ng pamamaraan ay hindi makikita sa klase o interface. Ang isang pagbubukod ay maaari ding mangyari kapag sinubukan naming tumawag ng isang pamamaraan gamit ang klase ng java.lang.reflect.Method at ang tinukoy na pangalan ng pamamaraan ay hindi umiiral sa object. Upang maiwasan ang pagbubukod na ito, tiyaking tumawag ng wastong pamamaraan na may tamang lagda ng pamamaraan at tagatukoy ng pag-access.

NoSuchFieldException

Ang NoSuchFieldException ay isang runtime exception na nangyayari kapag sinubukan naming i-access ang isang field na wala sa klase. Karaniwang nangyayari ang pagbubukod na ito kapag tumawag kami ng isang pamamaraan gamit ang Class.getField() o Class.getDeclaredField() at ang tinukoy na pangalan ng field ay hindi matatagpuan sa klase o interface. Bukod pa rito, maaari din itong tawagan kung sinusubukan nating i-access ang isang field gamit ang java.lang.reflect.Field class at ang tinukoy na pangalan ng field ay hindi umiiral sa object. Upang maiwasan ang pagbubukod na ito, tiyaking ina-access mo ang isang wastong field na may tamang pangalan at mga modifier ng access. Kung nag-a-access ka ng isang pribadong field, siguraduhing gamitin ang getDeclaredField() method sa halip na getField() method .

IllegalAccessException

Ang IllegalAccessException ay isang run-time exception na nangyayari kapag sinubukan naming i-access ang isang field o pamamaraan sa isang klase ngunit wala kaming mga kinakailangang karapatan sa pag-access. Karaniwang lumilitaw ang pagbubukod na ito kapag sinubukan naming i-access ang isang pribadong field o pamamaraan mula sa labas ng isang klase o kapag sinubukan naming i-access ang isang protektadong field o pamamaraan mula sa isang klase na hindi isang subclass ng orihinal na klase. Maaari din itong tawagan kapag sinusubukang i-access ang isang field o pamamaraan na minarkahan bilang hindi magagamit ng java.lang.reflect.AccessibleObject class . Upang maiwasan ang isyung ito, tiyaking mayroon kang mga kinakailangang pahintulot sa field o paraan na sinusubukan mong i-access. Kung pribado ang field o paraan, maaaring kailanganin mong gumamit ng reflection at itakda ang AccessibleObject sa true (upang ma-access ito). Gayunpaman, mag-ingat kapag gumagamit ng reflection upang ma-access ang mga pribadong field o pamamaraan, dahil maaari itong masira ang encapsulation at makompromiso ang integridad ng klase.

I-verify ang Error

Ang VerifyError ay isang run-time na error na isang subclass ng LinkageError . Ito ay nangyayari kapag ang Java Virtual Machine (JVM) ay nakatagpo ng isang file ng klase na lumalabag sa ilang mga panuntunan sa pagpapatunay. Kapag na-compile ang isang Java class, susuriin ng compiler kung sumusunod ang bytecode sa ilang partikular na panuntunan at paghihigpit, gaya ng kaligtasan ng uri at wastong paggamit ng stack at mga lokal na variable. Kung ang isang file ng klase ay lumalabag sa mga panuntunang ito, ang JVM ay maglalagay ng isang VerifyError kapag naglo-load at nagsusuri ng klase sa runtime. Upang maiwasan ang VerifyError , tiyaking sumusunod ang iyong code sa tamang syntax at semantics ng wikang Java. Kung makatagpo ka ng VerifyError , dapat mong suriin ang iyong code upang matiyak na ito ay wasto at walang mga paglabag sa Java bytecode na mga panuntunan sa pag-verify.

OutOfMemoryError

Ang OutOfMemoryError ay isang subclass ng Error , isang Throwable type na nagpapakilala ng matitinding problema na hindi malulutas sa runtime. Kahit na ang Java 8 ay may kasamang ilang mga pagpapahusay sa koleksyon ng basura at pamamahala ng memorya, maaari ka pa ring makatagpo ng OutOfMemoryError kung ang iyong application ay gumagamit ng masyadong maraming memory o hindi wasto ang pamamahala sa paggamit ng memorya. Upang maiwasan ang OutOfMemoryError , kailangan mong maayos na pamahalaan ang paggamit ng memory sa iyong Java application. Kabilang dito ang paggamit ng mga istruktura at algorithm ng data na mahusay na gumagamit ng memorya, pag-iwas sa hindi kinakailangang paggawa ng bagay, at pagtanggal ng mga bagay nang maayos kapag hindi na kailangan ang mga ito. Bukod pa rito, maaari mong taasan ang maximum na laki ng heap para sa JVM sa pamamagitan ng paggamit ng flag na -Xmx kapag pinapatakbo ang iyong Java program.

StackOverflowError

Ang StackOverflowError ay isang uri ng error na nangyayari kapag ang laki ng stack na kinakailangan ng isang programa ay lumampas sa dami ng memorya na nakalaan dito. Ito ay maaaring mangyari kapag ang isang programa ay tumatawag ng napakaraming mga nested na pamamaraan o kapag ang isang pamamaraan ay tumatawag sa sarili nito nang napakaraming beses, na nagreresulta sa isang walang katapusang loop. Ang Java Virtual Machine (JVM) ay naglalaan ng isang nakapirming dami ng memory para sa execution stack, na ginagamit upang subaybayan ang mga method call at lokal na variable. Kapag umapaw ang stack, naghagis ang JVM ng StackOverflowError . Upang maiwasan ang StackOverflowError , mahalagang matiyak na ang iyong Java program ay gumagawa ng sapat na paggamit ng mga recursion at method na tawag. Kung makakatagpo ka ng StackOverflowError , maaari mong subukang pataasin ang laki ng stack sa pamamagitan ng paggamit ng flag na -Xss kapag pinapatakbo ang iyong Java program.

InvocationTargetException

Ang InvocationTargetException ay isang checked exception na itinapon ng Java reflection mechanism. Ito ay bahagi ng java.lang.reflect.InvocationTargetException package at ginagamit upang isaad na may naganap na exception sa panahon ng isang method o constructor invocation. Kapag ang isang method o constructor ay na-invoke gamit ang Java reflection mechanism, ang invoke() method ng java.lang.reflect.Method o java.lang.reflect.Constructor class ay tinatawag na . Kung ang invoke method o constructor ay naghagis ng exception, ang invoke() method ay nahuhuli ito at binabalot ito sa isang InvocationTargetException . Ang pagbubukod na ito ay ipapasa sa tumatawag ng invoke() method . Upang ayusin ang InvocationTargetException , kailangan nating makuha ito, kunin ang root cause exception gamit ang getCause() method , at pangasiwaan ang root cause exception nang naaayon. Tandaan na ang root cause ay maaaring isang checked exception o runtime exception, kaya siguraduhing hawakan ito ng tama.

Mga paraan upang ayusin ang pinakakaraniwang mga pagbubukod sa Java

Paano ayusin ang NullPointerException

Sitwasyon: Mayroon kang paraan na nag-a-access sa isang bagay na may halaga na null .

String title= null;
System.out.println(title.length()); // Это вызовет NullPointerException

Solusyon #1: Suriin kung ang bagay ay null bago gamitin.

if(title!= null) {
   System.out.println(title.length());
} else {
   System.out.println("title is null");
}

Solusyon #2: Gamitin ang Opsyonal upang maiwasan ang NullPointerException .

Optional<String> optionalTitle = Optional.ofNullable(getTitle());
if (optionalTitle.isPresent()) {
   String title= optionalTitle.get();
   System.out.println("Title: " + title);
} else {
   System.out.println("Title is not available.");
}

Paano ayusin ang ArrayIndexOutOfBoundsException

Scenario: Sinusubukan mong i-access ang isang array sa isang index na nasa labas ng mga hangganan nito.

int[] numbers = {4, 5, 6};
System.out.println(numbers[3]);   // Это вызовет ArrayIndexOutOfBoundsException

Solusyon: Suriin ang haba ng array bago ito i-access at tiyaking gumagamit ka ng mga wastong indeks.

int[] numbers = {4, 5, 6};
if (numbers.length > 3) {
   System.out.println(numbers[3]);
} else {
   System.out.println("ArrayIndexOutOfBoundsException: Please use valid indexes of the Array");
}

Paano ayusin ang ClassCastException

Scenario: Sinusubukan mong i-cast ang isang bagay sa isang uri na hindi tugma sa aktwal na uri nito.

Object obj = "Java Exception";
Integer number = (Integer) obj; // Это вызовет ClassCastException

Solusyon: Tiyaking nag-cast ka lang ng mga bagay sa mga uri na katugma ng mga ito.

Object obj = "Java Exception";
if(obj instanceof Integer) {
   Integer number = (Integer) obj;
   System.out.println(number);
} else {
   System.out.println("Object cannot caste to Integer");
}

Paano ayusin ang IllegalArgumentException

Sitwasyon: Nagpasa ka ng di-wastong argumento sa isang paraan.

public void printNumber(int number) {
   if(number <= 0) {
      throw new IllegalArgumentException("You cannot pass a negative number or zero");
   }
   System.out.println(number);
}

printNumber(-1); // Это вызовет IllegalArgumentException

Solusyon: Tiyaking nagpapasa ka ng mga wastong argumento sa mga pamamaraan. Sa kasong ito, ipasa ang isang positibong numero.

printNumber(1); //  Это успешно напечатает 1.

Paano ayusin ang IllegalStateException

Sitwasyon: Ang bagay ay nasa isang di-wastong estado.

public class Bike {

   private Boolean isStarted;

   public void start() {
      if(isStarted) {
        throw new IllegalStateException("Bike is already started");
      }
      isStarted = true;
      System.out.println("Bike started");
   }
}

Bike bike= new Bike();
bike.start();
bike.start(); // Это вызовет IllegalStateException потому что bike is already started

Solusyon: Tiyaking pinapanatili mo nang tama ang estado ng object.

Bike bike= new Bike();
bike.start();

Paano ayusin ang UnsupportedOperationException

Scenario: Gumagamit ka ng isang operasyon na hindi sinusuportahan ng isang bagay. Ang isang sikat na halimbawa ay kapag ginamit mo ang remove() na operasyon sa isang hindi nababagong koleksyon, malamang na makakita ka ng UnsupportedOperationException exception .

List<String> list = Arrays.asList("Java", "Angular", "Spring");
list.add("Python"); // Это вызовет UnsupportedOperationException

Dahil ang paraan ng Arrays.asList() ay nagbabalik ng isang hindi nababagong listahan, hindi nito sinusuportahan ang pagdaragdag o pag-alis ng mga elemento. Solusyon: Tiyaking tumatawag ka lang sa mga sinusuportahang operasyon sa mga bagay.

List<String> list = new ArrayList<>(Arrays.asList("Java", "Angular" "Spring"));
list.add("Python");
System.out.println(list);

Paano ayusin ang ArithmeticException

Sitwasyon #1: Sinusubukan mong magsagawa ng operasyon ng integer division na gumagawa ng fractional na resulta.

int i = 10;
int j = 4;
int k = i/j; // Это вызовет исключение ArithmeticException: целочисленное деление будет дробным

Narito ang resulta ng operasyon ng paghahati ay 2.5, na isang fractional na halaga. Dahil ang mga integer ay hindi maaaring mag-imbak ng mga fractional na halaga, ang isang ArithmeticException ay itinapon . Solusyon: Upang maiwasan ang pagbubukod na ito, maaari kaming gumamit ng isang uri ng data na sumusuporta sa mga fractional na halaga, tulad ng double , upang iimbak ang resulta ng operasyon ng paghahati. Narito ang isang halimbawa:

int i = 10;
int j = 4;
double k = (double) i/j;

Sitwasyon #2: Subukan mong hatiin sa zero at makukuha mo ang exception na ito. Ito ang pinakakaraniwang senaryo.

int i = 4;
int j = 0;
int k = i/j; // Это вызовет исключение ArithmeticException: нельзя делить на ноль

Solusyon: Hawakan nang tama ang paghahati ng zero. Halimbawa, ang code sa ibaba ay nagpapakita ng tamang pagproseso.

int i = 4;
int j = 0;
if(j != 0) {
int k = i/j;
System.out.println(k);
} else {
System.out.println("ArithmeticException: Cannot divide by zero");
}

Paano ayusin ang IndexOutOfBoundsException

Sitwasyon: Sinusubukan mong i-access ang isang koleksyon na may index na nasa labas nito.

List<String> list = Arrays.asList("Apple", "Papaya", "Mango");
System.out.println(list.get(3)); // Это вызовет IndexOutOfBoundsException

Solusyon: Suriin ang laki ng koleksyon bago ito i-access at tiyaking gumagamit ka ng mga wastong index.

List<String> list = Arrays.asList("Apple", "Papaya", "Mango");
if (list.size() > 3) {
   System.out.println(list.get(3));
} else {
   System.out.println("You are using the Index which is out of bounds");
}

Paano ayusin ang IOException

Sitwasyon: Nabigo ang isang input/output operation dahil hindi naa-access ang file.

try {
   File inputFile = new FileReader("pqr.txt");
   BufferedReader reader = new BufferedReader(inputFile);
   String line = reader.readLine();
   System.out.println(line);
} catch (IOException e) {
   e.printStackTrace();
}

Solusyon: Pangasiwaan ang mga error sa I/O at tiyaking sarado nang tama ang mga mapagkukunan.

File inputFile = new File("pqr.txt");

if (!inputFile.exists() || !inputFile.canRead()) {
 System.out.println("The input file is missing or not readable.");
 return;
}

try {
BufferedReader reader = new BufferedReader(inputFile);
 String line = reader.readLine();
 System.out.println(line);
  reader.close();
} catch (IOException e) {
 e.printStackTrace();
}

Tandaan na bilang alternatibo, maaari naming gamitin ang feature na try-with-resource na ipinakilala sa Java 7 upang awtomatikong isara ang mga mapagkukunan tulad ng ipinapakita sa ibaba. Maaari naming ideklara ang isa o higit pang mga mapagkukunan sa isang pagsubok na pahayag , at awtomatikong isasara ng Java ang mga mapagkukunan sa dulo ng bloke, hindi alintana kung ang bloke ay nakumpleto nang normal o ang isang pagbubukod ay itinapon.

try (BufferedReader reader = new BufferedReader(new FileReader("pqr.txt"))) {
....
} catch {
....
}

Paano ayusin ang FileNotFoundException

Sitwasyon: Ang file ay hindi natagpuan sa tinukoy na lokasyon.

try {
     BufferedReader reader = new BufferedReader(new FileReader("abc.txt"));
     String line = reader.readLine();
     System.out.println(line);
     reader.close();
} catch (FileNotFoundException | IOException e) {
     System.out.println("An error has occurred while reading the file: " + e.getMessage());
}

Solusyon: Tiyaking umiiral ang file at mayroon kang naaangkop na mga pahintulot upang ma-access ito.

try {
    File file = new File("abc.txt");
    if(!file.exists()) {
    throw new FileNotFoundException("File not found at the specified location");
    }
    BufferedReader reader = new BufferedReader(new FileReader(file));
    String line = reader.readLine();
    System.out.println(line);
    reader.close();
} catch (IOException e) {
    e.printStackTrace();
}

Paano ayusin ang NoSuchMethodException

Scenario: Kung sinusubukan mong i-access ang isang paraan na hindi mahanap.

public class TestClass {
   public void sayHello() {
      System.out.println("Hello");
   }
}

TestClass obj = new TestClass();
Method method = obj.getClass().getMethod("printHello"); // Это вызовет NoSuchMethodException

Solusyon: I-verify na umiiral ang pamamaraan at tama ang pangalan at lagda ng pamamaraan.

public class TestClass {
   public void sayHello() {
      System.out.println("Hello");
   }
}

TestClass  obj = new TestClass();
try {
    Method method = obj.getClass().getMethod("sayHello");
} catch (NoSuchMethodException e) {
    e.printStackTrace();
}

Paano ayusin ang ConcurrentModificationException

Scenario: Ang isang koleksyon ay nagbabago habang ito ay inuulit.

List<String> list = new ArrayList<>();
list.add("Java");
list.add("Python");
for (String str : list) {
  list.remove(str);  // Это вызовет ConcurrentModificationException
}

Solusyon: Gumamit ng isang iterator upang umulit sa isang koleksyon at baguhin ito gamit ang mga pamamaraan ng iterator.

List<String> list = new ArrayList<>();
list.add("Java");
list.add("Python");
Iterator<String> iterator = list.iterator();
while (iterator.hasNext()) {
    String str = iterator.next();
    iterator.remove();
}