Exception Dealing with in Java with Examples | 2023

Exception dealing with in java is among the highly effective mechanisms to deal with runtime errors attributable to exceptions. Exception dealing with performs an vital position in software program improvement. This text helps you perceive java exception, exception in java, java exception dealing with, java exception hierarchy, forms of exception in java, and plenty of extra.

What’s Exception Dealing with in Java?

Exception dealing with in java helps in minimizing exceptions and helps in recovering from exceptions. It is among the highly effective mechanisms to deal with runtime exceptions and makes it bug-free. Exception dealing with helps in sustaining the move of this system. An exception dealing with is outlined as an irregular situation that will occur at runtime and disturb the conventional move of this system.

Additionally Learn: Java Tutorial for novices

What’s an Exception?

An expectation is an sudden occasion that happens whereas executing this system, that disturbs the conventional move of the code.

Exception dealing with in java with an instance:

Let’s say,

assertion
assertion
assertion
exception ………… an exception occurred, then JVM will deal with it and can exit the prog.
assertion
assertion
assertion

For dealing with exceptions, there are 2 attainable approaches

1. JVM

If an exception isn’t dealt with explicitly, then JVM takes the accountability of dealing with the exception.

As soon as the exception is dealt with, JVM will halt this system and no extra execution of code will happen

import java.util.*;

class Essential {
    public static void primary (String[] args) {
        System.out.println(5/0);
        System.out.println("Finish of program!");
	}
}

Runtime Error:

 Exception in thread "primary" java.lang.ArithmeticException: / by zero
 at Essential.primary(File.java:5) 

2. Developer

Builders can explicitly write the implementation for dealing with the exception. As soon as an exception is dealt with, the conventional execution of code will proceed.

Preferable: deal with exceptions to make sure your code will get executed usually.

Java Exception Hierarchy

Exception Hierarchy – Following is the Exception Dealing with in Java dealing with hierarchy.

• Throwable –
  • It’s the root class for the exception hierarchy in java. 
  • It’s within the java.lang package deal.
• Error –
  • Subclass of Throwable.
  • Encompass irregular situation that’s out of 1’s management and is determined by the surroundings
  • They will’t be dealt with and can all the time end result within the halting of this system.
  • Eg: StackOverFlowError that may occur in infinite loop or recursion
• Exception –
  • Subclass of Throwable.
  • Encompass irregular situations that may be dealt with explicitly.
  • If one handles the exception then our code will proceed to execute easily.

Forms of exception in Java

• Checked Exceptions
  • These exceptions which are checked at compile-time includes checked exceptions.
  • They’re baby lessons of Exception aside from RuntimeException.
  • This system won’t compile if they don’t seem to be dealt with.
  • Instance: IOException, ClassNotFoundException, and so on.
• Unchecked Exceptions
  • These exceptions which are checked at runtime includes unchecked exceptions.
  • They’re baby lessons of RuntimeException.
  • They provide runtime errors if not dealt with explicitly.
  • Instance: ArithmeticException, NullPointerException and so on.

Distinction between Checked and Unchecked Exception

Java Exception Index

Java Exception Key phrases

Exception Dealing with in java is managed through 5 key phrases: attempt, catch, throw, throws, and eventually. Listed here are 5 key phrases which are utilized in dealing with exceptions in Java

Java Attempt-Catch Block

Attempt-catch syntax:

attempt{
}
catch(Exception e){
}

public class ExceptionDemo {
	public static void primary (String[] args) {
		int a=10;
		for(int i=3;i>=0;i--)
		   attempt{
		     System.out.println(a/i);  
		   }catch(ArithmeticException e){
		       System.out.println(e);
		   }
	}
}

Output:

3
5
10
java.lang.ArithmeticException: / by zero 

• attempt block accommodates the code that may throw an exception. Don’t write something additional in attempt as statements after the exception won’t get executed if the exception occurred. Attempt have to be instantly adopted by catch or lastly block.

public class ExceptionDemo {
	public static void primary (String[] args) {
		int a=10;
		for(int i=3;i>=0;i--)
		   attempt{
		     System.out.println(a/i);  
		   }
	}
}

Compile-time error:

