When you’re writing code in Java, things don’t always go as planned. Maybe the user enters invalid input, a file you’re trying to read doesn’t exist, or your program tries to divide by zero. These kinds of unexpected events are called exceptions, and if you don’t handle them properly, your application could crash.

That’s where Java Exception Handling comes in — a powerful mechanism that helps you gracefully deal with runtime errors and keep your code running smoothly. In this guide, we’ll break down everything you need to know about exception handling in Java — from the basics to advanced techniques — all explained with easy-to-understand examples.

Whether you’re a beginner or just brushing up, this complete guide will help you write more reliable and robust Java programs.

Exception Handling in Java is a way to manage and respond to unexpected situations or errors that occur while a program is running. These errors — known as exceptions — can interrupt the normal flow of the program. Common examples include trying to access a file that doesn’t exist, dividing a number by zero, or using a null object.

Instead of letting the program crash, Java gives you a structured way to catch and handle these exceptions using a set of keywords like try, catch, throw, throws, and finally. This allows you to write cleaner, more secure, and error-resistant code.

In simple terms, exception handling ensures your program knows what to do when something goes wrong — like showing a user-friendly error message or retrying an operation — instead of just stopping abruptly.

Exception handling is crucial in Java programming because it helps make your applications more reliable, maintainable, and user-friendly. Here’s why it’s so important:

• Prevents Program Crashes: Without exception handling, a single unexpected error can crash the entire program. With proper handling, you can manage errors gracefully and keep your program running.
• Improves User Experience: Instead of showing confusing error messages or crashing, you can show meaningful messages to the user and guide them on what to do next.
• Encourages Clean Code Structure: Java’s exception handling uses a clear structure (try-catch-finally) that separates error-handling logic from normal logic, making the code easier to read and maintain.
• Helps with Debugging: Exceptions often come with detailed messages and stack traces that help developers identify the exact cause and location of the error.
• Essential for Robust Applications: In real-world applications (like banking systems, e-commerce apps, or medical software), failures can be costly. Exception handling ensures your app behaves predictably even when something goes wrong.

In Java, exceptions and errors are part of the Throwable class hierarchy. Throwable has two main branches: Exception and Error. Exceptions are further divided into checked and unchecked types. Let’s understand each in detail:

Checked exceptions are the ones that are checked at compile time. If a method can throw a checked exception, the compiler forces you to handle it using a try-catch block or declare it using the throws keyword. These exceptions usually occur due to external factors beyond the program’s control — like file access, database issues, or network failures.

• IOException: Occurs during input/output operations like reading a file.
• SQLException: Occurs when there’s a problem interacting with a database.
• FileNotFoundException: Thrown when a file cannot be found.

try {
    FileReader file = new FileReader("example.txt");
} catch (IOException e) {
    e.printStackTrace();
}

try {
    FileReader file = new FileReader("example.txt");
} catch (IOException e) {
    e.printStackTrace();
}

Unchecked exceptions are not checked at compile time, meaning the compiler doesn’t force you to handle them. They usually occur due to logical programming errors and are subclasses of RuntimeException.

• NullPointerException: When you try to use a null object.
• ArithmeticException: When an illegal arithmetic operation occurs, like dividing by zero.
• ArrayIndexOutOfBoundsException: When accessing an invalid array index.

int a = 5 / 0; // Throws ArithmeticException

int a = 5 / 0; // Throws ArithmeticException

Errors are serious issues that are not meant to be caught or handled by your code. They occur due to problems in the Java Virtual Machine (JVM), such as memory leaks or system crashes. Since they usually indicate serious problems, your application cannot recover from them.

• OutOfMemoryError: When JVM runs out of memory.
• StackOverflowError: When a method keeps calling itself recursively without a base condition.

Java’s exception handling is based on a well-structured class hierarchy, starting from the Throwable class. This hierarchy helps categorize different types of errors and exceptions, making it easier to manage them effectively.

At the top of the hierarchy is the Throwable class. It is the superclass for all errors and exceptions in Java. Only instances of this class or its subclasses can be thrown using the throw statement.

Throwable has two main direct subclasses:
1. Exception
2. Error

public class Throwable extends Object implements Serializable

public class Throwable extends Object implements Serializable

The Exception class represents events that a program might want to catch and handle. These are conditions that arise during the normal execution of a program.

• Most exceptions that you write in your code are derived from this class.
• It includes both checked and unchecked exceptions.

