Best examples of try-catch block example in Java

Simple examples of try-catch block example in Java for beginners

Let’s start where most people first meet exceptions: dividing numbers and parsing user input. These are the best examples to see how try-catch actually behaves.

public class BasicTryCatchExample {
    public static void main(String[] args) {
        String input = "42";

        try {
            int number = Integer.parseInt(input);
            int result = 100 / number;
            System.out.println("Result: " + result);
        } catch (NumberFormatException e) {
            System.err.println("Invalid number: " + e.getMessage());
        } catch (ArithmeticException e) {
            System.err.println("Math error: " + e.getMessage());
        }

        System.out.println("Program continues after try-catch block.");
    }
}

This example of a try-catch block shows a few important habits:

Catching specific exception types (NumberFormatException, ArithmeticException)
Logging an error message without killing the JVM
Allowing the program to continue after the exception is handled

When people search for examples of try-catch block example in Java, this is usually what they expect first: a small code snippet that shows how exceptions are caught and how control flow continues.

File handling: real examples of try-catch block example in Java with resources

File I/O is one of the most common real examples where try-catch goes wrong. Developers forget to close streams, swallow exceptions, or log nothing. Modern Java gives you a better pattern: try-with-resources.

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

public class FileReadExample {
    public static void main(String[] args) {
        String path = "config/app.properties";

        try (BufferedReader reader = new BufferedReader(new FileReader(path))) {
            String line;
            while ((line = reader.readLine()) != null) {
                System.out.println(line);
            }
        } catch (IOException e) {
            System.err.println("Failed to read file: " + path);
            e.printStackTrace();
        }
    }
}

Here the try-with-resources block automatically closes the reader, even if an exception is thrown. In production, this pattern is one of the best examples of how to avoid file descriptor leaks.

If you want to go deeper on Java I/O behavior, Oracle’s official Java tutorials are still a reliable reference:

https://docs.oracle.com/javase/tutorial/essential/io/index.html

This is a good complement to any list of examples of try-catch block example in Java, because it shows how exceptions interact with actual file operations.

Network and API calls: examples include timeouts and unreachable services

Modern Java apps are glued together with HTTP calls. APIs fail in all sorts of messy ways: timeouts, DNS issues, 500 errors. Here’s a more realistic example of try-catch block example in Java using HttpClient (Java 11+):

import java.io.IOException;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.http.HttpTimeoutException;
import java.time.Duration;

public class HttpExample {
    public static void main(String[] args) {
        HttpClient client = HttpClient.newHttpClient();

        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create("https://api.example.com/users/123"))
                .timeout(Duration.ofSeconds(3))
                .GET()
                .build();

        try {
            HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());

            if (response.statusCode() >= 200 && response.statusCode() < 300) {
                System.out.println("Response: " + response.body());
            } else {
                System.err.println("Unexpected status: " + response.statusCode());
            }
        } catch (HttpTimeoutException e) {
            System.err.println("Request timed out: " + e.getMessage());
        } catch (IOException e) {
            System.err.println("I/O error during HTTP call: " + e.getMessage());
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            System.err.println("HTTP call interrupted");
        }
    }
}

In microservice-heavy systems that are common in 2024–2025, this style of try-catch is everywhere. These examples of try-catch block example in Java highlight a few patterns worth copying:

Separate timeouts (HttpTimeoutException) from general IOException
Preserve thread interruption status when catching InterruptedException
Treat non-2xx HTTP codes as handled failures, not exceptions

Database access: example of wrapping low-level exceptions

JDBC and most database drivers throw checked exceptions. Raw SQL errors are rarely helpful to upper layers, so a clean design wraps them in domain-specific exceptions.

import java.sql.*;

public class UserRepository {

