Exception handling in Java

Exceptions in programming are events that occur during the execution of a program and disrupt the normal flow of its instructions. They are typically used to signal error conditions or other unusual circumstances that the program may encounter, such as trying to divide by zero, attempting to access an out-of-bounds index in an array, or failing to open a file.

Types of Exceptions

  1. Runtime Exceptions: These exceptions occur during the execution of the program and are often due to programming errors, such as logic mistakes or incorrect use of APIs. Examples include:

    • NullPointerException: When an application attempts to use null in a case where an object is required.
    • ArrayIndexOutOfBoundsException: When an attempt is made to access an array element with an invalid index.
    • ArithmeticException: When an exceptional arithmetic condition has occurred, like division by zero.

  2. Checked Exceptions: These exceptions are checked at compile time, and the programmer is required to handle them explicitly. Examples include:

    • IOException: When an input-output operation fails or is interrupted.
    • SQLException: When there is a database access error or other errors related to database operations.

  3. Errors: These are serious problems that a reasonable application should not try to catch. They are generally outside the control of the program and indicate problems like system errors. Examples include:

    • OutOfMemoryError: When the Java Virtual Machine (JVM) cannot allocate an object because it is out of memory.
    • StackOverflowError: When the stack depth limit is exceeded, usually due to deep or infinite recursion.

Exception Handling Mechanism

Most programming languages provide constructs to handle exceptions, ensuring that programs can handle errors gracefully and continue running or terminate cleanly.

In Java

Java uses a combination of try, catch, finally, throw, and throws for exception handling.

  1. try: Encapsulates code that might throw an exception.
  2. catch: Catches and handles the exception.
  3. finally: Contains code that will always execute, regardless of whether an exception was thrown or not.
  4. throw: Used to explicitly throw an exception.
  5. throws: Used in a method signature to declare that the method might throw one or more exceptions.

Example 1:

public class ExceptionExample {
    public static void main(String[] args) {
        try {
            int[] numbers = {1, 2, 3};
            System.out.println(numbers[3]); 

// This will throw an ArrayIndexOutOfBoundsException
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("Array index is out of bounds!");
        } finally {
            System.out.println("This will always execute.");
        }
    }
}

Example 2:

public class DivisionExample {
    public static void main(String[] args) {
        int numerator = 10;
        int[] denominators = {2, 0, 5};

        for (int denominator : denominators) {
            try {
                int result = divide(numerator, denominator);
                System.out.println("Result: " + result);
            } catch (ArithmeticException e) {
                System.out.println("Cannot divide by zero!");
            } finally {
                System.out.println("Division attempt completed.");
            }
        }
    }

    public static int divide(int num, int denom) {
        return num / denom;
    }
}


Custom Exceptions
Custom exceptions in Java allow you to create your own exceptions tailored to the specific needs of your application. These custom exceptions can be either checked or unchecked.

Checked exceptions are exceptions that are checked at compile-time. When you create a custom checked exception, you need to handle or declare it explicitly in your code. Custom checked exceptions are typically used for conditions that a reasonable application might want to catch.

Unchecked exceptions are exceptions that are not checked at compile-time. They are typically used to indicate programming errors, such as logic errors or improper use of an API. 

Throwing custom exceptions in Java involves defining a new exception class that extends either Exception (for checked exceptions) or RuntimeException (for unchecked exceptions). Once the custom exception class is defined, you can throw instances of it in your code.

Steps to Create and Throw Custom Exceptions
  1. Define the Custom Exception Class: Create a class that extends Exception or RuntimeException.
  2. Throw the Custom Exception: Use the throw keyword to throw an instance of your custom exception.
  3. Handle the Custom Exception: Use try-catch blocks to handle the custom exception where necessary.
Example: Custom Checked Exception

First, let's define a custom checked exception by extending Exception.

class CustomCheckedException extends Exception {
    public CustomCheckedException(String message) {
        super(message);
    }
}
public class Main {
    public static void main(String[] args) {
        try {
            validateAge(15);
        } catch (CustomCheckedException e) {
            System.out.println("Caught custom exception: " + e.getMessage());
        }
    }