try {
   // risky code
} catch (Exception e) {
   // handle exception
}

try {
   // risky code
} catch (Exception e) {
   // handle exception
}

RuntimeException is a subclass of Exception, but it’s special because it represents unchecked exceptions. These exceptions are not checked at compile time and usually happen due to programming mistakes.

Examples include:

• NullPointerException
• ArithmeticException
• IndexOutOfBoundsException

Because they’re so common and indicate bugs, Java doesn’t force you to catch them.

String name = null;
System.out.println(name.length()); // NullPointerException

String name = null;
System.out.println(name.length()); // NullPointerException

Java provides a structured way to handle exceptions using specific keywords and blocks. These core components allow developers to catch errors, clean up resources, and even define their own custom exceptions. Let’s explore them one by one:

The try-catch block is the foundation of exception handling in Java. You place the risky code inside the try block, and if an exception occurs, it’s caught and handled in the corresponding catch block.

// Syntax
try {
    // code that may throw an exception
} catch (ExceptionType e) {
    // code to handle the exception
}

// Example
try {
    int a = 10 / 0;
} catch (ArithmeticException e) {
    System.out.println("Cannot divide by zero.");
}

// Syntax
try {
    // code that may throw an exception
} catch (ExceptionType e) {
    // code to handle the exception
}

// Example
try {
    int a = 10 / 0;
} catch (ArithmeticException e) {
    System.out.println("Cannot divide by zero.");
}

The finally block is optional but very useful. It contains code that always executes after the try and catch blocks — whether an exception was thrown or not. It’s commonly used to release resources like closing files, database connections, etc.

// Syntax
try {
    // risky code
} catch (Exception e) {
    // handle exception
} finally {
    // always executed
}

// Example
java
Copy code
try {
    int data = 5 / 0;
} catch (ArithmeticException e) {
    System.out.println("Exception caught.");
} finally {
    System.out.println("This will always execute.");
}

// Syntax
try {
    // risky code
} catch (Exception e) {
    // handle exception
} finally {
    // always executed
}

// Example
java
Copy code
try {
    int data = 5 / 0;
} catch (ArithmeticException e) {
    System.out.println("Exception caught.");
} finally {
    System.out.println("This will always execute.");
}

The throw keyword is used to manually throw an exception. It’s often used when you want to signal an error condition intentionally.

// Syntax
throw new ExceptionType("Error Message");

//Example
public void checkAge(int age) {
    if (age < 18) {
        throw new ArithmeticException("You must be 18 or older.");
    }
}

// Syntax
throw new ExceptionType("Error Message");

//Example
public void checkAge(int age) {
    if (age < 18) {
        throw new ArithmeticException("You must be 18 or older.");
    }
}

The throws keyword is used in method declarations to indicate that a method might throw one or more exceptions. It tells the compiler and caller to handle or declare the exception.

// Syntax
public void methodName() throws IOException, SQLException {
    // code that may throw checked exceptions
}

// Example
public void readFile() throws FileNotFoundException {
    FileReader file = new FileReader("test.txt");
}

// Syntax
public void methodName() throws IOException, SQLException {
    // code that may throw checked exceptions
}

// Example
public void readFile() throws FileNotFoundException {
    FileReader file = new FileReader("test.txt");
}

Java allows you to create your own exception classes to handle specific business logic or application needs. Custom exceptions are useful when you want to represent specific error scenarios in your application.

Steps to create a custom exception:
1. Extend the Exception class (for checked) or RuntimeException (for unchecked).
2. Add a constructor with a custom message.

// Example
class InvalidInputException extends Exception {
    public InvalidInputException(String message) {
        super(message);
    }
}

public void validate(int number) throws InvalidInputException {
    if (number < 0) {
        throw new InvalidInputException("Negative numbers are not allowed.");
    }
}

// Example
class InvalidInputException extends Exception {
    public InvalidInputException(String message) {
        super(message);
    }
}

public void validate(int number) throws InvalidInputException {
    if (number < 0) {
        throw new InvalidInputException("Negative numbers are not allowed.");
    }
}

Writing exception handling code is not just about catching errors — it’s about handling them the right way. Here are some best practices every Java developer should follow to ensure clean, efficient, and professional error management:

Always catch specific exceptions before general ones. This ensures that each type of exception is handled appropriately and avoids accidentally catching unintended ones with a broad Exception block.

