graph TD
    A[Java Errors] --> B[Compile-Time Errors]
    A --> C[Runtime Errors]
    A --> D[Logical Errors]
    B --> E[Detected before running<br/>Program won't compile]
    C --> F[Occur while running<br/>Program crashes]
    D --> G[Program runs but gives<br/>wrong results]

int x = 5  // Error: ';' expected

int x = 5;

System.out.println(myVar);  // Error: cannot find symbol

int myVar = 50;
System.out.println(myVar);

int x = "Hello";  // Error: incompatible types

String x = "Hello";

int x = 10;
int y = 0;
int result = x / y;  // ArithmeticException

Exception in thread "main" java.lang.ArithmeticException: / by zero

int[] numbers = {1, 2, 3};
System.out.println(numbers[10]);  // ArrayIndexOutOfBoundsException

Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 10

int x = 10;
int y = 2;
int result = x - y;  // You meant x + y
System.out.println(result);  // Prints 8 instead of 12

flowchart LR
    A[Code has bug] --> B[Add print statements]
    B --> C[Run program]
    C --> D[Check output]
    D --> E{Found problem?}
    E -->|No| B
    E -->|Yes| F[Fix bug]
    F --> G[Test again]

int x = 10;
int y = 0;
 
System.out.println("Before division");  // This prints
System.out.println("x = " + x);         // This prints
System.out.println("y = " + y);         // This prints
 
int result = x / y;  // Program crashes here
 
System.out.println("Result: " + result);  // Never runs

Before division
x = 10
y = 0
Exception in thread "main" java.lang.ArithmeticException: / by zero

flowchart TD
    A[Start] --> B[Execute try block]
    B --> C{Error occurs?}
    C -->|No| D[Skip catch block]
    C -->|Yes| E[Execute catch block]
    D --> F[Continue program]
    E --> F

try {
    // Code that might cause an error
} catch (Exception e) {
    // Code to handle the error
}

public class Main {
    public static void main(String[] args) {
        int[] myNumbers = {1, 2, 3};
        System.out.println(myNumbers[10]);  // Crash!
    }
}

Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 10

public class Main {
    public static void main(String[] args) {
        try {
            int[] myNumbers = {1, 2, 3};
            System.out.println(myNumbers[10]);
        } catch (Exception e) {
            System.out.println("Something went wrong.");
        }
    }
}

Something went wrong.

try {
    int[] myNumbers = {1, 2, 3};
    System.out.println(myNumbers[10]);
} catch (Exception e) {
    System.out.println("Something went wrong.");
} finally {
    System.out.println("The 'try catch' is finished.");
}

Something went wrong.
The 'try catch' is finished.

flowchart TD
    A[try block] --> B{Error?}
    B -->|Yes| C[catch block]
    B -->|No| D[Skip catch]
    C --> E[finally block]
    D --> E
    E --> F[Continue]

public class Main {
    static void checkAge(int age) {
        if (age < 18) {
            throw new ArithmeticException("Access denied - You must be at least 18 years old.");
        } else {
            System.out.println("Access granted - You are old enough!");
        }
    }
 
    public static void main(String[] args) {
        checkAge(15);  // Will throw exception
    }
}

Exception in thread "main" java.lang.ArithmeticException: Access denied - You must be at least 18 years old.

public class Main {
    static void checkAge(int age) {
        if (age < 18) {
            throw new ArithmeticException("Access denied - You must be at least 18 years old.");
        } else {
            System.out.println("Access granted - You are old enough!");
        }
    }
 
    public static void main(String[] args) {
        try {
            checkAge(15);
        } catch (Exception e) {
            System.out.println("Error: " + e.getMessage());
        }
    }
}

Error: Access denied - You must be at least 18 years old.

import java.io.FileOutputStream;
 
public class Main {
    public static void main(String[] args) {
        FileOutputStream fos = null;
        try {
            fos = new FileOutputStream("output.txt");
            fos.write("Hello".getBytes());
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (fos != null) fos.close();  // Manual closing
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}

try (ResourceType resource = new ResourceType()) {
    // Use the resource
}
// Resource is automatically closed here

import java.io.FileOutputStream;
 
public class Main {
    public static void main(String[] args) {
        try (FileOutputStream fos = new FileOutputStream("output.txt")) {
            fos.write("Hello".getBytes());
        } catch (Exception e) {
            e.printStackTrace();
        }
        // No need to close fos - Java does it automatically!
    }
}

import java.io.FileWriter;
import java.io.BufferedWriter;
 
public class Main {
    public static void main(String[] args) {
        try (FileWriter fw = new FileWriter("output.txt");
             BufferedWriter bw = new BufferedWriter(fw)) {
            bw.write("Hello World!");
        } catch (Exception e) {
            e.printStackTrace();
        }
        // Both resources are automatically closed in reverse order
    }
}

flowchart LR
    A[Open Resource 1] --> B[Open Resource 2]
    B --> C[Use Resources]
    C --> D[Close Resource 2]
    D --> E[Close Resource 1]

public class Main {
    public static void main(String[] args) {
        int age = 25
        String name
        System.out.println("Name: " + name);
        System.out.println("Age: " + age);
    }
}

public class Main {
    public static void main(String[] args) {
        int[] numbers = {10, 20, 30};
        int divisor = 0;
        
        int result = numbers[0] / divisor;
        System.out.println("Result: " + result);
    }
}

mindmap
  root((Java Exceptions<br/>& Debugging))
    Error Types
      Compile-Time
      Runtime
      Logical
    Debugging
      Print Statements
      IDE Debugger
      Check Variables
    Exception Handling
      try-catch
      finally
      throw
    Best Practices
      try-with-resources
      Specific Exceptions
      Meaningful Messages