    public User findById(long id) {
        String sql = "SELECT id, username, email FROM users WHERE id = ?";

        try (Connection conn = dataSource.getConnection();
             PreparedStatement ps = conn.prepareStatement(sql)) {

            ps.setLong(1, id);
            ResultSet rs = ps.executeQuery();

            if (rs.next()) {
                return new User(
                        rs.getLong("id"),
                        rs.getString("username"),
                        rs.getString("email")
                );
            } else {
                return null; // or Optional.empty() in modern code
            }
        } catch (SQLException e) {
            // Wrap in a runtime exception meaningful to the domain
            throw new DataAccessException("Failed to load user with id " + id, e);
        }
    }
}

This is a classic example of try-catch block example in Java where you do not just print the stack trace and move on. Instead, you:

Catch SQLException
Add context (the user id) to the error
Re-throw as a custom unchecked exception like DataAccessException

Patterns like this are widely taught in university software engineering courses; for instance, many Java and exception handling examples in academic material from sites like MIT and Stanford mirror this style:

https://web.mit.edu/6.005/www/fa15/classes/17-exceptions/

Input validation and parsing: examples include JSON and date parsing

User input is messy. Parsing is where you either handle it gracefully or ship bugs to production.

JSON parsing example of try-catch block example in Java

Using Jackson, a common 2024 library:

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;

public class JsonExample {
    private static final ObjectMapper mapper = new ObjectMapper();

    public static User parseUser(String json) {
        try {
            return mapper.readValue(json, User.class);
        } catch (JsonProcessingException e) {
            // Log and return a fallback or propagate
            throw new IllegalArgumentException("Invalid user JSON: " + json, e);
        }
    }
}

This example of a try-catch block keeps the JSON-specific exception (JsonProcessingException) at the edge and rethrows something simpler for the rest of the code.

Date parsing example of try-catch block example in Java

import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
import java.time.format.DateTimeParseException;

public class DateParsingExample {
    private static final DateTimeFormatter FORMATTER = DateTimeFormatter.ISO_LOCAL_DATE;

    public static LocalDate parseDateOrNull(String input) {
        try {
            return LocalDate.parse(input, FORMATTER);
        } catch (DateTimeParseException e) {
            // Invalid date format; return null or Optional.empty()
            return null;
        }
    }
}

Here, the try-catch is used to implement a tolerant API: invalid data becomes null instead of an exception that bubbles up and kills the request.

Multi-catch and finally: best examples for cleanup logic

Sometimes multiple exceptions are handled the same way. Java’s multi-catch syntax keeps the code readable.

public class MultiCatchExample {
    public static void main(String[] args) {
        try {
            riskyOperation();
        } catch (IllegalArgumentException | IllegalStateException e) {
            System.err.println("Client error: " + e.getMessage());
        }
    }

    private static void riskyOperation() {
        // ...
    }
}

And here is an example of try-catch-finally where you must ensure cleanup, even without try-with-resources:

public class LegacyResourceExample {
    public static void main(String[] args) {
        LegacyConnection conn = null;
        try {
            conn = LegacyConnection.open();
            conn.send("PING");
        } catch (LegacyException e) {
            System.err.println("Legacy system error: " + e.getMessage());
        } finally {
            if (conn != null) {
                conn.close();
            }
        }
    }
}

These are the best examples when you need to explain to a junior developer why finally exists at all.

Real examples of try-catch block example in Java in 2024–2025 production systems

In 2024–2025, Java is still a top backend language, but the context has shifted: containers, cloud-native deployments, and distributed tracing are standard. That changes how you design try-catch blocks.

Some real examples include:

Wrapping every external boundary: HTTP calls, message queues (Kafka, RabbitMQ), database access, and file storage all use try-catch to convert low-level failures into clear domain-level errors.
Structured logging inside catch blocks: Instead of e.printStackTrace(), teams use logging frameworks (SLF4J, Logback, Log4j2) with JSON output so observability tools can index exceptions.
Circuit breakers and retries: Libraries like Resilience4j use try-catch internally around supplier functions to decide when to open or close circuits.

