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 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.
Why Create Custom Exceptions?
Java provides many built-in exceptions, but they're generic. In real applications, you need domain-specific exceptions that:
- Communicate specific business errors —
InsufficientFundsExceptionis clearer thanRuntimeException("not enough money") - Carry additional context — error codes, affected entities, recovery suggestions
- Enable fine-grained handling — callers can catch specific business errors separately
- Improve API design — method signatures clearly document what can go wrong
Creating a Basic Custom Exception
Custom Checked Exception (extends Exception)
java example
// Custom checked exception — caller MUST handle or declare
public class InsufficientFundsException extends Exception {
public InsufficientFundsException(String message) {
super(message);
}
}Custom Unchecked Exception (extends RuntimeException)
java example
// Custom unchecked exception — caller doesn't need to handle
public class InvalidProductException extends RuntimeException {
public InvalidProductException(String message) {
super(message);
}
}When to Choose Checked vs Unchecked
Use Checked (extends Exception) | Use Unchecked (extends RuntimeException) |
|---|---|
| Caller can meaningfully recover | Programming error / bug |
| External resource failures | Validation failures |
| Business rule violations with alternatives | Illegal state that shouldn't happen |
| API contracts the caller must respect | Framework/internal errors |
Complete Custom Exception with All Constructors
A well-designed custom exception should have four constructors matching Exception:
java example
public class ApplicationException extends Exception {
// 1. No-arg constructor
public ApplicationException() {
super();
}
// 2. Message constructor
public ApplicationException(String message) {
super(message);
}
// 3. Message + Cause constructor (for exception chaining)
public ApplicationException(String message, Throwable cause) {
super(message, cause);
}
// 4. Cause-only constructor
public ApplicationException(Throwable cause) {
super(cause);
}
}Real-World Example: Banking System
java example
// === Custom Exceptions ===
class InsufficientFundsException extends Exception {
private double balance;
private double withdrawAmount;
public InsufficientFundsException(double balance, double withdrawAmount) {
super(String.format(
"Cannot withdraw $%.2f. Available balance: $%.2f. Short by: $%.2f",
withdrawAmount, balance, withdrawAmount - balance));
this.balance = balance;
this.withdrawAmount = withdrawAmount;
}
public double getBalance() { return balance; }
public double getWithdrawAmount() { return withdrawAmount; }
public double getDeficit() { return withdrawAmount - balance; }
}
class AccountNotFoundException extends Exception {
private String accountId;
public AccountNotFoundException(String accountId) {
super("Account not found: " + accountId);
this.accountId = accountId;
}
public String getAccountId() { return accountId; }
}
class AccountLockedException extends Exception {
private String accountId;
private String reason;
public AccountLockedException(String accountId, String reason) {
super("Account " + accountId + " is locked: " + reason);
this.accountId = accountId;
this.reason = reason;
}
public String getAccountId() { return accountId; }
public String getReason() { return reason; }
}
// === Bank Account Class ===
class BankAccount {
private String accountId;
private String ownerName;
private double balance;
private boolean locked;
private String lockReason;
public BankAccount(String accountId, String ownerName, double balance) {
this.accountId = accountId;
this.ownerName = ownerName;
this.balance = balance;
this.locked = false;
}
public void withdraw(double amount)
throws InsufficientFundsException, AccountLockedException {
if (locked) {
throw new AccountLockedException(accountId, lockReason);
}
if (amount <= 0) {
throw new IllegalArgumentException("Amount must be positive: " + amount);
}
if (amount > balance) {
throw new InsufficientFundsException(balance, amount);
}
balance -= amount;
System.out.printf(" ✓ Withdrew $%.2f from %s. New balance: $%.2f%n",
amount, accountId, balance);
}
public void lock(String reason) {
this.locked = true;
this.lockReason = reason;
}
public double getBalance() { return balance; }
public String getAccountId() { return accountId; }
}
// === Banking Service ===
public class BankingSystem {
private static java.util.Map<String, BankAccount> accounts = new java.util.HashMap<>();
static {
accounts.put("ACC001", new BankAccount("ACC001", "Alice", 5000));
accounts.put("ACC002", new BankAccount("ACC002", "Bob", 1200));
BankAccount locked = new BankAccount("ACC003", "Charlie", 8000);
locked.lock("Suspicious activity detected");
accounts.put("ACC003", locked);
}
static BankAccount findAccount(String accountId) throws AccountNotFoundException {
BankAccount account = accounts.get(accountId);
if (account == null) {
throw new AccountNotFoundException(accountId);
}
return account;
}
static void processWithdrawal(String accountId, double amount) {
System.out.printf("Processing withdrawal: $%.2f from %s%n", amount, accountId);
try {
BankAccount account = findAccount(accountId);
account.withdraw(amount);
} catch (AccountNotFoundException e) {
System.out.println(" ✗ " + e.getMessage());
System.out.println(" → Please verify account number");
} catch (InsufficientFundsException e) {
System.out.println(" ✗ " + e.getMessage());
System.out.printf(" → Consider withdrawing up to $%.2f%n",
e.getBalance());
} catch (AccountLockedException e) {
System.out.println(" ✗ " + e.getMessage());
System.out.println(" → Contact support at 1-800-BANK");
} catch (IllegalArgumentException e) {
System.out.println(" ✗ Invalid input: " + e.getMessage());
}
}
public static void main(String[] args) {
System.out.println("=== Banking System Demo ===\n");
processWithdrawal("ACC001", 3000); // Success
System.out.println();
processWithdrawal("ACC001", 5000); // Insufficient funds
System.out.println();
processWithdrawal("ACC999", 100); // Account not found
System.out.println();
processWithdrawal("ACC003", 500); // Account locked
System.out.println();
processWithdrawal("ACC002", -50); // Invalid amount
}
}Output:
| Processing withdrawal | $3000.00 from ACC001 |
| ✓ Withdrew $3000.00 from ACC001. New balance | $2000.00 |
| Processing withdrawal | $5000.00 from ACC001 |
| ✗ Cannot withdraw $5000.00. Available balance | $2000.00. Short by: $3000.00 |
| Processing withdrawal | $100.00 from ACC999 |
| ✗ Account not found | ACC999 |
| Processing withdrawal | $500.00 from ACC003 |
| ✗ Account ACC003 is locked | Suspicious activity detected |
| Processing withdrawal | $-50.00 from ACC002 |
| ✗ Invalid input | Amount must be positive: -50.0 |
Custom Exception with Error Codes
Enterprise applications often use error codes for API responses:
Example
// Error code enum
enum ErrorCode {
VALIDATION_ERROR(1001, "Validation Failed"),
NOT_FOUND(1002, "Resource Not Found"),
UNAUTHORIZED(1003, "Access Denied"),
CONFLICT(1004, "Resource Conflict"),
INTERNAL_ERROR(1005, "Internal Server Error");
private final int code;
private final String description;
ErrorCode(int code, String description) {
this.code = code;
this.description = description;
}
public int getCode() { return code; }
public String getDescription() { return description; }
}
// Custom exception with error code
class ApiException extends RuntimeException {
private final ErrorCode errorCode;
private final java.util.Map<String, Object> details;
public ApiException(ErrorCode errorCode, String message) {
super(message);
this.errorCode = errorCode;
this.details = new java.util.HashMap<>();
}
public ApiException(ErrorCode errorCode, String message, Throwable cause) {
super(message, cause);
this.errorCode = errorCode;
this.details = new java.util.HashMap<>();
}
public ApiException addDetail(String key, Object value) {
details.put(key, value);
return this; // Fluent API
}
public ErrorCode getErrorCode() { return errorCode; }
public java.util.Map<String, Object> getDetails() { return details; }
@Override
public String toString() {
return String.format("[%d] %s: %s | Details: %s",
errorCode.getCode(), errorCode.getDescription(),
getMessage(), details);
}
}
// Usage
public class ApiExceptionDemo {
static void findUser(String userId) {
if (userId == null || userId.isEmpty()) {
throw new ApiException(ErrorCode.VALIDATION_ERROR, "User ID is required")
.addDetail("field", "userId")
.addDetail("constraint", "not_empty");
}
if (!userId.startsWith("USR")) {
throw new ApiException(ErrorCode.NOT_FOUND, "User not found")
.addDetail("userId", userId)
.addDetail("searchedAt", java.time.Instant.now().toString());
}
System.out.println("Found user: " + userId);
}
public static void main(String[] args) {
String[] testIds = {"USR001", "", "INVALID_123"};
for (String id : testIds) {
try {
findUser(id);
} catch (ApiException e) {
System.out.println("API Error: " + e);
System.out.println(" Code: " + e.getErrorCode().getCode());
System.out.println(" Details: " + e.getDetails());
System.out.println();
}
}
}
}
Output:
| Found user | USR001 |
| API Error | [1001] Validation Failed: User ID is required | Details: {field=userId, constraint=not_empty} |
| Code | 1001 |
| Details | {field=userId, constraint=not_empty} |
| API Error | [1002] Resource Not Found: User not found | Details: {userId=INVALID_123, searchedAt=2024-01-15T10:30:00Z} |
| Code | 1002 |
| Details | {userId=INVALID_123, searchedAt=2024-01-15T10:30:00Z} |
Exception Chaining (Wrapping)
When a low-level exception occurs, you should wrap it in a higher-level exception:
java example
import java.io.*;
class DataLoadException extends Exception {
private String filename;
public DataLoadException(String message, String filename, Throwable cause) {
super(message, cause);
this.filename = filename;
}
public String getFilename() { return filename; }
}
class ConfigurationException extends Exception {
public ConfigurationException(String message, Throwable cause) {
super(message, cause);
}
}
public class ExceptionChainingDemo {
static java.util.Properties loadConfig(String filename)
throws ConfigurationException {
try {
FileInputStream fis = new FileInputStream(filename);
java.util.Properties props = new java.util.Properties();
props.load(fis);
fis.close();
return props;
} catch (FileNotFoundException e) {
throw new ConfigurationException(
"Configuration file not found: " + filename, e);
} catch (IOException e) {
throw new ConfigurationException(
"Error reading configuration: " + filename, e);
}
}
public static void main(String[] args) {
try {
loadConfig("app.properties");
} catch (ConfigurationException e) {
System.out.println("=== Exception Chain ===");
System.out.println("Top-level: " + e.getMessage());
System.out.println("Cause: " + e.getCause().getClass().getSimpleName()
+ " - " + e.getCause().getMessage());
System.out.println("\n=== Full Stack Trace ===");
e.printStackTrace(System.out);
}
}
}Output:
| Top-level | Configuration file not found: app.properties |
| Cause | FileNotFoundException - app.properties (No such file or directory) |
| ConfigurationException | Configuration file not found: app.properties |
| at ExceptionChainingDemo.loadConfig(ExceptionChainingDemo.java | 27) |
| at ExceptionChainingDemo.main(ExceptionChainingDemo.java | 36) |
| Caused by | java.io.FileNotFoundException: app.properties (No such file or directory) |
| at java.io.FileInputStream.<init>(FileInputStream.java | 157) |
| at ExceptionChainingDemo.loadConfig(ExceptionChainingDemo.java | 22) |
Exception Hierarchy for a Real Application
Example
// Base application exception
abstract class AppException extends Exception {
private final String errorCode;
private final java.time.LocalDateTime timestamp;
public AppException(String errorCode, String message) {
super(message);
this.errorCode = errorCode;
this.timestamp = java.time.LocalDateTime.now();
}
public AppException(String errorCode, String message, Throwable cause) {
super(message, cause);
this.errorCode = errorCode;
this.timestamp = java.time.LocalDateTime.now();
}
public String getErrorCode() { return errorCode; }
public java.time.LocalDateTime getTimestamp() { return timestamp; }
}
// Domain-specific exceptions
class OrderException extends AppException {
private String orderId;
public OrderException(String errorCode, String message, String orderId) {
super(errorCode, message);
this.orderId = orderId;
}
public String getOrderId() { return orderId; }
}
class PaymentException extends AppException {
private double amount;
public PaymentException(String errorCode, String message, double amount) {
super(errorCode, message);
this.amount = amount;
}
public double getAmount() { return amount; }
}
class InventoryException extends AppException {
private String productId;
private int requested;
private int available;
public InventoryException(String productId, int requested, int available) {
super("INV_001", String.format(
"Insufficient stock for %s: requested %d, available %d",
productId, requested, available));
this.productId = productId;
this.requested = requested;
this.available = available;
}
public String getProductId() { return productId; }
public int getRequested() { return requested; }
public int getAvailable() { return available; }
}
// Usage
public class ECommerceSystem {
public static void main(String[] args) {
System.out.println("=== E-Commerce Exception Hierarchy ===\n");
try {
placeOrder("ORD-123", "PROD-456", 10);
} catch (InventoryException e) {
System.out.printf("Inventory Issue [%s]: %s%n", e.getErrorCode(), e.getMessage());
System.out.printf(" Product: %s | Want: %d | Have: %d%n",
e.getProductId(), e.getRequested(), e.getAvailable());
} catch (PaymentException e) {
System.out.printf("Payment Issue [%s]: %s%n", e.getErrorCode(), e.getMessage());
} catch (OrderException e) {
System.out.printf("Order Issue [%s]: %s%n", e.getErrorCode(), e.getMessage());
} catch (AppException e) {
System.out.printf("General Issue [%s]: %s%n", e.getErrorCode(), e.getMessage());
}
}
static void placeOrder(String orderId, String productId, int qty)
throws OrderException, PaymentException, InventoryException {
// Check inventory
int available = 5; // Simulated stock
if (qty > available) {
throw new InventoryException(productId, qty, available);
}
}
}
Output:
Example
=== E-Commerce Exception Hierarchy ===
Inventory Issue [INV_001]: Insufficient stock for PROD-456: requested 10, available 5
Product: PROD-456 | Want: 10 | Have: 5
Common Mistakes
1. Not extending the right parent class
java example
// ❌ Extending Throwable directly (too broad)
class MyException extends Throwable { }
// ❌ Extending Error (reserved for JVM issues)
class MyException extends Error { }
// ✅ Extend Exception (checked) or RuntimeException (unchecked)
class MyCheckedException extends Exception { }
class MyUncheckedException extends RuntimeException { }2. Losing the original cause
java example
// ❌ BAD: Original exception cause is LOST
try {
// code
} catch (SQLException e) {
throw new AppException("DB Error"); // Where's the cause?
}
// ✅ GOOD: Preserve the cause
try {
// code
} catch (SQLException e) {
throw new AppException("DB Error", e); // Cause preserved!
}3. Making exceptions mutable
java example
// ❌ BAD: Mutable exception
class BadException extends Exception {
private String detail;
public void setDetail(String d) { this.detail = d; } // Mutable!
}
// ✅ GOOD: Immutable exception
class GoodException extends Exception {
private final String detail; // final!
public GoodException(String message, String detail) {
super(message);
this.detail = detail;
}
public String getDetail() { return detail; }
}Best Practices
- Name ends with "Exception" —
InvalidOrderException, notInvalidOrder - Provide all four standard constructors when possible
- Include the original cause in chained exceptions
- Make exception fields final (immutable)
- Add meaningful context — error codes, affected IDs, suggestions
- Create an exception hierarchy for complex domains
- Use checked for recoverable, unchecked for bugs
- Document with @throws in Javadoc
- Make exceptions Serializable (they already are via Throwable)
Interview Questions
Q1: How do you create a custom exception in Java?
Answer: Extend Exception for checked or RuntimeException for unchecked. At minimum, provide a constructor that takes a String message and calls super(message). Best practice: provide all four constructors (no-arg, message, message+cause, cause-only).
Q2: When should you create a custom exception vs using built-in ones?
Answer: Create custom exceptions when: (1) you need to carry domain-specific data (account ID, error codes), (2) callers need to distinguish your errors from other exceptions, (3) you want a hierarchy of related exceptions. Use built-in ones for generic cases (IllegalArgumentException for bad inputs, IllegalStateException for bad state).
Q3: Should custom exceptions be checked or unchecked?
Answer: Use checked when the caller can take meaningful recovery action (retry, use default, prompt user). Use unchecked when it's a programming error that should be fixed in code. In modern practice, unchecked exceptions are generally preferred because they don't clutter method signatures.
Q4: What is exception chaining and why is it important?
Answer: Exception chaining wraps a low-level exception in a higher-level one using new MyException("message", cause). It's important because: (1) it preserves the full error history for debugging, (2) it hides implementation details from callers, (3) the original cause is accessible via getCause().
Q5: What methods should a well-designed custom exception have?
Answer: At minimum: four constructors (matching Exception), getMessage() (inherited), and any domain-specific getters for additional fields. For enterprise apps: error code, timestamp, and a toMap() or toJson() method for API responses.
Q8: Should custom exceptions be checked or unchecked?
A: It depends on whether the caller can meaningfully recover. Checked (extend Exception): for recoverable conditions like InsufficientFundsException, FileFormatException. Unchecked (extend RuntimeException): for programming errors or conditions callers can't handle like InvalidConfigException, DataCorruptionException.
Q9: What constructors should a custom exception have?
A: At minimum: (1) no-arg constructor, (2) constructor with message (String), (3) constructor with message and cause (String, Throwable), (4) constructor with cause only (Throwable). These mirror the constructors in Exception/RuntimeException and enable proper exception chaining.
Q10: Should custom exceptions be serializable?
A: Yes. All exceptions extend Throwable which implements Serializable. If your custom exception has non-serializable fields (like a database Connection), make them transient. If your exception carries custom data (error codes, context objects), ensure those are serializable or transient too.
Q11: What is the best practice for custom exception class naming?
A: Always end with "Exception": InsufficientBalanceException, InvalidOrderException. For errors (unrecoverable), end with "Error": ConfigurationError. Use business-domain names, not technical names. Group related exceptions with a common parent: PaymentException → InsufficientFundsException, CardDeclinedException.
Q12: How do you add custom data to exceptions?
A: Add fields with getters: private final String errorCode; private final Map<String, Object> context;. Initialize in constructors. This lets catch blocks access structured error data beyond just the message: catch (PaymentException e) { log(e.getErrorCode(), e.getTransactionId()); }.
Exam Focus
Revise definitions, diagrams, examples, and short-answer points for Custom Exceptions 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, custom
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 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.Exception HandlingTry-Catch Block in JavaComplete 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.