Java Tutorial

🔍

Java Introduction What is Java?History & Features JDK vs JRE vs JVM How Java Works Install Java & Setup First Java Program Java vs Other Languages

Syntax & Structure Java Keywords & Reserved Words Naming Conventions Data Types Variables Type Casting Operators Increment & Decrement Operators Escape Sequences Math Class User Input (Scanner)Command Line Arguments Wrapper Classes Autoboxing & Unboxing final Keyword Comments

if Statement if-else Statement else-if Ladder Nested if switch Statement for Loop while Loop do-while Loop for-each Loop Nested Loops break Statement continue Statement return Statement

Methods Overview Parameters & Return Types Method Overloading Recursion Variable Arguments (varargs)Pass by Value vs Pass by Reference

Arrays Overview Multi-dimensional Arrays Arrays class Passing Arrays to Methods

String Overview String Methods String Comparison equals() vs ==String Pool StringBuilder StringBuffer String vs StringBuilder vs StringBuffer Immutable Strings String Formatting String Class Deep Dive

Packages in Java Creating Custom Packages import Statement Access Modifiers Deep Dive public Access Modifier private Access Modifier protected Access Modifier default Access Modifier

Inner Classes Static Nested Class Anonymous Classes Enums Records (Java 16+)Sealed Classes (Java 17+)Immutable Classes Object Cloning Shallow vs Deep Copy Annotations Built-in Annotations Custom Annotations Reflection API

What is Exception Handling?Exception vs Error Exception Hierarchy Checked vs Unchecked Exceptions Common Java Exceptions try-catch Multi-catch finally Block try-with-resources throw Keyword throws Keyword throw vs throws Custom Exceptions Exception Propagation

Generics Overview Why Generics?Generic Classes Generic Interfaces Generic Methods Bounded Type Parameters Wildcards (?)Upper-Bounded Wildcards (? extends)Lower-Bounded Wildcards (? super)Generics in the Collections Framework Type Inference (Diamond Operator)Type Erasure What Generics Cannot Do

Lambda Expressions Functional Interfaces Method References Predicate Function Consumer Supplier Optional

Streams Overview filter()map()forEach()reduce()collect()sorted()distinct()limit()skip()Collectors & groupingBy()Parallel Streams Stream vs Parallel Stream

Introduction to Date & Time API LocalDate LocalTime LocalDateTime ZonedDateTime Period Duration DateTimeFormatter Legacy Date vs New API

Java 8 Key Features Java 11 Features Java 17 Features Java 21 Features var (Local Type Inference)Text Blocks Pattern Matching Switch Expressions Virtual Threads (Java 21)

File & Path Overview Reading Files Writing Files BufferedReader & Writer NIO.2 (java.nio)Serialization Externalization Serialization vs Externalization

Threads Overview Runnable & Callable Thread Lifecycle Synchronization volatile Keyword Race Conditions Deadlock Livelock Starvation wait, notify & notifyAll Lock & ReentrantLock Semaphore Atomic Variables ConcurrentHashMap Executor Framework CompletableFuture ForkJoinPool

JVM Architecture Stack Memory Heap Memory Stack vs Heap Memory Garbage Collection Metaspace vs PermGen ClassLoader JIT Compiler

Java Programs›Exceptions›Custom Exception

Custom Exception in Java

intermediate· Exceptions · Error Handling

Problem

A custom exception is a user-defined class that extends Exception (or RuntimeException) to represent a specific error condition in your own code.

Define a custom exception and throw it when a withdrawal exceeds the account balance.

Input

balance=100, withdraw=150

Output

Error: Insufficient funds for this withdrawal

Java Program

Java

class InsufficientFundsException extends Exception {
    InsufficientFundsException(String message) {
        super(message); // forwards the message so getMessage() can return it
    }
}

public class BankAccount {
    // throws clause forces callers to catch or declare this checked exception
    static void withdraw(double balance, double amount) throws InsufficientFundsException {
        if (amount > balance) {
            throw new InsufficientFundsException("Insufficient funds for this withdrawal");
        }
        System.out.println("Withdrawal successful");
    }

    public static void main(String[] args) {
        try {
            withdraw(100.0, 150.0);
        } catch (InsufficientFundsException e) {
            System.out.println("Error: " + e.getMessage());
        }
    }
}

▶ Run Code

Output

Error: Insufficient funds for this withdrawal

Core Logic

Sometimes the built-in exceptions don't fit — here a custom checked exception is thrown when a withdrawal breaks the balance rule.

How It Works

1class InsufficientFundsException extends Exception creates a new checked exception type.
2Its constructor forwards the message to super(message), so getMessage() returns it later.
3withdraw() declares throws InsufficientFundsException, requiring callers to handle it.
4When amount > balance, the method does throw new InsufficientFundsException(...) instead of continuing.
5The caller wraps the call in try/catch and reads the message back with e.getMessage().

Withdrawing 150 from a balance of 100 throws the custom exception, caught and printed as "Error: Insufficient funds for this withdrawal".

💡

Key Point: Extending Exception (not RuntimeException) makes this a checked exception — the compiler forces every caller to either catch it or declare it.

Key Concepts

custom exceptionextends Exceptionthrows

Approach 2: Unchecked Custom Exception

Java

class InsufficientFundsRuntimeException extends RuntimeException {
    InsufficientFundsRuntimeException(String message) {
        super(message);
    }
}

public class BankAccountUnchecked {
    // No throws clause needed — RuntimeException is unchecked
    static void withdraw(double balance, double amount) {
        if (amount > balance) {
            throw new InsufficientFundsRuntimeException("Insufficient funds for this withdrawal");
        }
        System.out.println("Withdrawal successful");
    }

    public static void main(String[] args) {
        try {
            withdraw(100.0, 150.0);
        } catch (InsufficientFundsRuntimeException e) {
            System.out.println("Error: " + e.getMessage());
        }
    }
}

▶ Run Code

Output

Error: Insufficient funds for this withdrawal

Core Logic

The same idea works as an unchecked exception too — extend RuntimeException instead, and callers are no longer forced to handle it.

How It Works

1class InsufficientFundsRuntimeException extends RuntimeException makes this an unchecked exception.
2withdraw() no longer needs a throws clause — the compiler doesn't require callers to catch or declare unchecked exceptions.
3The throw statement inside withdraw() is otherwise identical to the checked version.
4The caller still chooses to wrap the call in try/catch here, but it's now optional rather than compiler-enforced.

Calling withdraw(100.0, 150.0) throws the same way as before, but the compiler would have allowed calling it with no try/catch at all.

💡

Key Point: Use a checked exception when callers can reasonably be expected to recover (like retrying with a smaller amount); use an unchecked one when the failure represents a programming error or a business rule violation the caller isn't expected to routinely handle.

Key Concepts

RuntimeExceptionunchecked exceptionchecked vs. unchecked

Handling Divide by Zero

Related Programs

Exceptionsbeginner

Handling Divide by Zero

Stringsintermediate

Check Anagram

Stringsbeginner

Check Palindrome String

Stringsbeginner

Count Characters in a String

Stringsbeginner

Reverse a String