//Bad Practice:
catch (Exception e) {
    // too generic
}

//Good Practice:
catch (FileNotFoundException e) {
    // handle file not found
} catch (IOException e) {
    // handle other I/O errors
}

//Bad Practice:
catch (Exception e) {
    // too generic
}

//Good Practice:
catch (FileNotFoundException e) {
    // handle file not found
} catch (IOException e) {
    // handle other I/O errors
}

An empty catch block silently ignores exceptions, which can make bugs hard to detect and debug. Always include meaningful actions, such as logging or corrective steps.

//Bad Example:
try {
    // risky code
} catch (Exception e) {
    // do nothing ❌
}

//Good Example:
catch (Exception e) {
    e.printStackTrace(); // or log the error
}

//Bad Example:
try {
    // risky code
} catch (Exception e) {
    // do nothing ❌
}

//Good Example:
catch (Exception e) {
    e.printStackTrace(); // or log the error
}

Use the finally block (or try-with-resources) to release resources like files, streams, or database connections. This ensures that cleanup happens even if an exception occurs.

FileReader reader = null;
try {
    reader = new FileReader("file.txt");
    // read file
} catch (IOException e) {
    e.printStackTrace();
} finally {
    if (reader != null) {
        reader.close(); // cleanup
    }
}

//Or use try-with-resources (Java 7+):
try (FileReader reader = new FileReader("file.txt")) {
    // automatic close
}

FileReader reader = null;
try {
    reader = new FileReader("file.txt");
    // read file
} catch (IOException e) {
    e.printStackTrace();
} finally {
    if (reader != null) {
        reader.close(); // cleanup
    }
}

//Or use try-with-resources (Java 7+):
try (FileReader reader = new FileReader("file.txt")) {
    // automatic close
}

Even if an exception doesn’t seem critical, never ignore it completely. Log it, notify the user, or at least acknowledge it. Silent failures can lead to major issues later.

Tip: Ignoring exceptions breaks transparency and makes debugging very difficult in production systems.

Logging exceptions helps you keep a record of errors, especially in large or production-level applications. Use a proper logging framework (like Log4j, SLF4J, or java.util.logging) instead of System.out.println.

catch (IOException e) {
    logger.error("File operation failed", e);
}

catch (IOException e) {
    logger.error("File operation failed", e);
}

Good logs help trace errors, monitor system behavior, and quickly resolve issues.

Even experienced developers can make mistakes when handling exceptions. These mistakes can lead to silent bugs, poor performance, or hard-to-maintain code. Below are some of the most common exception-handling pitfalls in Java and how to avoid them:

Swallowing an exception means catching it but not doing anything with it — no logging, no message, no action. This makes debugging very difficult and hides the actual problem.

//Bad Example:
try {
    // risky operation
} catch (Exception e) {
    // silently ignored ❌
}

//Fix:At minimum, log the exception or rethrow it.
catch (Exception e) {
    e.printStackTrace(); // or use a proper logger
}

//Bad Example:
try {
    // risky operation
} catch (Exception e) {
    // silently ignored ❌
}

//Fix:At minimum, log the exception or rethrow it.
catch (Exception e) {
    e.printStackTrace(); // or use a proper logger
}

Using too many checked exceptions in your code — especially in deeply nested method calls — can lead to cluttered and hard-to-read code. It forces callers to handle or declare exceptions unnecessarily.

Bad Practice:
Declaring throws Exception for every method, even when it’s not needed.

Better Approach:
1. Only use checked exceptions when the caller can recover or react.
2. Use unchecked exceptions for programming errors or logic issues.

Throwing a generic Exception or Throwable doesn’t provide specific context about what went wrong. It also forces the calling code to handle a very broad range of possible issues.

//Bad Example:
throw new Exception("Something went wrong"); 
//Fix: Throw a specific exception or create a custom exception that clearly describes the issue.

throw new InvalidUserInputException("User ID is missing");

//Bad Example:
throw new Exception("Something went wrong"); 
//Fix: Throw a specific exception or create a custom exception that clearly describes the issue.

throw new InvalidUserInputException("User ID is missing");

Failing to properly close resources like files, database connections, or streams can lead to memory leaks and resource exhaustion.

Common Mistake:
Forgetting to close a file or database connection in a try block.

Best Practice:
1. Use finally block or
2. Use try-with-resources (Java 7+), which automatically closes the resource.

