Overview

In Java, exceptions are divided into two main categories: Checked Exceptions and Unchecked Exceptions. This distinction is fundamental to Java's exception handling mechanism.

Exception Hierarchy

Throwable ├── Error (Unchecked) │ ├── VirtualMachineError │ │ ├── OutOfMemoryError │ │ └── StackOverflowError │ └── ... ├── Exception │ ├── RuntimeException (Unchecked) │ │ ├── NullPointerException │ │ ├── IllegalArgumentException │ │ ├── ArrayIndexOutOfBoundsException │ │ └── ... │ └── Checked Exceptions │ ├── IOException │ ├── SQLException │ ├── ClassNotFoundException │ └── ...

Checked Exceptions

Definition

Checked exceptions are exceptions that are checked at compile-time. The compiler ensures that these exceptions are either caught or declared in the method signature.

Characteristics

• Must be handled explicitly using try-catch or declared with throws
• Represent conditions that a reasonable application might want to catch
• Extend Exception but not RuntimeException

Common Checked Exceptions

import java.io.*; import java.sql.*; public class CheckedExceptionsExamples { // IOException - Must be handled or declared public void readFile() throws IOException { BufferedReader reader = new BufferedReader(new FileReader("file.txt")); String line = reader.readLine(); reader.close(); } // SQLException - Must be handled or declared public void databaseOperation() throws SQLException { Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/db"); Statement stmt = conn.createStatement(); stmt.executeQuery("SELECT * FROM users"); } // ClassNotFoundException - Must be handled or declared public void loadClass() throws ClassNotFoundException { Class.forName("com.example.MyClass"); } // FileNotFoundException - Must be handled or declared public void openFile() throws FileNotFoundException { FileInputStream fis = new FileInputStream("nonexistent.txt"); } }

Handling Checked Exceptions

public class CheckedExceptionHandling { // Method 1: Declare in throws clause public void methodWithThrows() throws IOException { FileReader file = new FileReader("test.txt"); } // Method 2: Handle with try-catch public void methodWithTryCatch() { try { FileReader file = new FileReader("test.txt"); System.out.println("File opened successfully"); } catch (FileNotFoundException e) { System.out.println("File not found: " + e.getMessage()); } } // Method 3: Combination public void processFile() throws IOException { try { BufferedReader reader = new BufferedReader(new FileReader("data.txt")); String line = reader.readLine(); // Process line } catch (FileNotFoundException e) { System.err.println("Logging error: " + e.getMessage()); throw e; // Re-throw } } }

Unchecked Exceptions

Definition

Unchecked exceptions are exceptions that are not checked at compile-time. They extend RuntimeException or Error.

Characteristics

• Not required to be caught or declared
• Represent programming errors or system problems
• Extend RuntimeException or Error

Common Unchecked Exceptions

public class UncheckedExceptionsExamples { public void demonstrateUncheckedExceptions() { // NullPointerException String str = null; // str.length(); // This would throw NullPointerException // ArrayIndexOutOfBoundsException int[] numbers = {1, 2, 3}; // int value = numbers[5]; // This would throw ArrayIndexOutOfBoundsException // IllegalArgumentException // setAge(-5); // This would throw IllegalArgumentException // NumberFormatException // int num = Integer.parseInt("abc"); // This would throw NumberFormatException // ClassCastException Object obj = "Hello"; // Integer num = (Integer) obj; // This would throw ClassCastException } public void setAge(int age) { if (age < 0) { throw new IllegalArgumentException("Age cannot be negative: " + age); } // Set age } }

Error Examples

public class ErrorExamples { public void causeStackOverflow() { causeStackOverflow(); // Recursive call without base case } public void causeOutOfMemory() { List<byte[]> memoryHog = new ArrayList<>(); while (true) { memoryHog.add(new byte[1024 * 1024]); // 1MB chunks } } }

Key Differences

Best Practices

When to Use Checked Exceptions

public class CheckedExceptionBestPractices { // Use checked exceptions for recoverable conditions public void loadConfiguration(String filename) throws ConfigurationException { try { Properties props = new Properties(); props.load(new FileInputStream(filename)); } catch (IOException e) { throw new ConfigurationException("Failed to load configuration: " + filename, e); } } // Provide meaningful exception messages public void validateUserInput(String input) throws ValidationException { if (input == null || input.trim().isEmpty()) { throw new ValidationException("Input cannot be null or empty"); } if (input.length() < 5) { throw new ValidationException("Input must be at least 5 characters long"); } } } // Custom checked exception class ConfigurationException extends Exception { public ConfigurationException(String message) { super(message); } public ConfigurationException(String message, Throwable cause) { super(message, cause); } } class ValidationException extends Exception { public ValidationException(String message) { super(message); } }

When to Use Unchecked Exceptions

public class UncheckedExceptionBestPractices { // Use unchecked exceptions for programming errors public void processOrder(Order order) { if (order == null) { throw new IllegalArgumentException("Order cannot be null"); } if (order.getItems() == null || order.getItems().isEmpty()) { throw new IllegalStateException("Order must have at least one item"); } // Process order } // Precondition validation public void withdrawMoney(BankAccount account, double amount) { if (account == null) { throw new NullPointerException("Account cannot be null"); } if (amount <= 0) { throw new IllegalArgumentException("Amount must be positive: " + amount); } if (amount > account.getBalance()) { throw new InsufficientFundsException("Insufficient funds"); } account.withdraw(amount); } } // Custom unchecked exception class InsufficientFundsException extends RuntimeException { public InsufficientFundsException(String message) { super(message); } }

Exception Handling Patterns

1. Try-with-resources (Java 7+)

public class TryWithResourcesExample { // Automatic resource management for checked exceptions public void readFile(String filename) { try (BufferedReader reader = new BufferedReader(new FileReader(filename))) { String line; while ((line = reader.readLine()) != null) { System.out.println(line); } } catch (IOException e) { // Handle IOException System.err.println("Error reading file: " + e.getMessage()); } } }

2. Exception Translation

public class ExceptionTranslation { // Translate lower-level exceptions to higher-level abstractions public User loadUser(String userId) throws UserServiceException { try { return userRepository.findById(userId); } catch (SQLException e) { throw new UserServiceException("Failed to load user: " + userId, e); } catch (IOException e) { throw new UserServiceException("Configuration error while loading user", e); } } } class UserServiceException extends Exception { public UserServiceException(String message) { super(message); } public UserServiceException(String message, Throwable cause) { super(message, cause); } }

3. Exception Chaining

public class ExceptionChainingExample { public void processData(String data) throws ProcessingException { try { // Some processing that might throw IOException parseData(data); } catch (IOException e) { // Chain the exception throw new ProcessingException("Failed to process data: " + data, e); } } private void parseData(String data) throws IOException { // Parsing logic } } class ProcessingException extends Exception { public ProcessingException(String message) { super(message); } public ProcessingException(String message, Throwable cause) { super(message, cause); } }

Common Mistakes to Avoid

public class ExceptionMistakes { // ❌ DON'T: Empty catch block (swallowing exceptions) public void badPractice1() { try { // Some code that might throw exception } catch (Exception e) { // Empty - exception completely ignored! } } // ❌ DON'T: Catch generic Exception public void badPractice2() { try { // Some code } catch (Exception e) { // Too broad - might catch unexpected exceptions } } // ❌ DON'T: Throw Exception in method signature public void badPractice3() throws Exception { // Too vague - callers don't know what to expect } // ✅ DO: Be specific about exceptions public void goodPractice1() throws IOException, SQLException { // Caller knows exactly what to handle } // ✅ DO: Log exceptions properly public void goodPractice2() { try { // Some code } catch (SpecificException e) { logger.error("Specific error occurred", e); // Handle or re-throw appropriately } } // ✅ DO: Use finally for cleanup public void goodPractice3() { Connection conn = null; try { conn = getConnection(); // Use connection } catch (SQLException e) { logger.error("Database error", e); } finally { if (conn != null) { try { conn.close(); } catch (SQLException e) { logger.error("Error closing connection", e); } } } } }

Performance Considerations

• Checked exceptions have minimal performance overhead
• Unchecked exceptions are relatively fast when not thrown
• Stack trace generation is expensive - avoid exceptions for normal control flow
• Use exceptions for exceptional circumstances only

Summary

• Use Checked Exceptions for recoverable conditions that callers should handle
• Use Unchecked Exceptions for programming errors and precondition violations
• Always document exceptions that your methods can throw
• Provide meaningful error messages and context
• Don't use exceptions for normal control flow
• Consider the caller's perspective when choosing exception types

Understanding the distinction between checked and unchecked exceptions is crucial for writing robust, maintainable Java applications that handle errors appropriately.