Updated April 7, 2023
Introduction to Java User-Defined Exception
Java user-defined exception is a custom exception created and throws that exception using a keyword ‘throw’. It is done by extending a class ‘Exception’. An exception is a problem that arises during the execution of the program. In Object-Oriented Programming language, Java provides a powerful mechanism to handle such exceptions. Java allows to create own exception class, which provides own exception class implementation. Such exceptions are called user-defined exceptions or custom exceptions. Let us dig deeper and look at how user-defined exceptions are created in Java, its syntax, if any, and how it is implemented by solving some examples.
Syntax:
We do not have any particular syntax for Java user-defined exception; we will see how to create a User-defined exception.
Below is the code which will help to Create a User-defined exception class,
class SampleException{
public static void main(String args[]){
try{
throw new UserException(<value>); // used to create new exception and throw
}
catch(Exception e){
System.out.println(e);
}
}
}
class UserException extends Exception{
// code for exception class
}Here, while creating an exception class, it needs to be extended from java. lang.Exception.
An exception is an event that leads to sudden termination of the program during execution at runtime.
Examples
Let us discuss examples of Java User-Defined Exception.
Example #1: Simple Program
class SampleException{
public static void main(String args[]){
try{
throw new UserException(400);
}
catch(UserException e){
System.out.println(e) ;
}
}
}
class UserException extends Exception{
int num1;
UserException(int num2) {
num1=num2;
}
public String toString(){
return ("Status code = "+num1) ;
}
}Output:
Keyword ‘throw’ is used to create a new Exception and throw it to catch block.
Example #2: For Invalid ID
class EmployeeException extends Exception
{
public EmployeeException(String s)
{
super(s);
}
}
class SampleEmp
{
void empIDCheck(int EmpID) throws EmployeeException{
if(EmpID<=0 || EmpID>999){
throw new EmployeeException("Invalid Employee ID");
}
}
public static void main(String args[])
{
SampleEmp emp = new SampleEmp();
try
{
emp.empIDCheck(0);
}
catch (EmployeeException e)
{
System.out.println("Exception caught");
System.out.println(e.getMessage());
}
}
}Output:
If we are not using throw class here, it would give a compilation error as ‘Unhandled Exception in method’.
Example #3: For value lesser than defined value
class SampleException extends Exception
{
private int e;
SampleException(int num1)
{
e = num1;
}
public String toString()
{
return "(" + e +") is less than Ten";
}
}
class Demo1
{
static void sum(int num,int num1) throws SampleException
{
if(num1<10)
{
throw new SampleException(num1);
}
else
{
System.out.println(num+num1);
}
}
public static void main(String[] args)
{
try
{
sum(-5, 4);
}
catch(SampleException e1)
{
System.out.println(e1);
}
}
}Output:
Example #4: To check ID validity
class IDNotValid extends Exception
{
public IDNotValid(String s) {
super(s);
}
}
class Demo
{
static void find(int array[], int id) throws IDNotValid
{
boolean stdFlag = false;
for (int i = 0; i < array.length; i++) {
if(id == array[i])
stdFlag = true;
}
if(!stdFlag)
{
throw new IDNotValid("ID is not Valid!");
}
else
{
System.out.println("ID is Valid!");
}
}
public static void main(String[] args)
{
try
{
find(new int[]{101, 102, 103, 104, 105, 106, }, 108);
}
catch(IDNotValid e)
{
System.out.println(e);
}
}
}Output:
Here we are generating our own exception implementation.
There are advantages in using these user-defined exceptions; it allows users to throw an exception which wants user wants to mean. Users can also reuse any existing application; any piece of code that catches exception deals with a possibility of actual exception was not thrown by code but by some other third-party code.
Users can separate Error handling code from Regular code, grouping and differentiating error types.
There are some rules also to create Exception classes.
- Constructor: This is not mandatory in creating any constructor in the custom exception class. Providing parameterized constructors in the custom exception class is a good practice.
- Naming Convention: All exception classes are provided by the JDK end; hence, a custom exception should follow a naming convention.
- Extends Exception class: If the user is creating a custom exception class, then the user has to extend the Exception class.
With this, we shall conclude the topic ‘Java user exception class’. Almost all general exceptions in Java are provided that happen in Java programming. We have seen the creation of user-defined exception classes and seen few examples of user-defined exceptions. User need not implement anything inside the class; no methods are required, and also override the toString() function to display customized messages.
Recommended Articles
This is a guide to Java User-Defined Exception. Here we discuss the Introduction, syntax, How to create a User-Defined Exception? examples with code implementation. You may also have a look at the following articles to learn more –