try (BufferedReader reader = new BufferedReader(new FileReader("file.txt"))) {
    // safe reading
}

try (BufferedReader reader = new BufferedReader(new FileReader("file.txt"))) {
    // safe reading
}

Exception propagation is the process by which an exception moves up the call stack from the method where it occurred to the method that called it — until it’s caught by a matching catch block or causes the program to terminate.

When an exception is thrown in a method and not caught there, it gets passed (or propagated) to the method that called it. This continues until:

• The exception is caught using a try-catch block, or
• It reaches the main() method and crashes the program.

This mechanism allows you to centralize exception handling, especially in large applications.

Steps of Propagation:

1. Exception occurs in a method.
2. That method doesn’t handle it.
3. Java runtime passes the exception to the calling method.
4. If none of the methods in the call chain handle it, the program terminates with a stack trace.

• Reduces repetitive try-catch blocks in every method.
• Lets you handle exceptions in a centralized place.
• Keeps your business logic cleaner and more focused.

However, use propagation with care — if no one handles the exception, your program will crash.

To truly understand exception handling in Java, it’s important to see how it’s used in real applications. Below are common scenarios where exception handling plays a key role:

When working with files (reading/writing), issues like missing files or lack of permissions can cause exceptions. Java requires you to handle these checked exceptions like FileNotFoundException and IOException.

// Example:
import java.io.*;

public class FileExample {
    public static void main(String[] args) {
        try {
            FileReader reader = new FileReader("data.txt");
            int ch;
            while ((ch = reader.read()) != -1) {
                System.out.print((char) ch);
            }
            reader.close();
        } catch (FileNotFoundException e) {
            System.out.println("File not found: " + e.getMessage());
        } catch (IOException e) {
            System.out.println("Error reading file: " + e.getMessage());
        }
    }
}

// Example:
import java.io.*;

public class FileExample {
    public static void main(String[] args) {
        try {
            FileReader reader = new FileReader("data.txt");
            int ch;
            while ((ch = reader.read()) != -1) {
                System.out.print((char) ch);
            }
            reader.close();
        } catch (FileNotFoundException e) {
            System.out.println("File not found: " + e.getMessage());
        } catch (IOException e) {
            System.out.println("Error reading file: " + e.getMessage());
        }
    }
}

When interacting with databases using JDBC, many things can go wrong — connection failures, incorrect SQL syntax, or missing tables. These typically throw SQLException, a checked exception that must be handled.

// Example:
import java.sql.*;

public class DatabaseExample {
    public static void main(String[] args) {
        try {
            Connection con = DriverManager.getConnection("jdbc:mysql://localhost:3306/testdb", "root", "password");
            Statement stmt = con.createStatement();
            ResultSet rs = stmt.executeQuery("SELECT * FROM users");

            while (rs.next()) {
                System.out.println(rs.getString("username"));
            }

            con.close();
        } catch (SQLException e) {
            System.out.println("Database error: " + e.getMessage());
        }
    }
}

// Example:
import java.sql.*;

public class DatabaseExample {
    public static void main(String[] args) {
        try {
            Connection con = DriverManager.getConnection("jdbc:mysql://localhost:3306/testdb", "root", "password");
            Statement stmt = con.createStatement();
            ResultSet rs = stmt.executeQuery("SELECT * FROM users");

            while (rs.next()) {
                System.out.println(rs.getString("username"));
            }

            con.close();
        } catch (SQLException e) {
            System.out.println("Database error: " + e.getMessage());
        }
    }
}

Applications often accept user input — and users often make mistakes. For example, trying to parse a non-numeric value into an integer causes a NumberFormatException, an unchecked exception that should still be caught and handled gracefully.

// Example:
import java.util.Scanner;

public class InputExample {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        try {
            System.out.print("Enter your age: ");
            int age = Integer.parseInt(scanner.nextLine());
            System.out.println("Your age is: " + age);
        } catch (NumberFormatException e) {
            System.out.println("Invalid input! Please enter a number.");
        }
    }
}

// Example:
import java.util.Scanner;

public class InputExample {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        try {
            System.out.print("Enter your age: ");
            int age = Integer.parseInt(scanner.nextLine());
            System.out.println("Your age is: " + age);
        } catch (NumberFormatException e) {
            System.out.println("Invalid input! Please enter a number.");
        }
    }
}

