**Course Title:** Comprehensive Java Programming: From Basics to Advanced Concepts **Section Title:** Exception Handling in Java **Topic:** Write programs that handle various exceptions and create custom exception classes.(Lab topic) **Introduction:** In the previous topic, we discussed the basics of exception handling in Java, including checked and unchecked exceptions, try-catch blocks, and creating custom exceptions. In this lab, we will put our knowledge into practice by writing programs that handle various exceptions and create custom exception classes. **Lab Objectives:** - Understand how to handle different types of exceptions in Java - Learn how to create custom exception classes - Practice writing programs that handle exceptions using try-catch blocks and finally blocks - Understand best practices for error handling in Java **Handling Different Types of Exceptions:** In Java, there are two types of exceptions: checked and unchecked exceptions. Checked exceptions are those that occur at compile-time, whereas unchecked exceptions occur at runtime. In this lab, we will handle both checked and unchecked exceptions. **Example 1: Handling Checked Exceptions** Imagine we have a method that reads a file and returns the contents. This method throws a FileNotFoundException if the file is not found. We can handle this exception using a try-catch block. ```java import java.io.File; import java.io.FileNotFoundException; import java.util.Scanner; public class Main { public static void main(String[] args) { try { readFromFile("example.txt"); } catch (FileNotFoundException e) { System.out.println("File not found: " + e.getMessage()); } } public static void readFromFile(String filename) throws FileNotFoundException { File file = new File(filename); Scanner scanner = new Scanner(file); while (scanner.hasNextLine()) { System.out.println(scanner.nextLine()); } scanner.close(); } } ``` In this example, we handle the FileNotFoundException using a try-catch block. If the file is not found, the program prints a message to the console. **Example 2: Handling Unchecked Exceptions** Imagine we have a method that performs arithmetic operations. This method throws an ArithmeticException if division by zero occurs. We can handle this exception using a try-catch block. ```java public class Main { public static void main(String[] args) { try { divide(10, 0); } catch (ArithmeticException e) { System.out.println("Division by zero: " + e.getMessage()); } } public static void divide(int numerator, int denominator) { int result = numerator / denominator; System.out.println("Result: " + result); } } ``` In this example, we handle the ArithmeticException using a try-catch block. If division by zero occurs, the program prints a message to the console. **Creating Custom Exception Classes:** In Java, you can create custom exception classes that extend the Exception class or its subclasses. Custom exception classes can have constructors, fields, and methods like any other class. **Example 3: Creating a Custom Exception Class** Imagine we want to create a custom exception class called InsufficientBalanceException that throws an exception when the balance is insufficient. ```java // Custom exception class public class InsufficientBalanceException extends Exception { public InsufficientBalanceException(String message) { super(message); } } // Using the custom exception class public class Main { public static void main(String[] args) { try { withdraw(100, 500); } catch (InsufficientBalanceException e) { System.out.println("Insufficient balance: " + e.getMessage()); } } public static void withdraw(int amount, int balance) throws InsufficientBalanceException { if (balance < amount) { throw new InsufficientBalanceException("Insufficient balance"); } System.out.println("Withdrawal successful"); } } ``` In this example, we create a custom exception class called InsufficientBalanceException and use it in our program. If the balance is insufficient, the program throws the custom exception. **Best Practices for Error Handling:** 1. Handle specific exceptions instead of catching the general Exception class. 2. Use the finally block to release resources and clean up. 3. Avoid throwing exceptions from constructors. 4. Use the try-with-resources statement to automatically close resources. 5. Keep exception messages informative and concise. **Conclusion:** In this lab, we wrote programs that handled various exceptions and created custom exception classes. We also discussed best practices for error handling in Java. Remember to handle specific exceptions, use the finally block, and keep exception messages informative and concise. **What's Next?** In the next topic, we will learn how to read and write files using FileReader, FileWriter, and BufferedReader. You can access the topic here: [Java Tutorials - File I/O and Working with External Data](https://docs.oracle.com/javase/tutorial/essential/io/index.html) **Leave a Comment or Ask for Help:** If you have any questions or need help with the lab, please leave a comment below. We will respond to your queries as soon as possible.