    public static void validateAge(int age) throws CustomCheckedException {
        if (age < 18) {
            throw new CustomCheckedException("Age must be 18 or older.");
        }
        System.out.println("Age is valid.");
    }
}

Example: Custom Unchecked Exception

Now, let's define a custom unchecked exception by extending RuntimeException.

class CustomUncheckedException extends RuntimeException {

    public CustomUncheckedException(String message) {
        super(message);
    }
}
public class Main {
    public static void main(String[] args) {
        try {
            checkNumber(-1);
        } catch (CustomUncheckedException e) {
            System.out.println("Caught custom exception: " + e.getMessage());
        }
    }

    public static void checkNumber(int number) {
        if (number < 0) {
            throw new CustomUncheckedException("Number must be non-negative.");
        }
        System.out.println("Number is valid.");
    }
}

Key Points
  • Extending Exception: Use this for checked exceptions. These need to be declared in the method signature using the throws keyword.
  • Extending RuntimeException: Use this for unchecked exceptions. These do not need to be declared or caught.
  • Custom Message: Provide a meaningful message to the custom exception's constructor to describe the error.
  • Throwing the Exception: Use the throw keyword to throw an instance of your custom exception.
  • Handling the Exception: Use try-catch blocks to handle the custom exception where necessary.

By creating custom exceptions, you can handle specific error conditions in a more meaningful and controlled manner.

Comments

Post a Comment

Popular posts from this blog

KTU OOP LAB JAVA CSL 203 BTech CS S3 - Dr Binu V P

About Me Scheme and Evaluation Syllabus and Practice Questions ******************************** How to do Java Programs in  Debian PART A Basic Java Programs Using Control  Statements 1.String Problems 2.Numerical Problems 3.Arrays 4.Matrix Lab Exercise Java-1 PART B  Object Oriented Programming 1.Creating classes and objects. constructor for initializing object 2.Method overloading in Java 3.Single Inheritance 4.Multilevel Inheritance 5.Method overriding in Java 6. Hierarchical Inheritance 7.Interface in Java 8.Abstract classes in java  PART C Exception and File Handling 1.Exception Handling in Java 2.Reading and Writing Text Files 3.Buffered Reader and String Tokenizer PART D Multi-Threading  Creating Threads in Java Thread Synchronization in Java Thread Priorities in Java Programs using Multi-Threading PART E Graphics and Database Programming Introduction to Java Swing Drawing Shapes Drawing  a Sine Wave Handling Mouse Events Handling Keyboard ...
Read more

Reading and Writing Text Files

Handling text files in Java involves performing operations like reading from, writing to, and appending to files. Here are some common techniques and examples for handling text files in Java: FileReader and BufferedReader are classes in Java used for reading text from files. Here’s a detailed explanation of each: FileReader FileReader is a class in Java that is used to read character files. It is a convenient class for reading text files using the default character encoding of the operating system. Key Points: Purpose : To read text files. Inheritance : It extends InputStreamReader , which in turn extends Reader . Encoding : Uses the default character encoding of the operating system unless specified otherwise. Basic Usage : Suitable for simple file reading tasks. Example: create a text file "example.txt" using any text editor and then run this program.In this example, FileReader reads the file character by character. import java.io.FileReader; import java.io.IOException; ...
Read more

String Problems

Reverse a String import java.util.Scanner; public class ReverseString { public static void main(String[] args) {      Scanner scanner = new Scanner(System.in);      System.out.print("Enter a string to reverse: ");      String input = scanner.nextLine();      String reversed = new StringBuilder(input).reverse().toString();      System.out.println("Reversed string: " + reversed);      scanner.close(); } } without using StringBuilder import java.util.Scanner; public class ReverseString {     public static void main(String[] args) {         Scanner scanner = new Scanner(System.in);         System.out.print("Enter a string to reverse: ");         String input = scanner.nextLine();         // Manually reverse the string         String reversed = "";         for (int i = input....
Read more