Exception Handling & Diagnostic Resilience Architecture

import java.io.*;

public class TryWithResourcesDemo {
    public static void main(String[] args) {
        // Try-With-Resources (Java 7+): Any AutoCloseable resource declared in parentheses
        // is GUARANTEED to be closed automatically in reverse order, even if exceptions occur!
        try (BufferedReader reader = new BufferedReader(new FileReader("orders.txt"))) {
            String line = reader.readLine();
            System.out.println("Read: " + line);
        } catch (FileNotFoundException e) {
            System.err.println("Orders file missing: " + e.getMessage());
        } catch (IOException e) {
            System.err.println("I/O error during read: " + e.getMessage());
        }
        // No finally block needed! No manual reader.close() calls! No leak potential!
    }
}

public class StringBuilderPerformanceDemo {
    public static void main(String[] args) {
        // Anti-pattern: String concatenation inside loops creates 5000 garbage objects on Heap!
        long start = System.currentTimeMillis();
        String str = "";
        for (int i = 0; i < 5000; i++) {
            str += i; // SLOW: Mints 5000 separate String objects!
        }
        long stringTime = System.currentTimeMillis() - start;

        // Best Practice: StringBuilder mutates an internal dynamic array in-place!
        start = System.currentTimeMillis();
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < 5000; i++) {
            sb.append(i); // FAST: In-place buffer expansion, 0 garbage objects!
        }
        long sbTime = System.currentTimeMillis() - start;

        System.out.println("String loop time: " + stringTime + "ms | StringBuilder time: " + sbTime + "ms");
    }
}

public class TextBlocksDemo {
    public static void main(String[] args) {
        // Java 15+ Text Blocks: Clean multiline strings without messy \\n or \\" escaping
        String jsonPayload = """
            {
                "employeeId": 101,
                "role": "SENIOR_BACKEND_ENGINEER",
                "department": "ARCHITECTURE"
            }
            """;

        System.out.println(jsonPayload);
    }
}

import java.io.*;
import java.sql.SQLException;

public class ExceptionHandlingCompleteDemo {

    static class OrderProcessingException extends Exception {
        public OrderProcessingException(String message, Throwable cause) {
            super(message, cause); // Exception Chaining preserves original stack trace!
        }
    }

    public static void processOrder(String file) throws OrderProcessingException {
        try {
            if (file == null) throw new FileNotFoundException("File path is null");
            if (file.equals("db_error")) throw new SQLException("Connection timed out");
        } catch (FileNotFoundException | SQLException e) {
            // Multi-catch (Java 7+): catches related exceptions using pipe '|' operator
            // Wrap and rethrow as high-level domain exception while preserving cause:
            throw new OrderProcessingException("Failed to process order file: " + file, e);
        }
    }

    public static void main(String[] args) {
        try {
            processOrder("db_error");
        } catch (OrderProcessingException e) {
            System.err.println("Caught Domain Error: " + e.getMessage());
            System.err.println("Root Cause: " + e.getCause());
        }
    }
}

package com.accenture.ltt.exceptions.customexceptions.solutions;

// 1. Custom Checked Exception: Extends java.lang.Exception
public class InvalidCredentialsException extends Exception {
    private static final long serialVersionUID = 1L;

    public InvalidCredentialsException() { super(); }
    public InvalidCredentialsException(String message) { super(message); }
}

// 2. Service Class throwing Custom Exception
class User {
    String username;
    String password;

    public void validate() throws InvalidCredentialsException {
        if ("admin".equals(username) && "pass@123".equals(password)) {
            System.out.println("Authentication successful!");
        } else {
            // Throw custom exception enforcing business rules
            throw new InvalidCredentialsException("Username or password is invalid.");
        }
    }
}

package com.accenture.ltt.exceptions.runtime;

import java.util.InputMismatchException;
import java.util.Scanner;

public class FinallyClause {
    public static void division() {
        Scanner sc = new Scanner(System.in);
        try {
            System.out.println("Enter a and b: ");
            int a = sc.nextInt();
            int b = sc.nextInt();
            int c = a / b;
            System.out.println("Result: " + c);
        } catch (InputMismatchException | ArithmeticException e) {
            System.err.println("Handled exception: " + e.getClass().getSimpleName());
        } finally {
            // GUARANTEED to execute: Even if exceptions occur or return is executed!
            System.out.println("finally block executed: Cleaning up resources...");
            sc.close();
        }
    }
}