Tuesday, October 4, 2022
HomeE-LearningException Dealing with in Java with Examples

Exception Dealing with in Java with Examples


exception handling in java

Exception dealing with in java is without doubt one of the highly effective mechanisms to deal with runtime errors attributable to exceptions. Exception dealing with performs an vital position in software program growth. This text helps you perceive java exception, exception in java, java exception dealing with, java exception hierarchy, sorts 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 without doubt one of the highly effective mechanisms to deal with runtime exceptions and makes it bug-free. Exception dealing with helps in sustaining the circulate of this system. An exception dealing with is outlined as an irregular situation which will occur at runtime and disturb the traditional circulate 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 traditional circulate 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 potential approaches

exception handling in java

1. JVM

If an exception is just not dealt with explicitly, then JVM takes the duty 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 Important {
    public static void foremost (String[] args) {
        System.out.println(5/0);
        System.out.println("Finish of program!");
	}
}

Runtime Error:

 Exception in thread "foremost" java.lang.ArithmeticException: / by zero
 at Important.foremost(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 traditional 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.

exception handling in java
  • Throwable – 
    • It’s the root class for the exception hierarchy in java. 
    • It’s within the java.lang bundle.
  • Error – 
    • Subclass of Throwable.
    • Include irregular situation that’s out of 1’s management and is dependent upon the atmosphere
    • They will’t be dealt with and can at all times consequence within the halting of this system.
    • Eg: StackOverFlowError that may occur in infinite loop or recursion
  • Exception
    • Subclass of Throwable.
    • Include irregular circumstances 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 contains checked exceptions.
    • They’re little one courses of Exception apart from RuntimeException.
    • This system won’t compile if they don’t seem to be dealt with.
    • Instance: IOException, ClassNotFoundException, and so forth.
  • Unchecked Exceptions
    • These exceptions which are checked at runtime contains unchecked exceptions.
    • They’re little one courses of RuntimeException.
    • They offer runtime errors if not dealt with explicitly.
    • Instance: ArithmeticException, NullPointerException and so forth.

Distinction between Checked and Unchecked Exception

Checked Exceptions Unchecked Exceptions
Happen at compile time. Happen at runtime.
The compiler checks for a checked exception. The compiler doesn’t examine for exceptions.
Might be dealt with on the compilation time. Can’t be caught or dealt with throughout compilation time.
The JVM requires that the exception be caught and dealt with. The JVM doesn’t require the exception to be caught and dealt with.
Instance of Checked exception- ‘File Not Discovered Exception’ Instance of Unchecked Exceptions- ‘No Such Factor Exception’

Java Exception Index

Java Exception Key phrases

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

Key phrase Description
attempt This key phrase is used to specify a block and this block should be adopted by both catch or lastly. That’s, we are able to’t use attempt block alone.
catch This key phrase should be preceded by a attempt block to deal with the exception and will be adopted by a closing block later.
lastly This key phrase is used to execute this system, whether or not an exception is dealt with or not.
throw This key phrase is used to throw an exception.
throws This key phrase is used to declare exceptions.

Java Strive-Catch Block

Strive-catch syntax:

attempt{
}
catch(Exception e){
}
public class ExceptionDemo {
	public static void foremost (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 comprises 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. Strive should be instantly adopted by catch or lastly block.
public class ExceptionDemo {
	public static void foremost (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 comply with attempt else it should give a compile-time error.
public class ExceptionDemo {
	public static void foremost (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 liable to exception. As a result of if an exception occurred, it should right away soar to the catch or lastly block, ignoring all different statements within the attempt block.

class Important {
	public static void foremost (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 may have straight the category of exception or its superclass.

Instance: Precise Exception

class Important {
	public static void foremost (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 Precise Exception

class Important {
	public static void foremost (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

You probably have a number of catches, it’s a must to preserve the hierarchy from subclass to superclass.

Incorrect:

class Important {
	public static void foremost (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 Important {
	public static void foremost (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 Strive

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

class Important {
	public static void foremost (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 

Notice – If we put code of outer attempt earlier than interior attempt, then if an exception occurred, it should ignore the complete interior try to transfer on to its catch block.

class Important {
	public static void foremost (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

Accommodates code that should be executed regardless of if an exception is thrown or not. It comprises code of file launch, closing connections, and so forth.

exception handling in java
class Important {
	public static void foremost (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 Important {
	public static void foremost (String[] args) {
        attempt{
            System.out.println(4/0);
            
        }lastly
        {
            System.out.println("cleansing.......");
        }
	}
}

Runtime Error:

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

Output:

cleansing.......

Java Remaining vs Lastly vs Finalize

Remaining Lastly Finalize
Remaining is used to use restrictions on class, methodology, and variable Lastly is utilized in coding, will probably be executed whether or not an exception is dealt with or not. Finalize is used to carry out clean-up processing earlier than rubbish is collected.
Remaining is a key phrase in java Lastly is a block in java Finalize is a technique in java
Remaining is executed upon its name. Lastly executes after”try-catch” block. finalize executes simply earlier than the destruction of the item.

Java Throw Key phrase

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

We are able to use throw the place in line 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 may vote!");
	}
	public static void foremost (String[] args) {
		canVote(20);
		canVote(10);
	}
}

Output:

you may vote!
you aren't an grownup! 

Java Throws Key phrase

  • Throws key phrase is used when callee doesn’t need to deal with the exception reasonably it desires to increase this duty of dealing with the exception to the caller of the operate.
  • Mainly 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 foremost (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 probably 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 foremost (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

Throw Throws
This key phrase is used to explicitly throw an exception. This key phrase is used to declare an exception.
A checked exception can’t be propagated with throw solely. A checked exception will be propagated with throws.
The throw is adopted by an occasion and used with a way Throws are adopted by class and used with the strategy signature.
You can not throw a number of exceptions. You may declare a number of exceptions

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’re within the baggage check-in division and as per guidelines, you may 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 should prolong Exception.
    • We outline the constructor which can get invoked as quickly as an exception will probably be thrown
    • We’ve to explicitly throw the exception and therefore we’ll 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’ll 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 Important {
    void validWeight(int weight) throws WeightLimitExceeded{
        if(weight>15)
            throw new WeightLimitExceeded(weight);
        else
            System.out.println("You're able to fly!");
    }
    
      public static void foremost (String[] args) {
        Important ob=new Important();
        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're 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 will possibly throw the identical exception or subtype of that exception.

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

exception handling in java
Exception Dealing with in Java with Technique Overriding

Benefits and downsides 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 Varieties

Disadvantages of excepting dealing with in java 

  • Experiencing pointless overhead
  • Not understanding how the appliance actually works
  • Filling your logs with noisy occasions
  • Incapability to deal with what truly issues

This brings us to the tip of this text on exception dealing with in java. We hope that you’re now clear in regards to the idea of exception dealing with in java. Should you want to know extra in regards to the java programming language, then go surfing to our free java programming course and energy forward in your profession.

Additionally Watch:

RELATED ARTICLES

LEAVE A REPLY

Please enter your comment!
Please enter your name here

Most Popular

Recent Comments