Course: Core Java Training
Topic: Introduction to Errors and Exceptions in Java
Course Link: Core Java Training Course
Demo Link: Register for a Course Demo
JustAcademy Website: Visit JustAcademy
Errors and exceptions are important concepts in Java programming. They describe problems or unexpected conditions that can interrupt the normal execution of a program. Understanding them helps developers write reliable, maintainable, and robust applications.
For example, a program may attempt to divide an integer by zero, access an array element that does not exist, open a file that is unavailable, or use a reference that contains null. Java provides an exception-handling mechanism to identify many such conditions and respond appropriately.
Java also distinguishes exceptions from serious errors that affect the Java Virtual Machine or the runtime environment. These categories belong to the Throwable class hierarchy.
public class Main {
public static void main(String[] args) {
int a = 10;
int b = 0;
int result = a / b;
System.out.println("Result: " + result);
System.out.println("Program completed");
}
}Output:
Exception in thread "main" java.lang.ArithmeticException: / by zeroThe division operation throws an ArithmeticException. Because the exception is not handled, the remaining statements in the method are not executed.
After completing this topic, you should be able to:
Throwable class hierarchy.try, catch, finally, throw, and throws.An error is a problem that causes a program to behave incorrectly or prevents it from executing as expected. Errors can occur at different stages of software development and execution.
| Type | Description | Example |
|---|---|---|
| Syntax or compilation error | A violation of Java syntax or compile-time rules prevents successful compilation. | Missing semicolon or undeclared variable |
| Runtime exception | A problem occurs while the program is executing and an exception is thrown. | Dividing an integer by zero |
| Logical error | The program runs but produces an incorrect result. | Using addition instead of multiplication in a formula |
| Java Error | A serious condition represented by a subclass of java.lang.Error. |
OutOfMemoryError |
public class Main {
public static void main(String[] args) {
System.out.println("Hello Java")
}
}The statement is missing a semicolon. The compiler reports a compilation error, and the program cannot run until the code is corrected.
public class Main {
public static void main(String[] args) {
int length = 5;
int width = 4;
int area = length + width;
System.out.println("Area: " + area);
}
}Output:
Area: 9The program compiles and runs, but the area calculation is incorrect. The correct formula for a rectangle is length * width, which produces 20.
An exception is an object that represents an abnormal condition encountered during program execution. When an exception is thrown, Java interrupts the normal execution path and searches for an appropriate exception handler.
Exceptions may be generated by the Java Virtual Machine, Java library methods, or application code using the throw statement.
public class Main {
public static void main(String[] args) {
try {
int result = 10 / 0;
System.out.println(result);
} catch (ArithmeticException e) {
System.out.println("Cannot divide an integer by zero.");
}
System.out.println("Program continues.");
}
}Output:
Cannot divide an integer by zero.
Program continues.The try block contains code that may throw an exception. The catch block handles the matching exception, allowing execution to continue after the exception-handling statement.
In Java, Throwable is the root class for objects that can be thrown and caught. It has two main direct subclasses: Error and Exception.
Object
|
+-- Throwable
|
+-- Error
| +-- OutOfMemoryError
| +-- StackOverflowError
| +-- LinkageError
|
+-- Exception
|
+-- RuntimeException
| +-- ArithmeticException
| +-- NullPointerException
| +-- ArrayIndexOutOfBoundsException
| +-- NumberFormatException
|
+-- Other checked exceptions
+-- IOException
+-- SQLException
+-- ClassNotFoundExceptionThis hierarchy is simplified and shows representative subclasses rather than every class in the Java API.
| Class | Description |
|---|---|
Throwable |
Base class for Java errors and exceptions that can be thrown. |
Error |
Represents serious conditions that applications generally should not attempt to handle as ordinary recoverable problems. |
Exception |
Represents conditions that an application may be able to handle. |
RuntimeException |
Base class for unchecked exceptions that commonly indicate invalid operations or programming mistakes. |
IOException |
Represents input/output-related problems. |
ArithmeticException |
Represents certain invalid arithmetic operations, such as integer division by zero. |
Although both Error and Exception extend Throwable, they serve different purposes.
| Feature | Error | Exception |
|---|---|---|
| Meaning | Serious runtime or environment-related condition | Condition that an application may be able to handle |
| Typical cause | Resource exhaustion or JVM-related problems | Invalid input, missing files, or inappropriate operations |
| Recovery | Often difficult or unsafe to recover from | May be recoverable through validation, retry, or fallback logic |
| Handling approach | Usually diagnose the underlying cause rather than catch routinely | Catch or declare when appropriate |
| Examples | OutOfMemoryError, StackOverflowError |
IOException, ArithmeticException |
Important: An Error is not the same thing as a compilation error or logical error. A compilation error is detected by the compiler, while java.lang.Error is a specific class in Java's throwable hierarchy.
Checked exceptions are exceptions that the compiler requires a method to handle or declare when they can propagate beyond the method or constructor. They generally represent conditions that an application may need to anticipate and respond to.
| Exception | Description |
|---|---|
IOException |
Input/output operation fails. |
FileNotFoundException |
A requested file cannot be found or opened. |
SQLException |
A database access or SQL-related problem occurs. |
ClassNotFoundException |
An application attempts to load a class by name but cannot find its definition. |
InterruptedException |
A waiting or blocking operation is interrupted. |
import java.io.FileReader;
import java.io.IOException;
public class FileExample {
public static void main(String[] args) {
try {
FileReader reader = new FileReader("sample.txt");
reader.close();
System.out.println("File opened successfully.");
} catch (IOException e) {
System.out.println("Unable to read the file.");
}
}
}The file may not exist or may not be accessible. The program handles the possible IOException instead of allowing it to propagate uncaught.
Unchecked exceptions include subclasses of RuntimeException. The compiler does not require these exceptions to be caught or declared with throws. They often indicate invalid operations, incorrect assumptions, or invalid data encountered during execution.
| Exception | Cause | Prevention |
|---|---|---|
ArithmeticException |
Invalid integer arithmetic, such as division by zero. | Validate the divisor. |
NullPointerException |
Dereferencing a null reference. | Validate references and design null handling carefully. |
ArrayIndexOutOfBoundsException |
Using an array index outside its valid range. | Check the index against array bounds. |
NumberFormatException |
Parsing text that is not a valid number. | Validate input and handle parsing failures. |
IllegalArgumentException |
Passing an inappropriate argument to a method. | Validate method arguments. |
ClassCastException |
Attempting an incompatible reference type cast. | Use appropriate types and check before casting when necessary. |
public class NumberExample {
public static void main(String[] args) {
String value = "abc";
try {
int number = Integer.parseInt(value);
System.out.println(number);
} catch (NumberFormatException e) {
System.out.println("Please enter a valid integer.");
}
}
}Output:
Please enter a valid integer.| Feature | Checked Exception | Unchecked Exception |
|---|---|---|
| Compiler enforcement | Must be caught or declared when it can propagate out of a method | No catch-or-declare requirement |
| Class hierarchy | Subclass of Exception that is not a subclass of RuntimeException |
Subclass of RuntimeException |
| Typical examples | IOException, SQLException |
NullPointerException, ArithmeticException |
| Common approach | Handle or declare the expected failure | Prevent invalid operations and handle where recovery is useful |
Java provides several keywords and constructs for handling exceptional situations. These include try, catch, finally, throw, and throws.
The try block contains statements that may throw exceptions. It must be followed by at least one catch block or a finally block, or both.
try {
int result = 10 / 2;
System.out.println(result);
} catch (ArithmeticException e) {
System.out.println("Arithmetic problem occurred.");
}The catch block defines how to respond when an exception matching its type is thrown from the associated try block.
try {
int number = Integer.parseInt("hello");
} catch (NumberFormatException e) {
System.out.println("Invalid numeric input.");
}The finally block is used for cleanup actions. It normally executes whether the try block completes normally or an exception is thrown, even when a matching catch handles the exception.
try {
System.out.println("Processing data.");
} catch (Exception e) {
System.out.println("An exception occurred.");
} finally {
System.out.println("Cleanup step completed.");
}Note: The finally block is not an absolute guarantee under every circumstance, such as abrupt JVM termination. For resources implementing AutoCloseable, prefer try-with-resources where suitable.
The throw keyword explicitly throws a throwable object. It is useful when a program detects an invalid condition that should be reported to the caller.
public class AgeCheck {
static void checkAge(int age) {
if (age < 18) {
throw new IllegalArgumentException("Age must be 18 or above.");
}
System.out.println("Access granted.");
}
public static void main(String[] args) {
checkAge(20);
}
}Output:
Access granted.If the method is called with an age below 18, it throws an IllegalArgumentException.
The throws keyword appears in a method declaration to identify exceptions that may propagate to the caller. It is commonly used when a method allows the caller to handle a checked exception.
import java.io.FileReader;
import java.io.IOException;
public class FileExample {
static void openFile() throws IOException {
FileReader reader = new FileReader("sample.txt");
reader.close();
}
public static void main(String[] args) {
try {
openFile();
} catch (IOException e) {
System.out.println("File operation failed.");
}
}
}| Feature | throw | throws |
|---|---|---|
| Purpose | Explicitly throws an exception object. | Declares exception types that may propagate from a method or constructor. |
| Location | Inside a method, constructor, or block. | In a method or constructor declaration. |
| Followed by | A throwable object. | One or more exception types. |
| Example | throw new IllegalArgumentException("Invalid"); |
void read() throws IOException |
A single try block can be followed by multiple catch blocks to handle different exception types separately. More specific exception types must appear before broader types that would otherwise catch them first.
public class MultipleCatchDemo {
public static void main(String[] args) {
try {
String text = "abc";
int number = Integer.parseInt(text);
System.out.println(100 / number);
} catch (NumberFormatException e) {
System.out.println("The text is not a valid integer.");
} catch (ArithmeticException e) {
System.out.println("Division by zero is not allowed.");
} catch (Exception e) {
System.out.println("An unexpected exception occurred.");
}
}
}Output:
The text is not a valid integer.The final catch (Exception e) is broader than the previous catches. It must appear after the more specific exception handlers.
Java's Error class represents serious conditions that ordinary applications generally should not try to recover from through routine exception handling.
OutOfMemoryError may occur when the Java Virtual Machine cannot allocate more memory for an object and garbage collection cannot free enough space.
// Conceptual example only.
// Repeatedly allocating large objects without releasing references
// can exhaust available heap memory.Prevention and diagnosis:
StackOverflowError may occur when a thread's call stack becomes exhausted, often because of infinite or excessively deep recursion.
public class StackExample {
static void repeat() {
repeat();
}
public static void main(String[] args) {
repeat();
}
}This program repeatedly calls repeat() without a stopping condition and can cause a StackOverflowError.
Prevention: Ensure recursive methods have correct base cases. Use iteration when it is more appropriate than deep recursion.
LinkageError represents problems that occur while linking classes, such as certain incompatible class definitions or missing dependencies at runtime.
Prevention: Keep dependencies compatible, use consistent build configurations, and verify that the expected classes and libraries are available at runtime.
Exception propagation occurs when a method does not handle an exception and the exception moves back through the call stack until a suitable handler is found. If no matching handler is found, the exception becomes uncaught for that thread.
public class PropagationDemo {
static void methodA() {
int result = 10 / 0;
}
static void methodB() {
methodA();
}
public static void main(String[] args) {
try {
methodB();
} catch (ArithmeticException e) {
System.out.println("Exception handled in main.");
}
}
}Output:
Exception handled in main.The exception originates in methodA(), passes through methodB(), and is handled in main().
Try-with-resources is a Java language feature that automatically closes resources implementing AutoCloseable when the statement completes. It is commonly used with files, streams, and database resources.
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
public class ResourceDemo {
public static void main(String[] args) {
try (BufferedReader reader =
new BufferedReader(new FileReader("sample.txt"))) {
System.out.println(reader.readLine());
} catch (IOException e) {
System.out.println("Unable to read the file.");
}
}
}The reader is automatically closed when execution leaves the try-with-resources statement, including when an exception occurs during the operation.
Java allows developers to create custom exception classes to represent application-specific problems. For example, a banking application might define an exception for an invalid withdrawal amount.
class InvalidAmountException extends Exception {
public InvalidAmountException(String message) {
super(message);
}
}
public class BankAccount {
static void withdraw(double amount) throws InvalidAmountException {
if (amount <= 0) {
throw new InvalidAmountException(
"Withdrawal amount must be positive."
);
}
System.out.println("Withdrawal request accepted.");
}
public static void main(String[] args) {
try {
withdraw(-100);
} catch (InvalidAmountException e) {
System.out.println(e.getMessage());
}
}
}Output:
Withdrawal amount must be positive.Because InvalidAmountException extends Exception directly, it is a checked exception. A custom unchecked exception can instead extend RuntimeException.
Exception everywhere.catch blocks.AutoCloseable.Error unless there is a specific, well-justified reason.InterruptedException if the interruption cannot be propagated.| Mistake | Why It Is a Problem | Better Approach |
|---|---|---|
| Catching every exception without distinction | Hides the actual cause and makes recovery difficult. | Catch specific exception types and respond appropriately. |
| Using an empty catch block | Failures may go unnoticed. | Handle the failure or log useful diagnostic information. |
| Confusing Error with a compilation error | They refer to different concepts. | Distinguish compiler diagnostics from java.lang.Error. |
| Placing a broad catch before a specific catch | The specific catch becomes unreachable. | Place more specific exception handlers first. |
| Throwing exceptions without useful messages | Diagnosis becomes more difficult. | Include meaningful context in the exception message. |
| Forgetting to close a resource | Files or other resources may remain open. | Use try-with-resources where possible. |
| Using exceptions for ordinary conditions | Code becomes harder to understand and may be inefficient. | Use normal condition checks for expected, routine cases. |
| Ignoring an interrupted thread | Cancellation or shutdown signals may be lost. | Propagate InterruptedException or restore the interrupt status when appropriate. |
ArithmeticException.IOException.NumberFormatException and ArithmeticException.InvalidAgeException for an age validation program.Objective: Create a Java program that accepts student marks, validates the input, and handles invalid values using exception handling.
import java.util.Scanner;
public class StudentMarksValidator {
static void validateMarks(int marks) {
if (marks < 0 || marks > 100) {
throw new IllegalArgumentException(
"Marks must be between 0 and 100."
);
}
}
public static void main(String[] args) {
try (Scanner scanner = new Scanner(System.in)) {
System.out.print("Enter marks: ");
String input = scanner.nextLine();
try {
int marks = Integer.parseInt(input);
validateMarks(marks);
System.out.println("Valid marks: " + marks);
} catch (NumberFormatException e) {
System.out.println("Please enter a whole number.");
} catch (IllegalArgumentException e) {
System.out.println(e.getMessage());
}
}
}
}Sample Input:
Enter marks: 85Output:
Valid marks: 85If the user enters text such as hello, the program displays a numeric-input message. If the user enters a number outside the range 0 to 100, it displays the validation message.
Answer: An exception is an object that signals an abnormal condition during program execution and interrupts the normal execution path.
Answer: An Error generally represents a serious runtime or environment-related condition. An Exception represents a condition that an application may be able to handle.
Answer: It is the root class of Java's throwable hierarchy. Both Error and Exception extend Throwable.
Answer: It is an exception other than RuntimeException and its subclasses for which Java enforces a catch-or-declare requirement when it can propagate out of a method or constructor.
Answer: An unchecked exception is a subclass of RuntimeException. The compiler does not require it to be caught or declared.
Answer: The try block contains code that may throw an exception, while the catch block handles a matching exception.
Answer: The finally block is commonly used for cleanup code that should normally execute whether the try block completes normally or exceptionally.
Answer: throw explicitly throws an exception object. throws declares exception types that a method or constructor may allow to propagate.
Answer: It is the process by which an exception moves up the call stack until a matching handler is found or the exception remains uncaught.
Answer: It is a programmer-defined exception class that represents a specific application condition.
Answer: It is a Java construct that automatically closes resources implementing AutoCloseable when the statement finishes.
Answer: Usually not as part of ordinary application recovery. Errors often indicate serious conditions that require diagnosis, and catching them does not necessarily restore a safe application state.
Throwable is the root of the exception hierarchy.Error and Exception are direct subclasses of Throwable.try, catch, and finally.throw and throws.NullPointerException and NumberFormatException.Errors and exceptions are fundamental to writing reliable Java applications. Understanding the difference between compilation problems, logical errors, runtime exceptions, and serious Java errors helps developers diagnose failures and choose the right response.
Java's exception-handling mechanism provides tools such as try, catch, finally, throw, and throws to manage exceptional conditions. By using these constructs carefully, validating input, cleaning up resources, and designing meaningful custom exceptions, developers can build applications that are easier to maintain and troubleshoot.
Continue Learning: Explore the Core Java Training Course, register for a course demo, or visit the JustAcademy website.
