How to Ask User to Repeat Again After Throw Exception

Exceptions in Coffee programming language

Final update on February 26 2020 08:07:31 (UTC/GMT +eight hours)

Introduction

A Java exception is an object that describes an infrequent (that is, error) status that has occurred in a piece of code. When an exceptional condition arises, an object representing that exception is created and thrown in the method that caused the error. That method may cull to handle the exception itself or laissez passer it on. Either manner, at some point, the exception is caught and processed.

The programs you write can generate many types of potential exceptions, such as when you do the post-obit:

In Java there are three types of loops:

• You effect a command to read a file from a disk, merely the file does not exist there.
• Y'all attempt to write data to a disk, simply the deejay is full or unformatted.
• Your program asks for user input, only the user enters invalid data.
• The program attempts to divide a value by 0, access an array with a subscript that is too large or calculate a value that is also large for the answer'due south variable type.

These errors are called exceptions because, presumably, they are not usual occurrences; they are "infrequent." The object-oriented techniques to manage such errors comprise the group of methods known equally exception handling.

Exception handling works by transferring the execution of a program to an advisable exception handler when an exception occurs. Allow'southward accept an example program which will exercise take two numbers from user and impress segmentation result on screen. This might lead to exception condition if the denominator is goose egg.

Java Code: Go to the editor

          import java.util.Scanner; public class DivideExceptionDemo { 	public static void main(Cord[] args) { 		//Scanner class is wrapper class of System.in object 		Scanner inputDevice = new Scanner(Organisation.in); 		System.out.print("Delight enter kickoff number(numerator): "); 		int numerator = inputDevice.nextInt(); 		System.out.print("Delight enter second number(denominator): "); 		int denominator = inputDevice.nextInt(); 		new DivideExceptionDemo().doDivide(numerator, denominator); 	} 	public void doDivide(int a, int b){ 		float result = a/b; 		Arrangement.out.println("Sectionalization result of "+ a +"/"+b +"= " +result); 	} }                  

Output:

Outputs based on user input combinations:

Handling Exceptions:

In that location are two ways of treatment the exception, first catch the exception and take corrective action or throws the exception to the calling method which will force the calling method to handle it.

1. In above plan the execution is unexpected and ended in an error condition in instance of the denominator is zero. Nosotros can avert this past handling exception using a effort-grab block. Allow's update program for exception treatment. Hither we volition write exception prone code within try block (guarded cake) and catch block will follow the try cake.

Java Code: Go to the editor

          import java.util.Scanner; public class DivideExceptionHandle { 	public static void main(String[] args) { 		Scanner inputDevice = new Scanner(Arrangement.in); 		Organisation.out.impress("Please enter showtime number(numerator): "); 		int numerator = inputDevice.nextInt(); 		System.out.print("Please enter 2nd number(denominator): "); 		int denominator = inputDevice.nextInt();		 		new DivideExceptionHandle().doDivide(numerator, denominator);		 	} 	public void doDivide(int a, int b){ 		effort{ 			float issue = a/b; 			System.out.println("Division result of "+ a +"/"+b +"= " +consequence); 		}catch(ArithmeticException e){ 			System.out.println("Exception Condition Programme is ending "); 		} 	} }                  

Output:

Outputs based on user input combination:

2. When a Coffee method is going to throw an exception, to indicate that as part of the method signature 'throws' keyword should be used followed by the exception. It means that the caller of this method should handle the exception given in the throws clause. At that place can be multiple exceptions declared to be thrown by a method. If the caller of that method does not handle the exception, then it propagates to one level higher in the method call stack to the previous caller and similarly till it reaches base of operations of the the method phone call stack which volition exist the java's runtime system. For this arroyo, we use throws keyword in method proclamation which volition instruct the compiler to handle exception using effort-catch block. When we add together throws keyword in carve up method declaration compile time error will be seen as below,

Java Code: Get to the editor

          import java.util.Scanner; public form DivideExceptionThrows { 	public static void master(Cord[] args){ 		Scanner inputDevice = new Scanner(Arrangement.in); 		System.out.print("Delight enter beginning number(numerator): "); 		int numerator = inputDevice.nextInt(); 		Organization.out.print("Please enter 2d number(denominator): "); 		int denominator = inputDevice.nextInt();		 		endeavour { 			new DivideExceptionThrows().doDivide(numerator, denominator); 		} catch (Exception east) { 			System.out.println("Exception Condition Program is catastrophe "); 		}		 	} 	public void doDivide(int a, int b) throws Exception{ 			float outcome = a/b; 			Organisation.out.println("Division result of "+ a +"/"+b +"= " +result); 	} }                  

As yous can see either we can environment the code with try-take hold of block or we tin re-throw information technology to exist handled by calling the method. In this case, we are calling a method from the main() method and so if we re-throw the exception it would exist handled by JVM. Let us update the code and see output based on input combination

Output:

Outputs based on user input combination:

Nested Endeavour-catch cake:

The try argument can be nested. That is, a endeavor statement can be inside the block of another attempt.Each time a effort argument is entered, the context of that exception is pushed on the stack. If an inner effort statement does not have a catch handler for a particular exception, the stack is unwound and the next try statement's catch handlers are inspected for a match. This continues until one of the take hold of statements succeeds, or until all of the nested effort statements are exhausted.If no catch statement matches, then the Java runtime organisation will handle the exception. Below is the syntax of nested endeavour-catch block.

Java Lawmaking: Become to the editor

          public class NestedTryblockDemo { 	public static void main(String[] args) { 		endeavour{ 			//some lawmaking	which can throw Exception	 			try { 				//Some lawmaking which tin can throw Arithmatic exception 				endeavour { 					//Some lawmaking which tin can throw number format exception 				}catch(NumberFormatException n){ 					//Number format Exception treatment 				} 			}catch(ArithmeticException a){ 				//ArithmeticException Treatment 			} 		}grab(Exception eastward ){ 			//Full general Exception(SuperClass of all Exception) Handling 		} 	} }                  

Apply of finally block:

When you have actions you lot must perform at the end of a try...catch sequence, yous can apply a finally cake. The lawmaking within a finally block executes regardless of whether the preceding effort block identifies an Exception. Ordinarily, you use a finally block to perform cleanup tasks that must happen whether or not any Exceptions occurred, and whether or not any Exceptions that occurred were caught. In an application where database connection, files are being operated, we demand to take of endmost those resources in exceptional condition also as normal status.

Java Lawmaking: Get to the editor

          public grade TryCatchFinally { 	public void Demo() { 		attempt { 			// statements to endeavor 		} catch (Exception e) { 			// actions that occur if exception was thrown 		} finally { 			// actions that occur whether take hold of cake executed or not 		} 	} }                  

Summary:

Nosotros have learned almost how exceptions are generated and various ways of handling exceptions. Catching exception or propagating exceptions. We have learned keywords like effort, take hold of, finally, throws and programmatic employ of these keywords.

Java Code Editor:

Previous: Java Branching Statements
Next:Checked and unchecked

neversthionus.blogspot.com

Source: https://www.w3resource.com/java-tutorial/exception-in-java.php

Share this post