Exception handling in java credit by https://www.examtray.com/sites/default/files/styles/wordpress_800x460/public/2020-07/java-exception-handling-example-tutorial.jpg?itok=9MRW1UTs

1.Learning Exception Handling in Java: A Complete Guide to Study Error Control

by

What is the concept of exception handling in Java?

  • Java’s exception handling system allows a program to handle unexpected events or errors that occur while it is running, ensuring a smooth and uninterrupted execution.
  • An event that disrupts the normal functioning of a program is known as an exception.
  • Various factors, such as user input mistakes, missing files, network issues, mathematical errors (like dividing by zero), or accessing an array index that doesn’t exist, could lead to these errors.
  • Java’s robust exception handling framework offers a systematic approach to handling exceptions, preventing the program from crashing when an issue arises.
  • This enables programmers to pinpoint errors, address them effectively, and ensure that the application operates flawlessly or provides users with valuable information.

 

Why is exception handling in java considered essential?

  • Graceful error recovery: exception handling allows the application to recover from mistakes and continue functioning smoothly without abrupt interruptions.
  • Readability and maintainability: it provides a tidy and organized approach to separating regular program logic from error-handling code.
  • Diagnostics and debugging: exceptions offer crucial diagnostic information, including the specific type of fault and the exact location where it happened.

Types of Exception in Java.

Exceptional handeling in java
Exceptional handeling in java

There are two primary categories into which Java exceptions fall.

  1. Checked Exceptions
  2. Unchecked Exceptions
  3. Errors

Checked Exceptions

  • Checked exceptions are those that are examined during compilation.
  • The Java computer program needs us to point out or write down these computer problems.
  • I/O errors or database connection issues, typically signified by checked exceptions, require programmers to foresee and control these exceptional conditions.

Checked exceptions include, for example.

  1. I/O Problem: When we have an issue with accessing a file, like it being missing, a computer error happens.
  2. When the program can’t connect to the database, a database error happens.
  3. If we can’t find a class when we’re trying to use it, we’ll get a “can’t find it” error message.
  4. Java mandates that handled exceptions be enclosed in a try-catch block or declared in the method signature with the “throws” keyword.

 

import java.io.*;

public class CheckedExceptionExample {
public static void main(String[] args) {
try {
FileReader file = new FileReader(“file.txt”);
BufferedReader fileInput = new BufferedReader(file);
String line = fileInput.readLine();
System.out.println(line);
fileInput.close();
} catch (IOException e) {
System.out.println(“File not found: ” + e);
}
}
}

Unchecked Exceptions.

  • When the app is working, mistake errors happen without needing extra checks before they can be handled.
  • The programmer doesn’t have to deal with these errors by hand, as they won’t be checked while putting the program together.
  • Oops, some mistakes are tricky to predict, like wrong input or wrong logic ideas, leading to unchecked exceptions.

Unchecked exceptions include, for example.

  1. When trying to use something that doesn’t exist, an error message pops up.
  2. When trying to get at a mistake in positioning from a row of items, an error like ArrayIndexOutOfBoundsException happens.
  3. When something goes wrong in math, like trying to split by zero, a Special math Problem pops up.

public class UncheckedExceptionExample {

public static void main(String[] args) {
int result = 10 / 0; // This will throw an ArithmeticException
System.out.println(result);
}
}

Errors

  • In Java, the program usually does not handle errors.
  • Significant system-level problems often lie beyond the programmer’s control.
  • The Java Virtual Machine (JVM) generally generates exceptions, including during other severe issues or memory depletion.
public class ErrorExample {
public static void main(String[] args) {
// This will likely cause an OutOfMemoryError due to infinite recursion.
main(args);
}
}

Java’s Exception Handling Mechanism

  • Java comes with a built-in try-catch block technique for handling exceptions.
  • The fundamental syntax is:

try {
// Block of code that might throw an exception
} catch (ExceptionType1 e1) {
// Code to handle exception of type ExceptionType1
} catch (ExceptionType2 e2) {
// Code to handle exception of type ExceptionType2
} finally {
// Code that will always execute, regardless of an exception (optional)
}

1. try Block:

  • The code that could raise an exception is contained in the try block.
  • Control is sent to the appropriate catch block in the event of an exception.

2. catch Block:

  • The exception is handled by the catch block.
  • To handle various exception kinds, you can have more than one catch block.
  • Every catch block is made to deal with a certain kind of exception.

3. finally Block:

  • Code that always runs after the try and catch blocks, whether or not an exception occurred, is contained in the optional finally block.
  • Cleaning up resources, including deleting files or database connections, is a popular usage for it.

Managing Multiple Exceptions, for Example

import java.io.*;

public class MultipleCatchExample {
public static void main(String[] args) {
try {
int[] numbers = new int[5];
numbers[10] = 100; // ArrayIndexOutOfBoundsException
FileReader file = new FileReader(“nonexistent.txt”); // FileNotFoundException
} catch (ArrayIndexOutOfBoundsException e) {
System.out.println(“Array index is out of bounds: ” + e);
} catch (FileNotFoundException e) {
System.out.println(“File not found: ” + e);
} catch (IOException e) {
System.out.println(“General I/O error: ” + e);
} finally {
System.out.println(“This block always executes.”);
}
}
}

In this instance:

  • The first catch block handles any ArrayIndexOutOfBoundsExceptions that may arise.
  • The second catch block is triggered in the event that a FileNotFoundException occurs.
  • Even in the event of an exception, the finally block will always run to ensure resource cleanup or final operations.

Propagating Exceptions

  • The throws keyword in Java is used to propagate exceptions to the calling function.
  • This enables you to assign exception handling to other program components.

public class ExceptionPropagationExample {
public static void main(String[] args) {
try {
methodA();
} catch (IOException e) {
System.out.println(“Exception caught: ” + e);
}
}

public static void methodA() throws IOException {
throw new IOException(“File not found”);
}
}

The main procedure in this example catches the IOException that methodA raises.

Leave a Comment