Java - Exception Types

There are many predefined Exceptions available in java which are mentioned below, these are some of the common exceptions seen.

Custom Exception (Declaring you own)

You can create your own exceptions in Java. Keep the following points in mind when writing your own exception classes:

• All exceptions must be a child of Throwable.
• If you want to write a checked exception that is automatically enforced by the Handle or Declare Rule, you need to extend the Exception class.
• If you want to write a runtime exception, you need to extend the RuntimeException class.

We can define our own Exception class as below:

class MyException extends Exception{
}

You just need to extend the Exception class to create your own Exception class. These are considered to be checked exceptions. The following InsufficientFundsException class is a user-defined exception that extends the Exception class. An exception class is like any other class, containing useful fields and methods.

//Declaring a user defined Exception 
public class InsufficientFundsException extends Exception {
	
	private double amount;
	
	public InsufficientFundsException(double amount)
	{
	   this.amount = amount;
	}
	
	public double getAmount()
	{
	   return amount;
	}
}


public class AccessFund {
	
	private double balance;
	private int accountNo;
	
	public AccessFund(int accountNo, double balance) {
		this.accountNo = accountNo;
		this.balance = balance;
	}
	
	public void depositAmount(double amount){
		balance = balance + amount;
	}
	
	public void withdraw (double amount) throws InsufficientFundsException{
		if (balance > amount){
			balance = balance - amount;
			System.out.println("Amount withdrawn = " + amount + " Now the current balance is " + balance);
		}
		else
		{
			double requiredAmount = amount - balance;
			throw new InsufficientFundsException(requiredAmount);		
		}
	}
}


public class Test {

	public static void main(String[] args){
		AccessFund newAccount = new AccessFund(1, 5000);
		
		try {
			newAccount.depositAmount(1000);
			newAccount.withdraw(2000);
			System.out.println("trying to withdraw 5000 now");
			newAccount.withdraw(5000);
		} catch (InsufficientFundsException e) {
			System.out.println(e.getAmount() + " money required");
		}
	}
}

In the above code we have declared a class which has two methods depositAmount and withdraw, but if we try to withdraw money more than the current balance then the method will throw an InsufficientFundsException.

Amount withdrawn = 2000.0 Now the current balance is 4000.0
trying to withdraw 5000 now
1000.0 money required

Checked vs Unchecked Exceptions

In Java the Exception are divided primarily in two different categories

• Checked Exceptions
• Unchecked Exceptions (also known as Runtime Exceptions)

Checked Exceptions

A checked exception is an exception that is typically a user error or a problem that cannot be foreseen by the programmer. For example, if a file is to be opened, but the file cannot be found, an exception occurs. These exceptions cannot simply be ignored at the time of compilation.

Some of the commonly used checked exceptions are :-

A custom checked exception

public class CheckedException extends Exception {
    
    public CheckedException(String errorMessage) {
        super(errorMessage);
    }
}

Unchecked Exceptions

An unchecked or runtime exception is an exception that occurs that probably could have been avoided by the programmer. As opposed to checked exceptions, runtime exceptions are ignored at the time of compilation.

Most commonly faced runtime exceptions are :-

A custom un-checked exception

public class UnCheckedException extends RuntimeException {
    
    public CheckedException(String errorMessage) {
        super(errorMessage);
    }
}

If you liked this article, you can buy me a coffee