prog.java:5: error: 'attempt' with out 'catch', 'lastly' or useful resource declarations
    attempt{
    ^
1 error 

• The catch block is used to catch the exception thrown by statements within the attempt block. The catch should observe attempt else it can give a compile-time error.

public class ExceptionDemo {
	public static void primary (String[] args) {
		int a=10;
		for(int i=3;i>=0;i--)
		   attempt{
		     System.out.println(a/i);  
		   }
		   System.out.println("between try to catch");
		   catch(ArithmeticException e){
		       System.out.println(e);
		   }
	}
}

Compile Time Error:

prog.java:5: error: 'attempt' with out 'catch', 'lastly' or useful resource declarations
    attempt{
    ^
prog.java:9: error: 'catch' with out 'attempt'
    catch(ArithmeticException e){
    ^
2 errors 

Issues to Keep in mind:

Don’t hold any code after the assertion which is susceptible to exception. As a result of if an exception occurred, it can right away soar to the catch or lastly block, ignoring all different statements within the attempt block.

class Essential {
	public static void primary (String[] args) {
         attempt
       {
             System.out.println(4/0);
	 //won't get printed
             System.out.println("finish of attempt!");
        }
catch(ArithmeticException e)
        {
            System.out.println("divide by 0");
        }
    }
}

Output:

divide by 0

• Whereas catching the exception within the catch block, both you possibly can have straight the category of exception or its superclass.

Instance: Actual Exception

class Essential {
	public static void primary (String[] args) {
        attempt{
            System.out.println(4/0);
           }
      
        //ArithmeticException 
        catch(ArithmeticException e){
            System.out.println("divide by 0");
        }
    }
}

Output:

divide by 0

Instance: Superclass of Actual Exception

class Essential {
	public static void primary (String[] args) {
        attempt{
            System.out.println(4/0);
           }
      
        //superclass of ArithmeticException 
        catch(Exception e){
            System.out.println("divide by 0");
        }
     }
}

Output:

divide by 0

Java A number of Catch Block

When you have a number of catches, you must keep the hierarchy from subclass to superclass.

Incorrect:

class Essential {
	public static void primary (String[] args) {
        attempt{
            System.out.println(4/0);
        }catch(Exception e)
        {
            System.out.println("Exception : divide by 0");
        }catch(ArithmeticException e)
        {
            System.out.println("ArithmeticException :divide by 0");
        }
	}
}

Compile-time error:

 prog.java:11: error: exception ArithmeticException has already been caught
        }catch(ArithmeticException e)
         ^
1 error 

Right:

class Essential {
	public static void primary (String[] args) {
        attempt{
            System.out.println(4/0);
        }catch(ArithmeticException e)
        {
            System.out.println("ArithmeticException : divide by 0");
        }catch(Exception e)
        {
            System.out.println("Exception : divide by 0");
        }
   }
}

Output:

ArithmeticException: Divide by 0

Java Nested Attempt

When there’s one other attempt block throughout the attempt block:

class Essential {
	public static void primary (String[] args) {
        attempt{
                attempt{
                    int[] a={1,2,3};
                    System.out.println(a[3]);
                }
   catch(ArrayIndexOutOfBoundsException e)
                {
                    System.out.println("Out of bounds");
                }
              System.out.println(4/0);
        }
       catch(ArithmeticException e)
        {
            System.out.println("ArithmeticException : divide by 0");
        }
	}
    }

Output:

Out of bounds
ArithmeticException: Divide by 0 

Observe – If we put code of outer attempt earlier than internal attempt, then if an exception occurred, it can ignore your complete internal try to transfer on to its catch block.

class Essential {
	public static void primary (String[] args) {
        attempt{
               System.out.println(4/0);
               attempt{
                    int[] a={1,2,3};
                    System.out.println(a[3]);
                }
   catch(ArrayIndexOutOfBoundsException e)
                {
                    System.out.println("Out of bounds");
                }
        }
       catch(ArithmeticException e)
        {
            System.out.println("ArithmeticException : divide by 0");
        }
	}
    }

Output:

ArithmeticException: Divide by 0

Java Lastly Block

Comprises code that have to be executed regardless of if an exception is thrown or not. It accommodates code of file launch, closing connections, and so on.

class Essential {
	public static void primary (String[] args) {
        attempt{
            System.out.println(4/0);
        }catch(Exception e)
        {
            System.out.println(e);       
        }
        lastly
        {
            System.out.println("lastly executed");
        }
        
       	        System.out.println("finish");
	}
}

Output:

java.lang.ArithmeticException: / by zero
lastly executed
finish 

Lastly, will execute even when we don’t deal with exceptions. Earlier than halting this system, JVM checks if there’s a “lastly” block.

class Essential {
	public static void primary (String[] args) {
        attempt{
            System.out.println(4/0);
            
        }lastly
        {
            System.out.println("cleansing.......");
        }
	}
}

Runtime Error:

 Exception in thread "primary" java.lang.ArithmeticException: / by zero
 at Essential.primary(File.java:4) 

Output:

cleansing.......

Java Remaining vs Lastly vs Finalize

Java Throw Key phrase

It’s a key phrase that’s used to explicitly throw an exception.

We will use throw the place in keeping with our logic an exception ought to happen.

Instance:

public class ExceptionDemo {
	static void canVote(int age){
		if(age<18)
            attempt{
                throw new Exception();
            }catch(Exception e){
                System.out.println("you aren't an grownup!");
            }
		else
		   System.out.println("you possibly can vote!");
	}
	public static void primary (String[] args) {
		canVote(20);
		canVote(10);
	}
}

Output:

you possibly can vote!
you aren't an grownup! 

Java Throws Key phrase

• Throws key phrase is used when callee doesn’t wish to deal with the exception fairly it desires to increase this accountability of dealing with the exception to the caller of the operate.
• Principally says what kind of exception the code can throw and depends on the caller to deal with it.
• It’s used to deal with checked Exceptions because the compiler won’t enable code to compile till they’re dealt with.

Instance:

public class ExceptionDemo {
	static void func(int a) throws Exception{
		   System.out.println(10/a);  
	}
	public static void primary (String[] args) {
		attempt{
		    func(10);
		    func(0);
		}catch(Exception e){
		   System.out.println("cannot divide by zero");
		}
	
	}
}

Output:

1
cannot divide by zero 

If callee can throw a number of exceptions, then all will likely be thrown concurrently.

import java.util.*;

public class ExceptionDemo {
	static void func(int a,int b) throws ArithmeticException, ArrayIndexOutOfBoundsException{
		   System.out.println(10/a); 
		   int[] arr={1,2,3};
		   System.out.println(arr[b]);
	}
	public static void primary (String[] args) {
		Scanner in=new Scanner(System.in);
		for(int i=0;i<3;i++){
		attempt{
		    func(in.nextInt(),in.nextInt());
    		}catch(ArithmeticException e){
    		   System.out.println("cannot divide by zero");
    		}catch(ArrayIndexOutOfBoundsException e){
    		   System.out.println("Out of bounds!");
    		}
		     }
		
	}
   }

Enter:

2 1
0 1
2 3 

Output:

5
2
cannot divide by zero
5
Out of bounds! 

Java Throw vs Throws

Java Customized Exception

You may create your personal exception and provides implementation as to the way it ought to behave. Your exception will behave like a toddler’s class of Exception.

Syntax:

 class YourException extends Exception{}

• Instance:
  • let’s say, you’re working with an airline firm 
  • You might be within the baggage check-in division and as per guidelines, you possibly can enable 15kg per buyer.
  • So now greater than 15kg of weight is an irregular situation for us or in different phrases its an exception
  • That is our logic-based exception, so we’ll create our customized exception WeightLimitExceeded 
  • As per syntax, it can lengthen Exception.
  • We outline the constructor which can get invoked as quickly as an exception will likely be thrown
  • We have now to explicitly throw the exception and therefore we are going to use throw key phrase for that.
  • Utilizing throws key phrase is as per our want. If we’re dealing with an exception the place it’s getting thrown then we are able to keep away from throws, else we are going to use throws and deal with it within the caller.

Implementation:

import java.util.*;

class WeightLimitExceeded extends Exception{
    WeightLimitExceeded(int x){
        System.out.print(Math.abs(15-x)+" kg : ");
    }
}


class Essential {
    void validWeight(int weight) throws WeightLimitExceeded{
        if(weight>15)
            throw new WeightLimitExceeded(weight);
        else
            System.out.println("You might be able to fly!");
    }
    
      public static void primary (String[] args) {
        Essential ob=new Essential();
        Scanner in=new Scanner(System.in);
        for(int i=0;i<2;i++){
            attempt{
                ob.validWeight(in.nextInt());
            }catch(WeightLimitExceeded e){
                System.out.println(e);
            }
        }
        
	}
}

Enter:

20
7 

Output:

5 kg : WeightLimitExceeded
You might be able to fly! 

Exception Dealing with in java with methodology overriding

Exception Dealing with in Java with Technique Overriding is an overridden methodology that declares to throw an exception and declare that it may well throw the identical exception or subtype of that exception.

To deal with the exception in Java, you’ll have to observe three vital guidelines. They’re depicted within the under determine.

Benefits and drawbacks of exception dealing with in java

Benefits of excepting dealing with in java 

• Separating Error-Dealing with Code from “Common” Code
• Propagating Errors Up the Name Stack
• Grouping and Differentiating Error Sorts

Disadvantages of excepting dealing with in java 

• Experiencing pointless overhead
• Not understanding how the applying actually works
• Filling your logs with noisy occasions
• Incapacity to give attention to what truly issues

This brings us to the top of this text on exception dealing with in java. We hope that you’re now clear concerning the idea of exception dealing with in java. When you want to know extra concerning the java programming language, then go browsing to our free java on-line course with certificates and energy forward in your profession.

Additionally Watch: