1. The Hook (The "Byte-Sized" Intro)
In a Nutshell: Good exception handling follows key principles: catch specific exceptions, never swallow errors, clean up resources, provide meaningful messages, document exceptions, and fail fast. Bad practices include empty catch blocks, catching generic Exception, and using exceptions for control flow.
Think of airline safety protocols. They don't say "handle any problem somehow." They have specific procedures for engine failure, decompression, fire—and they ALWAYS report incidents. Same with exceptions!
2. Conceptual Clarity (The "Simple" Tier)
💡 The Analogy: The Emergency Response
- ✅ Good: Specific training for each emergency type, always report, clear protocols
- ❌ Bad: "Deal with any problem however," ignore incidents, no documentation
3. Technical Mastery (The "Deep Dive")
The Golden Rules
- Catch Specific Exceptions (not generic)
- Never Swallow Exceptions (empty catch = bug hiding)
- Clean Up Resources (try-with-resources or finally)
- Provide Context (meaningful messages)
- Document Exceptions (@throws in Javadoc)
- Fail Fast (validate early)
- Don't Use for Control Flow (exceptions are expensive)
4. Interactive & Applied Code
java
// ❌ BAD PRACTICES
class BadPractices {
void badExample1() {
try {
// risky code
} catch (Exception e) {
// ❌ Empty catch (swallowing exception!)
}
}
void badExample2() {
try {
// code
} catch (Exception e) { // ❌ Too generic!
e.printStackTrace(); // ❌ Just printing (not handling!)
}
}
void badExample3() {
// ❌ Using exceptions for control flow
try {
while (true) {
array[index++];
}
} catch (ArrayIndexOutOfBoundsException e) {
// Reached end
}
}
}
// ✅ GOOD PRACTICES
class GoodPractices {
/**
* Processes user data
* @param userData Raw user input
* @throws IllegalArgumentException if userData is null or empty
* @throws DataProcessingException if processing fails
*/
void goodExample1(String userData) {
// ✅ Fail fast (validate early)
if (userData == null || userData.isEmpty()) {
throw new IllegalArgumentException("User data cannot be null or empty");
}
processData(userData);
}
void goodExample2() {
// ✅ Catch specific exceptions
try {
readFile("data.txt");
} catch (java.io.FileNotFoundException e) {
// ✅ Specific handling + logging
logger.error("File not found: {}", e.getMessage());
// ✅ Provide fallback
useDefaultData();
} catch (java.io.IOException e) {
// ✅ Different handling for different errors
logger.error("IO error", e);
throw new DataAccessException("Failed to read data", e);
}
}
void goodExample3() {
// ✅ Try-with-resources (automatic cleanup)
try (java.io.BufferedReader reader =
new java.io.BufferedReader(new java.io.FileReader("data.txt"))) {
String line = reader.readLine();
processLine(line);
} catch (java.io.IOException e) {
// ✅ Meaningful error message with context
throw new DataLoadException(
"Failed to load data from file: data.txt",
e
);
}
}
// Placeholder methods
void processData(String data) {}
void readFile(String name) throws java.io.IOException {}
void useDefaultData() {}
void processLine(String line) {}
java.util.logging.Logger logger = java.util.logging.Logger.getLogger("App");
}
// ✅ Custom exception with context
class DataProcessingException extends RuntimeException {
private final String dataId;
public DataProcessingException(String message, String dataId, Throwable cause) {
super(message + " (Data ID: " + dataId + ")", cause);
this.dataId = dataId;
}
public String getDataId() { return dataId; }
}
class DataAccessException extends RuntimeException {
public DataAccessException(String message, Throwable cause) {
super(message, cause);
}
}
class DataLoadException extends RuntimeException {
public DataLoadException(String message, Throwable cause) {
super(message, cause);
}
}5. The Comparison & Decision Layer
Best Practices Checklist
| Practice | ❌ Bad | ✅ Good |
|---|---|---|
| Catch | catch (Exception e) | catch (FileNotFoundException e) |
| Empty catch | catch (E e) {} | catch (E e) { log(e); } |
| Resources | Manual close in finally | Try-with-resources |
| Messages | throw new Exception() | throw new Exception("Clear message") |
| Documentation | No @throws | @throws IOException if... |
| Control flow | Use exceptions | Use normal if/loops |
6. The "Interview Corner" (The Edge)
The "Killer" Interview Question:
"Why shouldn't you catch generic Exception?"
Answer: Catching Exception catches everything (even RuntimeExceptions you didn't expect). This:
- Hides bugs (catches NullPointerException you should fix)
- Prevents specific handling (can't distinguish errors)
- Catches too much (maybe even Errors!)
Always catch specific exceptions you know how to handle.
Pro-Tips:
- Log, then rethrow at layer boundaries:
java
catch (IOException e) {
logger.error("Data access failed", e);
throw new DataAccessException("Cannot load user", e);
}- Use exception chaining to preserve root cause:
java
throw new BusinessException("Order failed", originalException);- Validate with Objects.requireNonNull() (Java 7+):
java
this.name = Objects.requireNonNull(name, "Name required");