🔷 Exception

An exception is an unexpected event that occurs during the execution of a program, which disrupts the normal flow of instructions.

Exceptions are objects that represent errors.

📊 Java Exception Hierarchy


java.lang.Object
 └── java.lang.Throwable
     ├── java.lang.Error (Serious problems)
     └── java.lang.Exception (Recoverable problems)
         ├── Checked Exceptions
         └── Unchecked Exceptions (RuntimeException and its subclasses)

🔷 1. Checked Exceptions (Compile-time)

These must be handled using try-catch or declared with throws

✅ Examples :

  • IOException
  • SQLException
  • FileNotFoundException
  • ClassNotFoundException

📝 Examples :

					 
import java.io.*;
public class FileRead {
    public static void main(String[] args) throws IOException {
        FileReader fr = new FileReader("test.txt"); // must handle or declare
        int i;
        while ((i = fr.read()) != -1)
            System.out.print((char) i);
        fr.close();
    }
}

🔷 2. Unchecked Exceptions (Runtime)

These don't need to be handled explicitly They are subclasses of RuntimeException.

✅ Examples :

  • NullPointerException
  • ArrayIndexOutOfBoundsException
  • ArithmeticException
  • IllegalArgumentException

📝 Examples :

					
public class Divide {
    public static void main(String[] args) {
        int a = 10 / 0; // ArithmeticException
    }
}

🔷 3. Errors (System-related)

These are not meant to be handled by the program — usually related to the environment

✅ Examples :

  • StackOverflowError
  • OutOfMemoryError
  • VirtualMachineError

🎯 Exception Handling Keywords

🔧 Keywords:
Keyword Description
try Wrap code that might throw an exception
catch Handle the exception
finally Block that runs regardless of exception
throw Manually throw an exception
throws Declare exceptions a method can throw

📝 Example: try-catch-finally

					
public class TryCatchExample {
    public static void main(String[] args) {
        try {
            int result = 10 / 0;
        } catch (ArithmeticException e) {
            System.out.println("Error: Division by zero.");
        } finally {
            System.out.println("This block always runs.");
        }
    }
}

🎯 Creating Custom Exceptions

You can create your own exception by extending Exception or RuntimeException

📝 Example:

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

public class Custom {
    public static void main(String[] args) throws MyException {
        throw new MyException("This is a custom exception!");
    }
}

📌 Common Exception Types

Exception Type When it Occurs
NullPointerException Unchecked Accessing object with null reference
ArrayIndexOutOfBounds Unchecked Invalid array index
NumberFormatException Unchecked Invalid conversion of String to number
IOException Checked Input/output failure
ClassNotFoundException Checked Class not found at runtime
FileNotFoundException Checked File does not exist
ArithmeticException Unchecked Divide by zero

📝 Best Practices

  • Catch specific exceptions.
  • Use finally to close resources (or use try-with-resources).
  • Don’t catch Exception or Throwable blindly.
  • Use custom exceptions for meaningful error reporting.

✅ Checked vs. Unchecked Exceptions in Java

Feature Checked Exception Unchecked Exception
Inheritance Subclass of Exception (but not RuntimeException) Subclass of RuntimeException
Compile-time Checking ✅ Checked at compile-time ❌ Not Checked at compile-time
Must Handle or Declare ✅ Yes — must be handled with try-catch or throws ❌ No — optional to handle
Common Examples IOException, SQLException,FileNotFoundException NullPointerException, ArithmeticException, ArrayIndexOutOfBoundsException
Use Case External factors (e.g., file, network, DB Programming errors (e.g., null reference)
When to Use When the program can recover from the exception When the program cannot recover or it's a bug

📝 Code Examples

🔷 Checked Exception — must be handled

					
import java.io.*;
public class CheckedExample {
 public static void main(String[] args) {
 try {
 FileReader fr = new FileReader("file.txt"); // 
FileNotFoundException (checked)
} catch (FileNotFoundException e) {
 System.out.println("File not found!");
 }
 }

If you don’t handle or declare this exception, the compiler will throw an error.

🔷 Unchecked Exception — optional to handle

					
public class UncheckedExample {
 public static void main(String[] args) {
 int[] numbers = {1, 2, 3};
 System.out.println(numbers[5]); // 
ArrayIndexOutOfBoundsException (unchecked)
 }
}

This compiles fine , but crashes at runtime.

✅ Difference Between throw vs throws

Feature throw throws
Purpose Used to actually throw an exception Used to declare an exception might be thrown
Position Used Inside a method Used in the method signature
Followed By An exception object One or more exception classes
Number Can only throw one exception at a time an declare multiple exceptions (commaseparated)
Checked/ Unchecked Works for both types Required only for checked exceptions

🔷 throw - Actually throws the exception

📝 Syntax :

throw new ExceptionType("error message");

✅ Example :

					
public class ThrowExample {
    public static void main(String[] args) {
        throw new ArithmeticException("Can't divide by zero");
    }
}

Here, the program immediately stops when the exception is thrown.

🔷 throws - Declares the possibility of an exception

📝 Syntax :

returnType methodName() throws ExceptionType1, ExceptionType2

✅ Example :

					
public void readFile() throws IOException {
 FileReader file = new FileReader("test.txt"); // Might 
throw IOException
}

This tells the compiler and caller that readFile() might throw IOException , so it must be handled there.

🔄 Summary:

Keyword Used to... Followed by... Used where?
throw Actually throw Object of exception class Inside method/block
throws Declare an exception Exception class name(s) Method signature