Java Exception Handling - Complete Tutorial

public class CommonExceptionsExample {
    public static void main(String[] args) {
        System.out.println("=== Common Java Exceptions ===");
        
        // 1. NullPointerException (Unchecked)
        try {
            String str = null;
            System.out.println("Length: " + str.length()); // This will throw NPE
        } catch (NullPointerException e) {
            System.out.println("1. NullPointerException caught: " + e.getMessage());
        }
        
        // 2. ArithmeticException (Unchecked)
        try {
            int result = 10 / 0; // Division by zero
        } catch (ArithmeticException e) {
            System.out.println("2. ArithmeticException caught: " + e.getMessage());
        }
        
        // 3. ArrayIndexOutOfBoundsException (Unchecked)
        try {
            int[] numbers = {1, 2, 3};
            System.out.println(numbers[5]); // Invalid index
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("3. ArrayIndexOutOfBoundsException caught: " + e.getMessage());
        }
        
        // 4. NumberFormatException (Unchecked)
        try {
            String invalidNumber = "abc123";
            int num = Integer.parseInt(invalidNumber);
        } catch (NumberFormatException e) {
            System.out.println("4. NumberFormatException caught: " + e.getMessage());
        }
        
        // 5. IllegalArgumentException (Unchecked)
        try {
            setAge(-5);
        } catch (IllegalArgumentException e) {
            System.out.println("5. IllegalArgumentException caught: " + e.getMessage());
        }
        
        // 6. ClassCastException (Unchecked)
        try {
            Object obj = "Hello";
            Integer num = (Integer) obj; // Invalid cast
        } catch (ClassCastException e) {
            System.out.println("6. ClassCastException caught: " + e.getMessage());
        }
        
        // 7. StringIndexOutOfBoundsException (Unchecked)
        try {
            String text = "Hello";
            char ch = text.charAt(10); // Invalid string index
        } catch (StringIndexOutOfBoundsException e) {
            System.out.println("7. StringIndexOutOfBoundsException caught: " + e.getMessage());
        }
        
        // 8. NegativeArraySizeException (Unchecked)
        try {
            int[] arr = new int[-5]; // Negative array size
        } catch (NegativeArraySizeException e) {
            System.out.println("8. NegativeArraySizeException caught: " + e.getMessage());
        }
        
        System.out.println("\nProgram continues normally after handling exceptions!");
    }
    
    private static void setAge(int age) {
        if (age < 0) {
            throw new IllegalArgumentException("Age cannot be negative: " + age);
        }
        System.out.println("Age set to: " + age);
    }
}

import java.util.Scanner;

public class TryCatchFinallyExample {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        
        System.out.println("=== Try-Catch-Finally Examples ===");
        
        // Example 1: Basic try-catch
        System.out.println("\n--- Example 1: Basic Try-Catch ---");
        try {
            System.out.print("Enter numerator: ");
            int numerator = scanner.nextInt();
            System.out.print("Enter denominator: ");
            int denominator = scanner.nextInt();
            
            int result = numerator / denominator;
            System.out.println("Result: " + result);
        } catch (ArithmeticException e) {
            System.out.println("Error: Division by zero is not allowed!");
        } catch (Exception e) {
            System.out.println("Unexpected error: " + e.getMessage());
        }
        
        // Example 2: Multiple catch blocks
        System.out.println("\n--- Example 2: Multiple Catch Blocks ---");
        try {
            System.out.print("Enter array size: ");
            int size = scanner.nextInt();
            int[] array = new int[size];
            
            System.out.print("Enter index to access: ");
            int index = scanner.nextInt();
            
            System.out.print("Enter value to store: ");
            String value = scanner.next();
            
            array[index] = Integer.parseInt(value);
            System.out.println("Value stored successfully!");
            
        } catch (NegativeArraySizeException e) {
            System.out.println("Error: Array size cannot be negative!");
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("Error: Invalid array index!");
        } catch (NumberFormatException e) {
            System.out.println("Error: Invalid number format!");
        } catch (Exception e) {
            System.out.println("General error: " + e.getMessage());
        }
        
        // Example 3: Try-catch-finally with resources
        System.out.println("\n--- Example 3: Try-Catch-Finally ---");
        Scanner fileScanner = null;
        try {
            System.out.print("Enter filename to open: ");
            String filename = scanner.next();
            
            // Simulating file operations
            if (filename.equals("missing.txt")) {
                throw new RuntimeException("File not found: " + filename);
            }
            
            System.out.println("Processing file: " + filename);
            // File processing logic here
            
        } catch (RuntimeException e) {
            System.out.println("File error: " + e.getMessage());
        } finally {
            // This block ALWAYS executes
            System.out.println("Finally block executed - cleaning up resources");
            if (fileScanner != null) {
                fileScanner.close();
            }
        }
        
        // Example 4: Nested try-catch
        System.out.println("\n--- Example 4: Nested Try-Catch ---");
        try {
            // Outer try block
            System.out.println("Outer try block started");
            
            try {
                // Inner try block
                System.out.print("Enter a number: ");
                int num = scanner.nextInt();
                
                if (num < 0) {
                    throw new IllegalArgumentException("Negative numbers not allowed");
                }
                
                System.out.println("Square root: " + Math.sqrt(num));
                
            } catch (IllegalArgumentException e) {
                System.out.println("Inner catch: " + e.getMessage());
                throw e; // Re-throwing exception
            } finally {
                System.out.println("Inner finally executed");
            }
            
            System.out.println("Outer try block completed");
            
        } catch (Exception e) {
            System.out.println("Outer catch: " + e.getClass().getSimpleName());
        } finally {
            System.out.println("Outer finally executed");
        }
        