In Java, both throw and throws are used to work with exceptions — but they serve different purposes and are used in different contexts. Let’s understand the difference clearly.

• Used to manually throw an exception inside a method or block.
• It creates and throws a specific exception object at runtime.

throw new ExceptionType("Error Message");

throw new ExceptionType("Error Message");

• Used in a method declaration to indicate that the method might throw one or more checked exceptions.
• It tells the caller of the method that they need to handle or declare the exception.

public void methodName() throws IOException, SQLException {
    // code that may throw exception
}

public void methodName() throws IOException, SQLException {
    // code that may throw exception
}

//Example Use Cases

//Using throw:
public void validateAge(int age) {
    if (age < 18) {
        throw new IllegalArgumentException("Age must be 18 or above.");
    }
}

//Using throws:
public void readFile(String fileName) throws IOException {
    FileReader reader = new FileReader(fileName);
    reader.close();
}

//You can also combine both:
public void process() throws IOException {
    throw new IOException("File not accessible");
}

//Example Use Cases

//Using throw:
public void validateAge(int age) {
    if (age < 18) {
        throw new IllegalArgumentException("Age must be 18 or above.");
    }
}

//Using throws:
public void readFile(String fileName) throws IOException {
    FileReader reader = new FileReader(fileName);
    reader.close();
}

//You can also combine both:
public void process() throws IOException {
    throw new IOException("File not accessible");
}

While Java provides a wide range of built-in exception classes, sometimes those aren’t enough to express your application’s specific error conditions. That’s where custom exceptions come in — giving you the flexibility to define meaningful and descriptive exceptions that align with your business logic.

You should create a custom exception when:

• Built-in exceptions don’t clearly represent your error scenario.
• You want to handle a specific business rule violation.
• You want to provide clearer, more readable code.
• You need to separate different types of application errors for better control and debugging.

• InsufficientBalanceException in a banking app.
• InvalidAgeException for form validation.
• UserNotFoundException in authentication systems.

Creating a custom exception is easy — just extend the Exception class (for checked) or RuntimeException (for unchecked), and define a constructor.

// Step-by-step Example (Checked Exception):

// Step 1: Define the custom exception
public class InvalidAgeException extends Exception {
    public InvalidAgeException(String message) {
        super(message);
    }
}

// Step 2: Use the custom exception in code
public class VoterRegistration {
    public void register(int age) throws InvalidAgeException {
        if (age < 18) {
            throw new InvalidAgeException("Age must be 18 or older to register.");
        } else {
            System.out.println("Registration successful.");
        }
    }

    public static void main(String[] args) {
        VoterRegistration vr = new VoterRegistration();
        try {
            vr.register(16);
        } catch (InvalidAgeException e) {
            System.out.println("Error: " + e.getMessage());
        }
    }
}
//Output:
//Error: Age must be 18 or older to register.

// Step-by-step Example (Checked Exception):

// Step 1: Define the custom exception
public class InvalidAgeException extends Exception {
    public InvalidAgeException(String message) {
        super(message);
    }
}

// Step 2: Use the custom exception in code
public class VoterRegistration {
    public void register(int age) throws InvalidAgeException {
        if (age < 18) {
            throw new InvalidAgeException("Age must be 18 or older to register.");
        } else {
            System.out.println("Registration successful.");
        }
    }

    public static void main(String[] args) {
        VoterRegistration vr = new VoterRegistration();
        try {
            vr.register(16);
        } catch (InvalidAgeException e) {
            System.out.println("Error: " + e.getMessage());
        }
    }
}
//Output:
//Error: Age must be 18 or older to register.

• Extend the right base class: use Exception for checked exceptions and RuntimeException for unchecked exceptions.
• Always include at least one constructor with a message in your custom exception.
• Optionally include a constructor that takes a cause (Throwable).
• Use meaningful class names, such as UserAlreadyExistsException.
• Avoid overusing custom exceptions; only create them when they add real value or clarity.
• Don’t replace standard exceptions like IllegalArgumentException unless absolutely necessary.
• Document your exceptions clearly, including when and why they are thrown.

Java 8 introduced powerful features like lambda expressions, streams, and functional interfaces that changed how developers write code. But handling exceptions in these modern, functional styles requires some new techniques. Let’s explore how exception handling works in Java 8 and beyond.

