Java Notes
HubArray IntroductionArray OperationsArray Programs — FundamentalsArray Interview QuestionsJagged Array in JavaMulti Dimensional ArrayOne Dimensional Arraybreak and continue in JavaDo-While Loop in JavaFor Loop in JavaIf-Else Statements in JavaNested Loops in JavaSwitch-Case in JavaWhile Loop in JavaJava Compilation ProcessFeatures of JavaYour First Java ProgramHistory of JavaJava EditionsJava Program StructureJDK, JRE, and JVMWhat is Java?Immutable Strings in JavaString Class in JavaString Interview QuestionsString MethodsString Programs — FundamentalsStringBuffer in JavaStringBuilder in JavaComments in JavaData Types in JavaIdentifiers in JavaInput and Output in JavaKeywords in JavaOperators in JavaType Casting in JavaVariables in JavaAbstract Class in JavaAbstraction in JavaAnonymous Class in JavaClass and Object in JavaConstructor in JavaEncapsulation in JavaInheritance in JavaInner Class in JavaInterface in JavaMethod Overloading in JavaMethod Overriding in JavaObject Class in JavaObject Cloning in JavaOOPs IntroductionPolymorphism in Javastatic Keyword in Javasuper Keyword in Javathis Keyword in JavaWrapper Class in JavaCollections Framework OverviewCollections Practice ProgramsComparable vs Comparator in JavaGenerics in JavaIterator in JavaArrayList in JavaLinkedList in JavaStack in Java — Collections FrameworkVector in JavaHashMap in JavaHashtable in JavaLinkedHashMap in JavaTreeMap in JavaArrayDeque in JavaDeque Interface in JavaPriorityQueue in JavaHashSet in JavaLinkedHashSet in JavaTreeSet in JavaException Handling Best PracticesCustom Exceptions in JavaException Hierarchy in JavaFinally Block in JavaException Handling Introductionthrow and throws Keywords in JavaTry-Catch Block in JavaBuffered Streams in JavaByte Streams in JavaCharacter Streams in JavaDeserialization in JavaFile Class in JavaJava NIO PackageSerialization in JavaDate and Time API in Java 8Default and Static Methods in InterfacesFunctional Interface in Java 8Lambda Expression in Java 8Method Reference in Java 8Optional Class in Java 8Stream API in Java 8Creating Threads in JavaDaemon Threads in JavaExecutor Framework in JavaInter-Thread Communication in JavaMultithreading Programs in JavaRunnable Interface in JavaSynchronization in JavaThread Class in JavaThread IntroductionThread Life Cycle in JavaThread Priority in JavaBatch Processing in JDBCCallableStatement in JDBCJDBC ArchitectureJDBC IntroductionJDBC ProjectsMySQL Connection with JDBCPreparedStatement in JDBCResultSet in JDBCStatement Interface in JDBCTransaction Management in JDBCCookies in ServletsExpression Language (EL)GenericServletHttpServletJSP IntroductionJSP Tags and JSTLMVC ArchitectureRequest and Response ObjectsServlet IntroductionServlet Life CycleSession TrackingDependency InjectionAPI GatewayConfig ServerDocker DeploymentEureka Server - Service DiscoverySpring BeansCRUD ApplicationException Handling in Spring BootJWT Authentication — Java ProgrammingREST API with Spring BootSpring SecuritySpring Boot IntroductionSpring Data JPAValidation in Spring BootSpring Core ContainerSpring Framework IntroductionDynamic Programming in JavaGraph Data Structure in JavaHashing in JavaHeap (DSA)Linked List in JavaQueue in JavaRecursion in JavaSearching Algorithms in JavaSorting Algorithms in JavaStack in Java — DSA in JavaTime ComplexityTree Data Structure in JavaAdapter Design PatternBuilder Design PatternFactory Design PatternMVC Pattern — Java ProgrammingObserver Design PatternSingleton Design PatternArray Programs — PracticeBasic Java ProgramsCollection ProgramsJDBC ProgramsMultithreading ProgramsOOP ProgramsPlacement Coding QuestionsString Programs — PracticeBanking System — Java ProgrammingChat ApplicationE-Commerce BackendEmployee Management SystemLibrary Management System — Java ProgrammingSpring Boot Fullstack ProjectStudent Management System — Java ProgrammingCoding Interview QuestionsCollections Interview QuestionsCore Java Interview QuestionsJDBC Interview QuestionsMultithreading Interview QuestionsOOPs Interview QuestionsSpring Framework Interview QuestionsJava Cheat SheetImportant Formulas & ConceptsImportant Java ProgramsQuick Revision Notes — Java ProgrammingJava Master Course - Learning Roadmap
Complete guide to try-catch blocks in Java covering syntax, multiple catch blocks, nested try, multi-catch (Java 7+), exception propagation, and practical examples with output.
What is a Try-Catch Block?
The try-catch block is the fundamental mechanism for handling exceptions in Java. Code that might throw an exception is placed inside the try block, and the code to handle the exception is placed inside the catch block.
Basic Syntax
java example
try {
// Code that may throw an exception
// (risky/suspicious code)
} catch (ExceptionType variableName) {
// Code to handle the exception
// (recovery/error reporting code)
}How It Works — Step by Step
┌─────────────────────────────────────────┐
│ TRY BLOCK │
│ │
│ Statement 1 ✓ (executes) │
│ Statement 2 ✓ (executes) │
│ Statement 3 ✗ (EXCEPTION occurs!) │
│ Statement 4 ✗ (SKIPPED) │
│ Statement 5 ✗ (SKIPPED) │
└─────────────────┬───────────────────────┘
│ Exception thrown
▼
┌─────────────────────────────────────────┐
│ CATCH BLOCK │
│ │
│ Handle the exception │
│ Log error / show message │
│ Recovery actions │
└─────────────────┬───────────────────────┘
│
▼
┌─────────────────────────────────────────┐
│ REST OF THE PROGRAM │
│ (continues normally) │
└─────────────────────────────────────────┘
Basic Try-Catch Example
java example
public class BasicTryCatch {
public static void main(String[] args) {
System.out.println("=== Program Start ===");
try {
System.out.println("Inside try: before exception");
int result = 100 / 0; // ArithmeticException
System.out.println("Inside try: after exception (NEVER prints)");
} catch (ArithmeticException e) {
System.out.println("Inside catch: " + e.getMessage());
}
System.out.println("=== Program continues normally ===");
}
}Output:
Example
=== Program Start ===
Inside try: before exception
Inside catch: / by zero
=== Program continues normally ===
Key Insight: When an exception occurs in the try block, the remaining statements in the try block are SKIPPED, and control immediately transfers to the matching catch block.
Multiple Catch Blocks
You can have multiple catch blocks to handle different types of exceptions differently:
Example
public class MultipleCatch {
public static void main(String[] args) {
int[] numbers = {10, 20, 30};
try {
// Experiment: change index to test different exceptions
System.out.println("Accessing element...");
int value = numbers[5]; // ArrayIndexOutOfBoundsException
System.out.println("Dividing...");
int result = value / 0; // ArithmeticException
String str = null;
System.out.println(str.length()); // NullPointerException
} catch (ArrayIndexOutOfBoundsException e) {
System.out.println("Array Error: Index " + e.getMessage() + " is invalid");
System.out.println("Valid indices: 0 to " + (numbers.length - 1));
} catch (ArithmeticException e) {
System.out.println("Math Error: " + e.getMessage());
} catch (NullPointerException e) {
System.out.println("Null Error: Tried to use a null reference");
} catch (Exception e) {
// Generic catch-all (must be LAST)
System.out.println("Unexpected Error: " + e.getMessage());
}
System.out.println("Program continues...");
}
}
Output:
Example
Accessing element...
Array Error: Index 5 out of bounds for length 3
Valid indices: 0 to 2
Program continues...
Rule: Order Matters — Specific to General
java example
// ❌ COMPILE ERROR: Unreachable catch block
try {
// code
} catch (Exception e) { // Parent class first
// This catches everything
} catch (IOException e) { // ERROR! Already caught above
// Unreachable
}
// ✅ CORRECT: Child exceptions first, parent last
try {
// code
} catch (FileNotFoundException e) { // Most specific first
System.out.println("File not found");
} catch (IOException e) { // Parent of FileNotFoundException
System.out.println("IO error");
} catch (Exception e) { // Most general LAST
System.out.println("Something went wrong");
}Multi-Catch Block (Java 7+)
Java 7 introduced the ability to catch multiple exception types in a single catch block using the pipe (|) operator:
java example
import java.io.IOException;
import java.sql.SQLException;
public class MultiCatchExample {
public static void main(String[] args) {
try {
// Simulating different exceptions
String input = "abc";
int number = Integer.parseInt(input);
} catch (NumberFormatException | ArithmeticException |
ArrayIndexOutOfBoundsException e) {
// Single handler for multiple exception types
System.out.println("Error type: " + e.getClass().getSimpleName());
System.out.println("Message: " + e.getMessage());
}
}
}Output:
Example
Error type: NumberFormatException
Message: For input string: "abc"
Multi-Catch Rules:
- Exception types must NOT be related (no parent-child)
- The catch parameter is implicitly
final(cannot reassigne) - Use
|(pipe) to separate exception types
java example
// ❌ WRONG: IOException is parent of FileNotFoundException
catch (IOException | FileNotFoundException e) { } // Compile error
// ✅ CORRECT: Unrelated exception types
catch (IOException | NumberFormatException e) { }
// ❌ WRONG: Cannot reassign in multi-catch
catch (IOException | SQLException e) {
e = new IOException(); // Compile error - e is final
}Nested Try-Catch Blocks
You can nest try-catch blocks when different parts of your code require different exception handling:
Example
public class NestedTryCatch {
public static void main(String[] args) {
try {
System.out.println("Outer try: start");
try {
System.out.println(" Inner try: start");
int[] arr = new int[3];
arr[5] = 100; // ArrayIndexOutOfBoundsException
System.out.println(" Inner try: end (won't print)");
} catch (ArrayIndexOutOfBoundsException e) {
System.out.println(" Inner catch: " + e.getMessage());
}
System.out.println("Outer try: after inner try-catch");
int result = 10 / 0; // ArithmeticException
System.out.println("Outer try: end (won't print)");
} catch (ArithmeticException e) {
System.out.println("Outer catch: " + e.getMessage());
}
System.out.println("Program ends normally");
}
}
Output:
| Outer try | start |
| Inner try | start |
| Inner catch | Index 5 out of bounds for length 3 |
| Outer try | after inner try-catch |
| Outer catch | / by zero |
When Inner Catch Doesn't Handle the Exception
If the inner catch block doesn't match the exception type, it propagates to the outer catch:
java example
public class ExceptionPropagation {
public static void main(String[] args) {
try {
System.out.println("Outer try");
try {
System.out.println(" Inner try");
int result = 10 / 0; // ArithmeticException
} catch (NullPointerException e) {
// This won't catch ArithmeticException
System.out.println(" Inner catch: " + e);
}
System.out.println("Outer try: after inner (won't print)");
} catch (ArithmeticException e) {
System.out.println("Outer catch handles it: " + e.getMessage());
}
}
}Output:
Example
Outer try
Inner try
Outer catch handles it: / by zero
The Catch Block — What You Can Do With the Exception Object
The exception object (e) provides useful methods:
java example
public class ExceptionMethods {
public static void main(String[] args) {
try {
methodA();
} catch (ArithmeticException e) {
// 1. Get the error message
System.out.println("getMessage(): " + e.getMessage());
// 2. Get exception class and message
System.out.println("toString(): " + e.toString());
// 3. Print full stack trace
System.out.println("\nprintStackTrace():");
e.printStackTrace();
// 4. Get stack trace as array
System.out.println("\nStack trace elements:");
StackTraceElement[] trace = e.getStackTrace();
for (StackTraceElement element : trace) {
System.out.println(" Class: " + element.getClassName()
+ " | Method: " + element.getMethodName()
+ " | Line: " + element.getLineNumber());
}
}
}
static void methodA() {
methodB();
}
static void methodB() {
int result = 10 / 0;
}
}Output:
| getMessage() | / by zero |
| toString() | java.lang.ArithmeticException: / by zero |
| java.lang.ArithmeticException | / by zero |
| at ExceptionMethods.methodB(ExceptionMethods.java | 33) |
| at ExceptionMethods.methodA(ExceptionMethods.java | 29) |
| at ExceptionMethods.main(ExceptionMethods.java | 5) |
| Class | ExceptionMethods | Method: methodB | Line: 33 |
| Class | ExceptionMethods | Method: methodA | Line: 29 |
| Class | ExceptionMethods | Method: main | Line: 5 |
Real-World Example: User Input Validation
Example
import java.util.Scanner;
public class InputValidation {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int age = 0;
boolean valid = false;
while (!valid) {
try {
System.out.print("Enter your age: ");
String input = scanner.nextLine().trim();
age = Integer.parseInt(input);
if (age < 0 || age > 150) {
throw new IllegalArgumentException(
"Age must be between 0 and 150");
}
valid = true; // Reached here = no exception
} catch (NumberFormatException e) {
System.out.println("Error: Please enter a valid number!");
} catch (IllegalArgumentException e) {
System.out.println("Error: " + e.getMessage());
}
}
System.out.println("Your age: " + age);
if (age >= 18) {
System.out.println("You are eligible to vote.");
} else {
System.out.println("You are not yet eligible to vote.");
}
scanner.close();
}
}
Output
Enter your age: abc Error: Please enter a valid number! Enter your age: 25 You are 25 years old. Eligible to vote: Yes
Sample Run:
| Enter your age | abc |
| Error | Please enter a valid number! |
| Enter your age | -5 |
| Error | Age must be between 0 and 150 |
| Enter your age | 25 |
| Your age | 25 |
Real-World Example: Array Processing
Example
public class SafeArrayAccess {
public static void main(String[] args) {
int[] data = {10, 20, 30, 40, 50};
int[] indices = {0, 2, 4, 7, -1, 3};
System.out.println("Safely accessing array elements:");
System.out.println("Array: [10, 20, 30, 40, 50]");
System.out.println("─────────────────────────────────");
int sum = 0;
int validCount = 0;
for (int index : indices) {
try {
int value = data[index];
sum += value;
validCount++;
System.out.printf("Index %2d → Value: %d ✓%n", index, value);
} catch (ArrayIndexOutOfBoundsException e) {
System.out.printf("Index %2d → INVALID (skipped) ✗%n", index);
}
}
System.out.println("─────────────────────────────────");
System.out.println("Valid accesses: " + validCount + "/" + indices.length);
System.out.println("Sum of valid values: " + sum);
}
}
Output:
| Array | [10, 20, 30, 40, 50] |
| Index 0 | Value: 10 ✓ |
| Index 2 | Value: 30 ✓ |
| Index 4 | Value: 50 ✓ |
| Index 7 | INVALID (skipped) ✗ |
| Index -1 | INVALID (skipped) ✗ |
| Index 3 | Value: 40 ✓ |
| Valid accesses | 4/6 |
| Sum of valid values | 130 |
Try Without Catch (Try-Finally)
You can have a try block without a catch block, but it MUST have a finally block:
java example
public class TryFinally {
public static void main(String[] args) {
try {
System.out.println("In try block");
// If exception occurs here, it propagates up
// but finally still executes
} finally {
System.out.println("Finally always runs");
}
// Note: No catch block! Exception (if any) propagates to caller
}
}Output
In try block Finally always runs Note: Exception propagates to caller!
Common Mistakes with Try-Catch
1. Catching Exception Too Broadly
Example
// ❌ BAD: Hides all possible errors
try {
String str = null;
str.length(); // NullPointerException
int[] arr = new int[3];
arr[10] = 5; // ArrayIndexOutOfBoundsException
int result = 10 / 0; // ArithmeticException
} catch (Exception e) {
System.out.println("Error"); // Which error? We don't know!
}
// ✅ GOOD: Handle each exception type appropriately
try {
// same code
} catch (NullPointerException e) {
System.out.println("Null reference detected");
} catch (ArrayIndexOutOfBoundsException e) {
System.out.println("Invalid array index: " + e.getMessage());
} catch (ArithmeticException e) {
System.out.println("Math error: " + e.getMessage());
}
2. Try Block Too Large
java example
// ❌ BAD: Entire method in one try block
try {
connectToDatabase();
readUserInput();
processData();
writeResults();
sendEmail();
} catch (Exception e) {
System.out.println("Something went wrong somewhere...");
}
// ✅ GOOD: Separate concerns
try {
connectToDatabase();
} catch (SQLException e) {
System.out.println("Database connection failed");
return;
}
try {
processData();
writeResults();
} catch (IOException e) {
System.out.println("File operation failed: " + e.getMessage());
}3. Unreachable Code After Try-Catch
java example
public class UnreachableCode {
public static void main(String[] args) {
try {
System.out.println("Try block");
return; // Method returns here
} catch (Exception e) {
System.out.println("Catch block");
return; // OR returns here
}
// ❌ COMPILE ERROR: Unreachable statement
// System.out.println("After try-catch");
}
}Output
Try block Catch block Finally block Program continues
Performance Considerations
Example
public class PerformanceTest {
public static void main(String[] args) {
int iterations = 1_000_000;
// Method 1: Using try-catch
long start = System.nanoTime();
int count1 = 0;
for (int i = 0; i < iterations; i++) {
try {
Integer.parseInt("123");
count1++;
} catch (NumberFormatException e) {
// ignore
}
}
long tryCatchTime = System.nanoTime() - start;
// Method 2: Pre-validation (no exception thrown)
start = System.nanoTime();
int count2 = 0;
for (int i = 0; i < iterations; i++) {
String s = "123";
if (s.matches("\\d+")) {
Integer.parseInt(s);
count2++;
}
}
long validationTime = System.nanoTime() - start;
System.out.printf("Try-catch (no exception): %d ms%n", tryCatchTime / 1_000_000);
System.out.printf("Pre-validation: %d ms%n", validationTime / 1_000_000);
System.out.println("\nNote: Try-catch with NO exception thrown has minimal overhead.");
System.out.println("The EXPENSIVE part is when exceptions are actually thrown.");
}
}
Output (approximate):
| Try-catch (no exception) | 15 ms |
| Pre-validation | 850 ms |
| Note | Try-catch with NO exception thrown has minimal overhead. |
Key Takeaway: The try block itself has negligible overhead. The cost comes from actually *throwing and catching* exceptions (creating stack traces, unwinding the stack). So don't use exceptions for normal flow control.
Interview Questions
Q1: Can we have a try block without a catch block?
Answer: Yes, but it must be followed by a finally block. A try block alone without both catch and finally will cause a compilation error.
Q2: What happens if an exception occurs in the catch block?
Answer: It propagates normally like any other exception. If there's an outer try-catch that matches, it gets caught there. Otherwise, the default exception handler terminates the program.
Q3: Can we have multiple catch blocks for a single try?
Answer: Yes. You can have any number of catch blocks. They are evaluated top-to-bottom, and the first matching one executes. Child exception types must appear before parent types.
Q4: What is the difference between multi-catch (|) and multiple catch blocks?
Answer: Multi-catch (Java 7+) handles different exception types with the same code: catch (IOException | SQLException e). Multiple separate catch blocks let you handle each type differently. In multi-catch, the parameter is implicitly final and exception types must not be related by inheritance.
Q5: Is there a performance penalty for using try-catch?
Answer: Entering a try block has negligible overhead. The expensive part is when an exception is actually thrown — creating the exception object, capturing the stack trace, and unwinding the call stack. That's why exceptions should not be used for normal program flow.
Q6: What is unreachable catch block error?
Answer: If you catch a parent exception before a child exception, the child catch becomes unreachable because the parent already catches it. The compiler detects this and throws an error.
Q7: What is the difference between throw and catch?
A: throw is used to explicitly create and throw an exception object: throw new IllegalArgumentException("msg"). catch is used to handle (receive) an exception that was thrown. Throw generates the exception; catch handles it. They work together — one method throws, another (or the same) catches.
Q8: Can a try block have zero catch blocks?
A: Yes, if it has a finally block: try { ... } finally { ... }. This pattern is used when you want to guarantee cleanup code runs regardless of exceptions, without actually handling the exception (it propagates to the caller).
Q9: What is exception chaining?
A: Wrapping a caught exception as the cause of a new exception: throw new ServiceException("Failed", originalException). The original exception is preserved via getCause(). This maintains the root cause information while converting low-level exceptions to application-level exceptions.
Q10: How do you handle multiple exception types with the same code?
A: Use multi-catch (Java 7+): catch (IOException | SQLException e) { ... }. The exception variable is implicitly final. Exception types must NOT be related by inheritance (parent catches child anyway). This reduces code duplication when handling is identical.
Exam Focus
Revise definitions, diagrams, examples, and short-answer points for Try-Catch Block in Java.
Interview Use
Prepare one clear explanation, one practical example, and one common mistake for this Java Master Course topic.
Search Terms
java-master-course, java master course, java, master, course, exception, handling, try
Related Java Master Course Topics
Continue learning this concept
Exception HandlingException Handling Best PracticesComplete guide to exception handling best practices in Java — anti-patterns to avoid, proper exception design, logging strategies, retry patterns, and production-grade error handling techniques.Exception HandlingCustom Exceptions in JavaComplete guide to creating custom exceptions in Java — when to create them, checked vs unchecked custom exceptions, best practices, exception chaining, and real-world patterns for enterprise applications.Exception HandlingException Hierarchy in JavaComplete guide to JavaException HandlingFinally Block in JavaComplete guide to the finally block in Java — guaranteed execution, resource cleanup, try-catch-finally flow, try-with-resources (Java 7+), and edge cases where finally may not execute.Exception HandlingException Handling IntroductionComplete guide to Exception Handling in Java covering what exceptions are, why they occur, the exception handling mechanism, types of errors, and how JavaException Handlingthrow and throws Keywords in JavaComplete guide to throw and throws keywords in Java — how to manually throw exceptions, declare checked exceptions, method signatures, exception propagation, and real-world patterns.