        // Example 5: Try-with-resources (Java 7+)
        System.out.println("\n--- Example 5: Try-With-Resources ---");
        try (Scanner autoCloseScanner = new Scanner(System.in)) {
            System.out.print("Enter your name: ");
            String name = autoCloseScanner.nextLine();
            System.out.println("Hello, " + name + "!");
            
            // Scanner auto-closes here
        } catch (Exception e) {
            System.out.println("Error: " + e.getMessage());
        }
        
        System.out.println("\n=== Program Completed Successfully ===");
        scanner.close();
    }
    
    // Helper method demonstrating exception propagation
    private static void riskyMethod() throws Exception {
        System.out.println("Executing risky method...");
        if (Math.random() > 0.5) {
            throw new Exception("Something went wrong!");
        }
        System.out.println("Risky method completed successfully");
    }
}

import java.io.*;
import java.util.logging.*;

public class BestPracticesExample {
    private static final Logger logger = 
        Logger.getLogger(BestPracticesExample.class.getName());
    
    public static void main(String[] args) {
        System.out.println("=== Exception Handling Best Practices ===");
        
        // Practice 1: Specific exceptions over general ones
        try {
            readConfiguration("config.properties");
        } catch (FileNotFoundException e) {
            // Specific handling for missing file
            logger.severe("Configuration file not found: " + e.getMessage());
            System.out.println("Using default configuration");
        } catch (IOException e) {
            // General IO errors
            logger.severe("IO error reading configuration: " + e.getMessage());
        }
        
        // Practice 2: Try-with-resources
        try (BufferedReader reader = new BufferedReader(
                new FileReader("data.txt"))) {
            String line;
            while ((line = reader.readLine()) != null) {
                processLine(line);
            }
        } catch (IOException e) {
            logger.log(Level.SEVERE, "Error reading file", e);
        }
        
        // Practice 3: Never swallow exceptions
        badPracticeSwallowException();
        goodPracticeLogException();
        
        // Practice 4: Use exceptions for exceptional conditions
        validateInputBeforeProcessing("valid input");
        
        // Practice 5: Include cause when re-throwing
        try {
            processData();
        } catch (ProcessingException e) {
            logger.log(Level.SEVERE, "Data processing failed", e);
            // Original cause is preserved
            System.out.println("Root cause: " + e.getCause().getMessage());
        }
        
        // Practice 6: Clean up in finally or try-with-resources
        Connection connection = null;
        try {
            connection = openDatabaseConnection();
            executeQuery(connection);
        } catch (SQLException e) {
            logger.severe("Database error: " + e.getMessage());
        } finally {
            // Always close resources
            if (connection != null) {
                try {
                    connection.close();
                } catch (SQLException e) {
                    logger.warning("Error closing connection: " + e.getMessage());
                }
            }
        }
        
        System.out.println("\n=== Program Completed ===");
    }
    
    // GOOD: Specific exception handling
    private static void readConfiguration(String filename) 
            throws IOException {
        // Business logic here
    }
    
    // BAD: Swallowing exception
    private static void badPracticeSwallowException() {
        try {
            riskyOperation();
        } catch (Exception e) {
            // BAD: Exception completely swallowed
            // No logging, no re-throw, no recovery
        }
    }
    
    // GOOD: Proper exception logging
    private static void goodPracticeLogException() {
        try {
            riskyOperation();
        } catch (Exception e) {
            // GOOD: Log the exception
            logger.log(Level.SEVERE, "Operation failed", e);
            
            // Either recover or re-throw
            throw new RuntimeException("Operation failed", e);
        }
    }
    
    // GOOD: Validate before processing (avoid exceptions)
    private static void validateInputBeforeProcessing(String input) {
        if (input == null || input.trim().isEmpty()) {
            // Return error instead of throwing exception
            System.out.println("Invalid input");
            return;
        }
        
        if (input.length() > 100) {
            System.out.println("Input too long");
            return;
        }
        
        // Process valid input
        System.out.println("Processing: " + input);
    }
    
    // GOOD: Preserve cause when wrapping exceptions
    private static void processData() throws ProcessingException {
        try {
            // Some operation that might fail
            parseComplexData();
        } catch (IOException | NumberFormatException e) {
            // Wrap with custom exception, preserving cause
            throw new ProcessingException("Failed to process data", e);
        }
    }
    
    // Helper methods (simulated)
    private static void riskyOperation() {
        throw new RuntimeException("Simulated failure");
    }
    
    private static void processLine(String line) {
        // Process line
    }
    
    private static Connection openDatabaseConnection() throws SQLException {
        return new Connection(); // Simulated
    }
    
    private static void executeQuery(Connection connection) throws SQLException {
        // Execute query
    }
    
    private static void parseComplexData() throws IOException {
        throw new IOException("Simulated parse error");
    }
}

// Custom exception for practice 5
class ProcessingException extends Exception {
    public ProcessingException(String message) {
        super(message);
    }
    
    public ProcessingException(String message, Throwable cause) {
        super(message, cause);
    }
}

// Simulated classes
class Connection implements AutoCloseable {
    public void close() throws SQLException {
        // Close connection
    }
}

class SQLException extends Exception {
    public SQLException(String message) {
        super(message);
    }
}