Functional interfaces like Function, Consumer, and Supplier don’t allow throwing checked exceptions inside lambda expressions directly. This can be frustrating when you’re working with streams or higher-order functions.

Problem Example:

List<String> files = Arrays.asList("a.txt", "b.txt");

files.stream().map(file -> new FileReader(file)) // ❌ Compilation error if FileNotFoundException is thrown
    .collect(Collectors.toList());

// Solution: Wrap the exception inside a custom method or convert it to a RuntimeException.

// Example:
files.stream()
     .map(file -> {
         try {
             return new FileReader(file);
         } catch (FileNotFoundException e) {
             throw new RuntimeException(e); // wrap checked exception
         }
     })
     .collect(Collectors.toList());

// You can also create custom functional interfaces that allow checked 

//exceptions:
@FunctionalInterface
public interface CheckedFunction<T, R> {
    R apply(T t) throws Exception;
}

Problem Example:

List<String> files = Arrays.asList("a.txt", "b.txt");

files.stream().map(file -> new FileReader(file)) // ❌ Compilation error if FileNotFoundException is thrown
    .collect(Collectors.toList());

// Solution: Wrap the exception inside a custom method or convert it to a RuntimeException.

// Example:
files.stream()
     .map(file -> {
         try {
             return new FileReader(file);
         } catch (FileNotFoundException e) {
             throw new RuntimeException(e); // wrap checked exception
         }
     })
     .collect(Collectors.toList());

// You can also create custom functional interfaces that allow checked 

//exceptions:
@FunctionalInterface
public interface CheckedFunction<T, R> {
    R apply(T t) throws Exception;
}

In Java 8+, the Optional class is a container object that may or may not contain a non-null value. It’s widely used to avoid NullPointerException and reduce the need for explicit null checks or exception throwing.

// Traditional Approach:
String name = getUserName(userId); // might return null
if (name != null) {
    System.out.println(name.toUpperCase());
} else {
    System.out.println("User not found.");
}

// With Optional:
Optional<String> name = getUserNameOptional(userId);

name.ifPresentOrElse(
    value -> System.out.println(value.toUpperCase()),
    () -> System.out.println("User not found.")
);

// Traditional Approach:
String name = getUserName(userId); // might return null
if (name != null) {
    System.out.println(name.toUpperCase());
} else {
    System.out.println("User not found.");
}

// With Optional:
Optional<String> name = getUserNameOptional(userId);

name.ifPresentOrElse(
    value -> System.out.println(value.toUpperCase()),
    () -> System.out.println("User not found.")
);

• Avoids null checks and NullPointerException.
• Encourages functional, clean code.
• Can chain transformations using map(), filter(), orElse(), etc.

// Example of a method returning Optional:
public Optional<String> getUserNameOptional(int userId) {
    if (userId == 1) {
        return Optional.of("Alice");
    } else {
        return Optional.empty();
    }
}

// Example of a method returning Optional:
public Optional<String> getUserNameOptional(int userId) {
    if (userId == 1) {
        return Optional.of("Alice");
    } else {
        return Optional.empty();
    }
}

Mastering exception handling is crucial not only for writing robust Java code but also for performing well in job interviews. Below are some commonly asked theoretical, code-based, and tricky conceptual questions that appear in Java interviews.

1. What is the difference between checked and unchecked exceptions?
   Checked exceptions are checked at compile time (e.g., IOException), while unchecked exceptions are checked at runtime (e.g., NullPointerException).
2. What is the difference between throw and throws?
   throw is used to actually throw an exception, while throws is used to declare exceptions that a method may throw.
3. What is the purpose of the finally block?
   It’s used for resource cleanup. It always executes, whether or not an exception is thrown.
4. Can a finally block override a return statement?
   Yes, if both try and finally have return statements, the one in finally will override the one in try.
5. Can we catch multiple exceptions in a single catch block?
   Yes, from Java 7 onwards using multi-catch.

• Can a catch block exist without a try block?
  No, catch cannot be used independently of try.
• What happens if an exception is thrown in the catch block?
  The control passes to the finally block (if it exists). If not handled, the new exception is thrown up the call stack.
• Can we rethrow a caught exception?
  Yes, you can rethrow the same or a different exception.
• Can constructors throw exceptions?
  Yes, constructors can declare and throw exceptions using the throws keyword.
• What is exception chaining?
  It’s the practice of catching one exception and throwing another, while preserving the original exception as the cause.