A realistic modern snippet using logging might look like this:

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class PaymentService {
    private static final Logger log = LoggerFactory.getLogger(PaymentService.class);

    public Receipt charge(PaymentRequest request) {
        try {
            return paymentGateway.charge(request);
        } catch (GatewayTimeoutException e) {
            log.warn("Payment timeout for userId={} amount={}",
                    request.userId(), request.amount(), e);
            throw new PaymentUnavailableException("Payment service timeout", e);
        } catch (GatewayException e) {
            log.error("Payment gateway error for userId={} amount={}",
                    request.userId(), request.amount(), e);
            throw new PaymentFailedException("Payment failed", e);
        }
    }
}

This is one of the clearer real examples of try-catch block example in Java in a production-grade service: different exception types map to different log levels and different domain exceptions.

For developers interested in how error handling practices intersect with reliability and human factors, broader engineering and safety literature (for example, material from the National Institute of Standards and Technology) is surprisingly relevant:

https://www.nist.gov/programs-projects/software-quality-group

It’s not Java-specific, but it reinforces why disciplined exception handling matters for real-world reliability.

Anti-patterns: examples of try-catch usage you should avoid

Not all examples of try-catch block example in Java are worth copying. A few patterns show up repeatedly in code reviews and should raise red flags:

Empty catch blocks
```
try {
    doSomething();
} catch (Exception e) {
    // ignore
}
```
This hides bugs and makes production outages harder to diagnose.
Catching Exception everywhere
```
try {
    process();
} catch (Exception e) {
    log.error("Something went wrong", e);
}
```
Sometimes appropriate at top-level boundaries (like a servlet filter), but a bad habit inside libraries or core logic. It prevents the compiler from helping you reason about failures.
Using exceptions for control flow

Throwing exceptions to manage normal cases (like missing configuration) leads to slower and harder-to-read code.

Modern guidelines from many university courses and industry style guides align on this: use exceptions for exceptional conditions, not for ordinary branching. Stanford’s CS materials, for instance, echo this principle:

https://web.stanford.edu/class/archive/cs/cs108/cs108.1092/handouts/16Exceptions.pdf

When you look at the best examples of try-catch block example in Java, they all share a theme: they add clarity and safety, not confusion.

FAQ: common questions about examples of try-catch block example in Java

Q1. Can you give a simple example of a try-catch block that logs and rethrows?

Yes, here is a compact pattern used in many services:

try {
    service.call();
} catch (ServiceException e) {
    logger.error("Service failed", e);
    throw e; // rethrow after logging
}

This is one of the cleaner examples of logging without swallowing the exception.

Q2. When should I use multiple catch blocks versus a single catch?

Use multiple catch blocks when different exception types require different handling (retry vs fail fast, warn vs error logging). If they’re treated identically, a single catch or a multi-catch is usually better.

Q3. Is it okay to catch Exception at the top of my application?

At the very top (for example, in a main method, servlet filter, or framework-wide error handler), catching Exception can be reasonable to prevent the JVM from exiting and to log unexpected failures. Inside business logic, prefer specific exceptions. Most production-grade examples of try-catch block example in Java follow this pattern.

Q4. How do I test code that uses try-catch blocks?

You write tests that trigger both the normal path and the exceptional path. For instance, mock a repository to throw SQLException and assert that your service wraps it in DataAccessException. Good examples of unit tests around try-catch usually verify both the thrown type and the message.

Q5. What are examples of exceptions I should never swallow?

Errors like OutOfMemoryError, StackOverflowError, and ThreadDeath should almost never be caught. They indicate serious JVM-level problems. In standard examples of try-catch block example in Java, you’ll see developers catch Exception or RuntimeException, not Error.

The bottom line: the best examples of try-catch block example in Java are not about catching everything. They’re about catching the right things, adding context, logging intelligently, and making your system more debuggable when the inevitable failures arrive.

Practical examples of try-catch block example in Java for real-world debugging