An Exception is an unwanted or unexpected event that occurs during the execution of a program and disrupts the normal flow of the program that lead to abnormal termination. It occurs when unexpected events take place, like accessing an invalid index, dividing by zero, or trying to open a file that does not exist. To handle such events we use exceptions to avoid unexcepted termination of the program.
Exception handling in Java allows developers to handle runtime errors effectively by using structures like try-catch block, finally block, throwing Exceptions, Custom Exception handling, etc.
try-catch Block
A try-catch block in Java is a program block to handle exception where try block contains code that is expected to throw an exception and the catch block is used to handle the exceptions if in case it occurs.
Syntax :
try {
// Code that may throw an exception
} catch (ExceptionType e) {
// Code to handle the exception
}Handling Multiple Exception
We can handle multiple type of exceptions in Java by using multiple catch blocks, each catching a different type of exception.
Syntax :
try {
// Code that may throw an exception
} catch (ArithmeticException e) {
// Code to handle the exception
} catch(ArrayIndexOutOfBoundsException e){
//Code to handle the another exception
}catch(NumberFormatException e){
//Code to handle the another exception
}finally Block
The finally Block is used to execute important code regardless of whether an exception occurs or not.
Syntax :
try {
// Code that may throw an exception
} catch (ExceptionType e) {
// Code to handle the exception
}finally{
// cleanup code
}Java Program For try-catch and finally
public class JavaProgTryCatch {
public static void main(String args[]) {
int arr[] =new int[3];
try {
arr[2] = 10;
System.out.println(arr[2]);
System.out.println(arr[4]);
} catch (ArrayIndexOutOfBoundsException e) {
System.out.println("Oops something went wrong.");
} finally {
arr[0] = 5;
System.out.println("First element value: " + arr[0]);
System.out.println("The finally block is reached");
}
}
}Output :
10
Oops something went wrong.
First element value: 5
The finally block is reacedJava throw keyword
The throw keyword in Java is used to explicitly throw an exception from a method or any block of code. We can throw either checked or unchecked exception. The throw keyword is mainly used to throw custom exceptions.
Syntax :
throw Instance // Exception Class
throw new ArithmeticException("/ by zero");Java Program For throw keyword
public class JavaProgThrow {
static void validateAge(int age) {
if (age < 18) {
throw new ArithmeticException("Permission denied - Age must be at least 18 years old.");
}
else {
System.out.println("Access granted!");
}
}
public static void main(String[] args) {
validateAge(20);
System.out.println("/n");
validateAge(12);
}
}Output :
Access granted!
Exception in thread "main" java.lang.ArithmeticException: Permission denied - Age must be at least 18 years old.
at JavaProgThrow.validateAge(JavaProgThrow.java:7)
at JavaProgThrow.main(JavaProgThrow.java:16)Java throws keyword
If a method does not handle a checked exception, the method must declare it using the throws keyword. The throws keyword appears at the end of a method’s signature. The caller to these methods has to handle the exception using a try-catch block.
Syntax :
returnType methodName(parameters) throws ExceptionType1, ExceptionType2 {
// method body
}Java Program For throws keyword
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
public class JavaProgThrows {
public static void searchFile() throws IOException {
File newFile=new File("test.txt");
FileInputStream stream=new FileInputStream(newFile);
}
public static void main(String[] args) {
try{
searchFile();
} catch(IOException e){
System.out.println(e);
}
}
}
Output :
java.io.FileNotFoundException: test.txt (The system cannot find the file specified)Java Exception Hierarchy
All exception and error types are subclasses of the class Throwable, which is the base class of the hierarchy and a direct subclass of the Object class. Throwable has two direct subclasses – Exception and Error
Exception class is used for exceptional conditions that programs should catch. Examples of exceptions include ArithmeticException, NullPointerException, etc.
Error is used by the Java run-time system(JVM) to indicate errors having to do with the run-time environment itself(JRE). Examples of error include OutOfMemoryError, NoClassDefFoundError, StackOverflowError,etc.
Types of Java Exceptions
In Java, exceptions are categorized into two main types: Built-in Exceptions and User-Defined Exceptions. Additionally, there is a third category known as errors.
1) Built-in Exceptions
- Checked Exception
- Unchecked Exception
2) User-Defined Exceptions
Built-in Exception
Build-in Exception are pre-defined exception classes provided by Java libraries to handle common errors during program execution.
Checked Exceptions
Checked exceptions are called compile-time exceptions because these exceptions are checked at compile-time by the compiler. Java code containing any checked exceptions won’t compile. When you try to run such code, the compiler warns you about the presence of the checked exception. Examples of Checked Exception are listed below:
ClassNotFoundException: It occurs when the program tries to load a class at runtime but the class is not found because Java Virtual Machine cannot locate a required class, typically triggered by functions like Class.forName() or ClassLoader.loadClass().
InterruptedException: This exception is thrown when a thread is paused and another thread interrupts it.
IOException: It occurs when input/output operation fails
InstantiationException: This exception is thrown when the program tries to create an object of a class but fails because the class is abstract, an interface, or has no default constructor.
SQLException: It occurs when there’s an error with the database.
FileNotFoundException: It is thrown when the program tries to open a file that doesn’t exist
Unchecked Exceptions
Unchecked exceptions are issues that occur at runtime. They are also called uncaught or runtime exceptions. If a program throws an unchecked exception, and even if we didn’t handle or declare it, the program would not give a compilation error. Examples of Unchecked Exception are listed below:
ArithmeticException: It is thrown when there’s an illegal math operation.
ClassCastException: It is thrown when you try to cast an object to a class it does not belong
to.
NullPointerException: It is thrown when you try to use a null object.
ArrayIndexOutOfBoundsException: This occurs when we try to access an array element with an invalid index.
ArrayStoreException: This occurs when you store an object of the wrong type in an array.
IllegalThreadStateException: It is thrown when a thread operation is not allowed in its current state
Common Known Scenarios of Java Unchecked Exceptions
Java Program For ArithmeticException
public class ProgArithmeticException {
public static void main(String[] args) {
int dividend = 20;
int divisor = 0;
try {
int result = dividend / divisor; // Division by zero
System.out.println("Result: " + result);
} catch (ArithmeticException e) {
System.out.println("Error: Dude are your crazy division by zero isn't allowed.");
}
}
}Output :
Error: Dude are your crazy division by zero isn't allowed.Java Program For NullPointerException
public class ProgNullPointerException {
public static void main(String[] args) {
String str = null;
try {
int length = str.length();
System.out.println("Length of the string: " + length);
} catch (NullPointerException e) {
System.out.println("Error: Dude Your String in Null");
}
}
}Output :
Error: Dude Your String in NullJava Program For NumberFormatException
public class ProgNumberFormatException {
public static void main(String[] args) {
String str = "sachin";
try {
int num = Integer.parseInt(str);
System.out.println("Parsed number: " + num);
} catch (NumberFormatException e) {
System.out.println("Error: Dude Compiler can't parse the string as an integer.");
}
}
}Output :
Error: Dude Compiler can't parse the string as an integer.Java Program For ArrayIndexOutOfBoundsException
public class ProgArrayIndexOutOfBoundsException {
public static void main(String[] args) {
int[] numbers = {10, 20, 30, 40, 50};
try {
int value = numbers[6];
System.out.println("Value at index 6 " + value);
} catch (ArrayIndexOutOfBoundsException e) {
System.out.println("Error: Array Index is out of bounds");
}
}
}Output :
Error: Array Index is out of boundsCommon Known Scenarios of Java Unchecked Exceptions
Java Program For SQLException
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
public class JavaProgSQLException {
public static void main(String[] args) throws ClassNotFoundException {
Connection connection = null;
try {
Class.forName("com.mysql.jdbc.Driver");
connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/your_database", "username", "password");
// replace username and password with your sql username and password
String sql = "SELECT * FROM product_";
// This will give SQLException for table name misspelled
Statement stmt = connection.createStatement();
ResultSet rset = stmt.executeQuery(sql);
while (rset.next()) {
System.out.print("ID: " + rset.getString(1));
System.out.print(" Product: " + rset.getString(2));
System.out.println(" Price: " + rset.getFloat(3));
}
} catch (SQLException e) {
handleSQLException(e);
}
}
private static void handleSQLException(SQLException e) {
int errorCode = e.getErrorCode();
String sqlState = e.getSQLState();
String errorMessage = e.getMessage();
System.out.println("SQL Error Code: " + errorCode);
System.out.println("SQL State: " + sqlState);
System.out.println("Error Message: " + errorMessage);
e.printStackTrace();
}
}Output: This code will generate a SQLException.Java Program For IOException
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
public class JavaProgIOException {
private static String filepath = "D:/FolderName/javaprograms.txt";
public static void main(String[] args) {
BufferedReader br1 = null;
String curline;
try {
br1 = new BufferedReader(new FileReader(filepath));
while ((curline = br1.readLine()) != null) {
System.out.println(curline);
}
} catch (IOException e) {
System.err.println("IOException found :" + e.getMessage());
} finally {
try {
if (br1 != null)
br1.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}Output: This code will generate an IOException.Java Program For ClassNotFoundException
public class JavaProgClassNotFound {
// private static final String CLASS_TO_LOAD = "java.util.Scanner";
private static final String CLASS_TO_LOAD = "main.java.Utils";
public static void main(String[] args) {
try {
Class loadedClass = Class.forName(CLASS_TO_LOAD);
System.out.println("Class " + loadedClass + " found!");
} catch (ClassNotFoundException ex) {
System.err.println("ClassNotFoundException was found: " + ex.getMessage());
ex.printStackTrace();
}
}
}Output: This code will generate a ClassNotFoundException.User-Defined Exception
Java provides us the facility to create our own exceptions which are basically derived classes of Exception and besides using the Built-in Exception, if we want, we can create our Exceptions with messages and conditions for JVM to understand when to throw them. User-defined Exceptions are also called custom exceptions since they are not predefined and can be altered by the programmer. It is a beneficial tool to debug programs and handle edge cases without terminating the execution of the whole code.Java custom exceptions are used to customize the exception according to user needs. User-Defined Custom Exception or custom exception helps you create your own exception class and throwing that exception using the ‘throw’ keyword.
Creating our own Exception is known as a custom exception in Java or user-defined exception in Java.
Java Program For User-Defined Custom Exception
public class ProgException extends Exception {
public ProgException(String message) {
super(message);
}
}
public class ProgUserDefineCustomExcep {
public static void main(String args[]) {
try {
throw new ProgException("This is a Custom Exception");
}
catch (ProgException e) {
System.out.println("Exception Caught"); // Catch and print message
System.out.println(e.getMessage());
}
}
}Output :
Exception Caught
This is a Custom ExceptionJava Custom Exception
A Java Custom Exception is an exception defined by the user to handle specific programming requirements. These exceptions extend either the Exception class (for checked exceptions) or the RuntimeException class (for unchecked exceptions).
Types of Custom Exceptions
- Checked Exceptions: It extends the Exception class. and it must be declared in the throws clause of the method signature.
- Unchecked Exceptions: It extends the RuntimeException class.
Java Program For User-Defined Checked Exception
// Custom Checked Exception
public class InvalidAgeException extends Exception {
public InvalidAgeException(String m) {
super(m); //message
}
}
// Using the Custom Exception
public class ProgUserDefineCheckExcep {
public static void validate(int userAge)
throws InvalidAgeException {
if (userAge < 18) {
throw new InvalidAgeException("Age must be 18 or above.");
}
System.out.println("Valid age is : " + userAge);
}
public static void main(String[] args) {
try {
validate(12);
} catch (InvalidAgeException e) {
System.out.println("Code Has Caught An Exception: " + e.getMessage());
}
}
}Output :
Code Has Caught An Exception: Age must be 18 or above.Java Program For User-Defined Unchecked Exception
// Custom Unchecked Exception
public class DivideByZeroException extends RuntimeException {
public DivideByZeroException(String message) {
super(message);
}
}
// Using the Custom Exception
public class ProgUserDefineUncheckExcep {
public static void divide(int num1, int num2) {
if (num2 == 0) {
throw new DivideByZeroException("Division by zero is not allowed.");
}
System.out.println("Result is : " + (num1 / num2));
}
public static void main(String[] args) {
try {
divide(10, 0);
} catch (DivideByZeroException e) {
System.out.println("Code Has Caught Exception: " + e.getMessage());
}
}
}Output :
Code Has Caught Exception: Division by zero is not allowed.Java Exception Methods :
Important methods available in the Throwable class are as follows:
public String getMessage() – This method returns the message String of Throwable and the message can be provided while creating the exception through its constructor.
public String getLocalizedMessage() – This method is provided so that subclasses can override it to provide a locale-specific message to the calling program. The Throwable class implementation of this method uses the getMessage() method to return the exception message.
public synchronized Throwable getCause() – This method returns the cause of the exception or null if the cause is unknown.
public String toString() – This method returns the information about Throwable in String format, the returned String contains the name of the Throwable class and localized message.
public void printStackTrace() – This method prints the stack trace information to the standard error stream, this method is overloaded, and we can pass PrintStream or PrintWriter as an argument to write the stack trace information to the file or stream.
Error :
Errors represent irrecoverable conditions that are not expected to be caught under normal circumstances. They are typically caused by issues outside the control of the application, such as system failures or resource exhaustion. Errors are not meant to be caught or handled by application code. Examples of errors include:
OutOfMemoryError: It occurs when the Java Virtual Machine (JVM) cannot allocate enough memory for the application.
StackOverflowError: It is thrown when the stack memory is exhausted due to excessive recursion.
NoClassDefFoundError: It indicates that the JVM cannot find the definition of a class that was available at compile-time.
In java, both Errors and Exceptions are the subclasses of java.lang.Throwable class. Error refers to an illegal operation performed by the user which results in the abnormal working of the program. Programming errors often remain undetected until the program is compiled or executed. Some of the errors inhibit the program from getting compiled or executed. Thus errors should be removed before compiling and executing. In Java there are of four types errors:
- Run-time
- Compile-time
- Logical
- Syntax
Runtime Error:
Runtime errors occur during the program execution. Runtime errors are discovered when the user enters an invalid data or data which is not relevant. Runtime errors occur when a program does not contain any syntax errors but asks the computer to do something that the computer is unable to reliably do. During compilation, the compiler has no technique to detect these kinds of errors. It is the JVM (Java Virtual Machine) that detects it while the program is running. To handle the error during the run time we can put our error code inside the try block and catch the error inside the catch block.
Common causes of runtime errors in Java include:
ArithmeticException: Division by zero.
ArrayIndexOutOfBoundsException: Accessing an array element with an invalid index.
NullPointerException: Attempting to use a null reference.
ClassCastException: Trying to cast an object to an incompatible type.
IllegalArgumentException: Passing an invalid argument to a method.
NoSuchElementException: Occurs when trying to access an element that does not exist in a collection.
OutOfMemoryError: Insufficient memory to create a new object.
InputMismatchException: Occurs when the user enters an input that does not match the expected data type.
Java Program For Run Time Error :
class DivByZero {
public static void main(String args[])
{
int a = 12;
int b = 4;
int c = 0;
int res1 = a / b;
int res2 = a / c; // This will throw an ArithmeticException
System.out.println("Resultant Value of res1 is " + res1);
System.out.println("Resultant Value of res2 is " + res2);
}
}Output :
Exception in thread "main" java.lang.ArithmeticException: / by zero
at JavaProgRuntimeError.main(JavaProgRuntimeError.java:11)Compile Time Error:
Compile-time errors in Java occur when the code violates the syntax or semantic rules of the language, preventing the code from being compiled into bytecode. These errors are detected by the Java compiler before the program is executed,thus are known as compile-time errors. Common causes include:
Most frequent Compile-Time errors are:
- Mismatched or missing brackets,parenthesis or braces
- Printing the value of variable without declaring it
- Missing semicolon at the end of statements.
- Incorrect use of keywords or operators.
- Misspelled variable or method names.
Java Program For Compile Time Error :
public class CompileTimeErrorExample {
public static void main(String[] args) {
int x = 20;// Missing semicolon
System.out.println(x);// Missing semicolon
}
}Output :
Exception in thread "main" java.lang.Error: Unresolved compilation problems:
Syntax error, insert ";" to complete BlockStatements
Syntax error, insert ";" to complete Statement
at JavaProgCompileError.main(JavaProgCompileError.java:5)Logical Error:
A logic error is when your program compiles and executes, but returns an incorrect result or no output. These errors are detected neither by the compiler nor by JVM. The Java system has no idea about logical error, so it provides no additional information for it. Logical errors are also called Semantic Errors and are caused due to bad logic used by a programmer while coding. Example of Logical Error is when if a programmer accidentally adds two variables when he or she meant to divide them, the program will give no error and will execute successfully but with an incorrect result.
Java Program For Logical Error :
public class JavaProgLogicalError {
public static void main(String args[])
{
int num1 = 3, num2 = 10, num3 = 5;
System.out.println("Finding the largest number \n");
if (num1 > num2 && num1 > num3)
System.out.println( "num1 " + num1 + " is the largest Number");
else if (num2 > num1 && num2 > num3)
System.out.println( "num2 "+ num2 + " is the smallest Number");
// here correct message should be num2 is the larget Number
else
System.out.println( "num1 " + num3 + " is the largest Number");
}
}Output :
Finding the largest number
num2 10 is the smallest NumberSyntax Error:
Spelling or grammatical mistakes are syntax errors and can be removed with the help of the compiler. Syntax error include an uninitialized variable, an undefined variable,missing a semicolon, etc.
int x, y;
x = 20 // missing semicolon (;)
z = x * y; // z is undefined,while y in uninitialized.Syntax errors are grammatical errors whereas, logical errors are errors arising out of an incorrect meaning.