The Exception Handling in Java is one of the powerful mechanism to handle the runtime errors so that normal flow of the application can be maintained.

What is an Exception?

An exception is an unwanted or unexpected event, which occurs during the execution of a program i.e at run time, that disrupts the normal flow of the program’s instructions.

Error vs Exception

Error: An Error indicates serious problem that a reasonable application should not try to catch.
Exception: Exception indicates conditions that a reasonable application might try to catch.

When an exception occurs program execution gets terminated. In such cases we get a system generated error message. The good thing about exceptions is that they can be handled in Java. By handling the exceptions we can provide a meaningful message to the user about the issue rather than a system generated message, which may not be understandable to a user.

Why an exception occurs?

There can be several reasons that can cause a program to throw exception. For example: Opening a non-existing file in your program, Network connection problem, bad input data provided by user etc.

Hierarchy of Java Exception classes

The java.lang.Throwable class is the root class of Java Exception hierarchy which is inherited by two subclasses: Exception and Error. A hierarchy of Java Exception classes are given below:

Difference between Checked and Unchecked Exceptions

1) Checked Exception

The classes which directly inherit Throwable class except RuntimeException and Error are known as checked exceptions e.g. IOException, SQLException etc. Checked exceptions are checked at compile-time.

2) Unchecked Exception

The classes which inherit RuntimeException are known as unchecked exceptions e.g. ArithmeticException, NullPointerException, ArrayIndexOutOfBoundsException etc. Unchecked exceptions are not checked at compile-time, but they are checked at runtime

Common Scenarios of Java Exceptions

There are given some scenarios where unchecked exceptions may occur. They are as follows:

1) A scenario where ArithmeticException occurs

If we divide any number by zero, there occurs an ArithmeticException.

int a=50/0;//ArithmeticException

2) A scenario where NullPointerException occurs

If we have a null value in any variable, performing any operation on the variable throws a NullPointerException.

String s=null;
System.out.println(s.length());//NullPointerException

3) A scenario where NumberFormatException occurs

The wrong formatting of any value may occur NumberFormatException. Suppose I have a string variable that has characters, converting this variable into digit will occur NumberFormatException.

String s="abc";
int i=Integer.parseInt(s);//NumberFormatException

4) A scenario where ArrayIndexOutOfBoundsException occurs

If you are inserting any value in the wrong index, it would result in ArrayIndexOutOfBoundsException as shown below:

int a[]=new int[5];
a[10]=50; //ArrayIndexOutOfBoundsException

Java try-catch block

Java try block

Java try block is used to enclose the code that might throw an exception. It must be used within the method.

If an exception occurs at the particular statement of try block, the rest of the block code will not execute. So, it is recommended not to keeping the code in try block that will not throw an exception.

Java try block must be followed by either catch or finally block.

Syntax of Java try-catch

Syntax of try catch in java

try
{
     //statements that may cause an exception
}
catch (exception(type) e(object))‏
{
     //error handling code
}

Syntax of try-finally block

try{
//code that may throw an exception
}finally{}

Java catch block

Java catch block is used to handle the Exception by declaring the type of exception within the parameter. The declared exception must be the parent class exception ( i.e., Exception) or the generated exception type. However, the good approach is to declare the generated type of exception.

The catch block must be used after the try block only. You can use multiple catch block with a single try block.

Java Multi-catch block

A try block can be followed by one or more catch blocks. Each catch block must contain a different exception handler. So, if you have to perform different tasks at the occurrence of different exceptions, use java multi-catch block.

Points to remember

At a time only one exception occurs and at a time only one catch block is executed.
All catch blocks must be ordered from most specific to most general, i.e. catch for ArithmeticException must come before catch for Exception.

Example 1

Let's see a simple example of java multi-catch block.

public class MultipleCatchBlock1 {
public static void main(String[] args) {
try{
int a[]=new int[5];
a[5]=30/0;
}
catch(ArithmeticException e)
{
System.out.println("Arithmetic Exception occurs");
}
catch(ArrayIndexOutOfBoundsException e)
{
System.out.println("ArrayIndexOutOfBounds Exception occurs");
}
catch(Exception e)
{
System.out.println("Parent Exception occurs");
}
System.out.println("rest of the code");
}
}

Java finally block

Java finally block is a block that is used to execute important code such as closing connection, stream etc.
Java finally block is always executed whether exception is handled or not.
Java finally block follows try or catch block.

Syntax of Finally block

try {
    //Statements that may cause an exception
}
catch {
   //Handling exception
}
finally {
   //Statements to be executed
}

A Simple Example of finally block

Here you can see that the exception occurred in try block which has been handled in catch block, after that finally block got executed.

class Example
{
   public static void main(String args[]) {
      try{  
  int num=121/0;  
  System.out.println(num);  
      }  
      catch(ArithmeticException e){
         System.out.println("Number should not be divided by zero");
      }  
      /* Finally block will always execute
       * even if there is no exception in try block
       */
      finally{
  System.out.println("This is finally block");
      }  
      System.out.println("Out of try-catch-finally");  
   }   
}

Output:

Number should not be divided by zero
This is finally block
Out of try-catch-finally

Why use java finally

Finally block in java can be used to put "cleanup" code such as closing a file, closing connection etc

Cases when the finally block doesn’t execute

The circumstances that prevent execution of the code in a finally block are:
– The death of a Thread
– Using of the System. exit() method.
– Due to an exception arising in the finally block.

Finally and Close()

close() statement is used to close all the open streams in a program. Its a good practice to use close() inside finally block. Since finally block executes even if exception occurs so you can be sure that all input and output streams are closed properly regardless of whether the exception occurs or not.

Java throw keyword

The Java throw keyword is used to explicitly throw an exception.
We can throw either checked or uncheked exception in java by throw keyword. The throw keyword is mainly used to throw custom exception.

Syntax of throw keyword:

throw new exception_class("error message");

For example:

throw new ArithmeticException("dividing a number by 5 is not allowed in this program");

Example of throw keyword

Lets say we have a requirement where we we need to only register the students when their age is less than 12 and weight is less than 40, if any of the condition is not met then the user should get an ArithmeticException with the warning message “Student is not eligible for registration”. We have implemented the logic by placing the code in the method that checks student eligibility if the entered student age and weight doesn’t met the criteria then we throw the exception using throw keyword.

/* In this program we are checking the Student age
 * if the student age<12 and weight <40 then our program 
 * should return that the student is not eligible for registration.
 */
public class ThrowExample {
   static void checkEligibilty(int stuage, int stuweight){ 
      if(stuage<12 && stuweight<40) {
         throw new ArithmeticException("Student is not eligible for registration"); 
      }
      else {
         System.out.println("Student Entry is Valid!!"); 
      }
   } 

   public static void main(String args[]){ 
     System.out.println("Welcome to the Registration process!!");
     checkEligibilty(10, 39); 
     System.out.println("Have a nice day.."); 
 } 
}

Output:

Welcome to the Registration process!!Exception in thread "main" 
java.lang.ArithmeticException: Student is not eligible for registration
at beginnersbook.com.ThrowExample.checkEligibilty(ThrowExample.java:9)
at beginnersbook.com.ThrowExample.main(ThrowExample.java:18)

============================================================

Java throws keyword

The Java throws keyword is used to declare an exception. It gives an information to the programmer that there may occur an exception so it is better for the programmer to provide the exception handling code so that normal flow can be maintained.
Exception Handling is mainly used to handle the checked exceptions. If there occurs any unchecked exception such as NullPointerException, it is programmers fault that he is not performing check up before the code being used.

s we know that there are two types of exception checked and unchecked. Checked exception (compile time) force you to handle them, if you don’t handle them then the program will not compile.
On the other hand unchecked exception (Runtime) doesn’t get checked during compilation. Throws keyword is used for handling checked exceptions . By using throws we can declare multiple exceptions in one go.

What is the need of having throws keyword when you can handle exception using try-catch?

Well, thats a valid question. We already know we can handle exceptions using try-catch block.
The throws does the same thing that try-catch does but there are some cases where you would prefer throws over try-catch. For example:
Lets say we have a method myMethod() that has statements that can throw either ArithmeticException or NullPointerException, in this case you can use try-catch as shown below:

public void myMethod()
{
  try {
    // Statements that might throw an exception 
  }
  catch (ArithmeticException e) {
    // Exception handling statements
  }
  catch (NullPointerException e) {
    // Exception handling statements
  }
}

But suppose you have several such methods that can cause exceptions, in that case it would be tedious to write these try-catch for each method. The code will become unnecessary long and will be less-readable.

One way to overcome this problem is by using throws like this: declare the exceptions in the method signature using throws and handle the exceptions where you are calling this method by using try-catch.
Another advantage of using this approach is that you will be forced to handle the exception when you call this method, all the exceptions that are declared using throws, must be handled where you are calling this method else you will get compilation error.

public void myMethod() throws ArithmeticException, NullPointerException
{
  // Statements that might throw an exception 
}

public static void main(String args[]) { 
  try {
    myMethod();
  }
  catch (ArithmeticException e) {
    // Exception handling statements
  }
  catch (NullPointerException e) {
    // Exception handling statements
  }
}

Example of throws Keyword

In this example the method myMethod() is throwing two checked exceptions so we have declared these exceptions in the method signature using throws Keyword. If we do not declare these exceptions then the program will throw a compilation error.

import java.io.*;
class ThrowExample { 
  void myMethod(int num)throws IOException, ClassNotFoundException{ 
     if(num==1)
        throw new IOException("IOException Occurred");
     else
        throw new ClassNotFoundException("ClassNotFoundException");
  } 
} 

public class Example1{ 
  public static void main(String args[]){ 
   try{ 
     ThrowExample obj=new ThrowExample(); 
     obj.myMethod(1); 
   }catch(Exception ex){
     System.out.println(ex);
    } 
  }
}

Output:

java.io.IOException: IOException Occurred

===================================================

Difference between throw and throws in Java

There are many differences between throw and throws keywords. A list of differences between throw and throws are given below:

No.	throw	throws
1)	Java throw keyword is used to explicitly throw an exception.	Java throws keyword is used to declare an exception.
2)	Checked exception cannot be propagated using throw only.	Checked exception can be propagated with throws.
3)	Throw is followed by an instance.	Throws is followed by class.
4)	Throw is used within the method.	Throws is used with the method signature.
5)	You cannot throw multiple exceptions.	You can declare multiple exceptions e.g. public void method()throws IOException,SQLException.

Difference between final, finally and finalize

There are many differences between final, finally and finalize. A list of differences between final, finally and finalize are given below:

No.	final	finally	finalize
1)	Final is used to apply restrictions on class, method and variable. Final class can't be inherited, final method can't be overridden and final variable value can't be changed.	Finally is used to place important code, it will be executed whether exception is handled or not.	Finalize is used to perform clean up processing just before object is garbage collected.
2)	Final is a keyword.	Finally is a block.	Finalize is a method.

==============================================================

HACKER RANK PROBLEMS:

---------------------------------------------------------------------------------------------------------------

PRG-1)

Java has built-in mechanism to handle exceptions. Using the try statement we can test a block of code for errors. The catch block contains the code that says what to do if exception occurs.

This problem will test your knowledge on try-catch block.

You will be given two integers and as input, you have to compute . If and are not bit signed integers or if is zero, exception will occur and you have to report it. Read sample Input/Output to know what to report in case of exceptions.

Sample Input 0:

10
3

Sample Output 0:

Sample Input 1:

10
Hello

Sample Output 1:

java.util.InputMismatchException

Sample Input 2:

10
0

Sample Output 2:

java.lang.ArithmeticException: / by zero

Sample Input 3:

23.323
0

Sample Output 3:

java.util.InputMismatchException

=================================================

PRG-2

You are required to compute the power of a number by implementing a calculator. Create a class MyCalculator which consists of a single method long power(int, int). This method takes two integers, and , as parameters and finds . If either or is negative, then the method must throw an exception which says "". Also, if both and are zero, then the method must throw an exception which says ""

For example, -4 and -5 would result in .

Complete the function power in class MyCalculator and return the appropriate result after the power operation or an appropriate exception as detailed above.

Input Format

Each line of the input contains two integers, and . The locked stub code in the editor reads the input and sends the values to the method as parameters.

Constraints

Output Format

Each line of the output contains the result , if both and are positive. If either or is negative, the output contains "n and p should be non-negative". If both and are zero, the output contains "n and p should not be zero.". This is printed by the locked stub code in the editor.

Sample Input 0

Sample Output 0

243
16
java.lang.Exception: n and p should not be zero.
java.lang.Exception: n or p should not be negative.
java.lang.Exception: n or p should not be negative.

Explanation 0

In the first two cases, both and are postive. So, the power function returns the answer correctly.
In the third case, both and are zero. So, the exception, "n and p should not be zero.", is printed.
In the last two cases, at least one out of and is negative. So, the exception, "n or p should not be negative.", is printed for these two cases.

Why do you need Throw and Throws keyword when we have Try,catch and finally?

Ans)

The throw and throws keywords in programming are used in a different context than try, catch, and finally. They serve distinct purposes in handling exceptions and error management in many programming languages, including Java. Let's break down their roles:

throw:
- throw is used to explicitly raise (or throw) an exception or error within your code.
- When a specific condition or situation in your code indicates that something exceptional has occurred and you want to interrupt the normal flow of the program, you can use throw to create and throw an exception object.
- For example, you might throw an IllegalArgumentException when invalid arguments are passed to a method.
```
java
public void someMethod(int value) {
    if (value < 0) {
        throw new IllegalArgumentException("Value cannot be negative");
    }
    // ... rest of the code
}
```
throws:
- throws is used in method declarations to indicate that the method may throw one or more specific types of exceptions.
- It serves as a contract between the method and the caller, informing the caller that certain exceptions might be thrown during the execution of the method, and the caller should handle them using a try-catch block.
- It doesn't actually throw exceptions but provides information about the possible exceptions that might occur.
```
java
public void someMethod(int value) throws IllegalArgumentException {
    if (value < 0) {
        throw new IllegalArgumentException("Value cannot be negative");
    }
    // ... rest of the code
}
```

On the other hand, try, catch, and finally are used for exception handling:

try:
- The try block is used to enclose a section of code where exceptions might occur.
- If an exception occurs within the try block, the program's normal flow is interrupted, and the control is transferred to the corresponding catch block.
catch:
- The catch block follows a try block and is used to handle exceptions.
- It specifies the type of exception it can catch and the code to be executed when that type of exception occurs.
finally:
- The finally block is used to specify code that must be executed whether or not an exception occurred in the try block.
- It is typically used for cleanup operations or releasing resources.

In summary, throw and throws are used to raise and declare exceptions, respectively, while try, catch, and finally are used to handle exceptions when they occur. They serve different purposes in exception management, and both are essential for building robust and reliable software

How to handle exceptions?

ANS)

Handling exceptions is a critical part of writing robust and reliable software. Exceptions are unexpected or erroneous situations that can occur during program execution, and handling them allows you to gracefully recover from or respond to these situations. Here are some key principles and techniques for handling exceptions in programming:

Use Try-Catch Blocks:
- The primary mechanism for handling exceptions in most programming languages is the try-catch (or try-except) block.
- Wrap the code that might throw an exception in a try block, and catch and handle the exception in one or more catch blocks.
```
java
try {
    // Code that may throw an exception
} catch (ExceptionType e) {
    // Handle the exception
}
```

Catch Specific Exceptions:

Catch specific exceptions that you can handle, rather than catching a general Exception or Throwable unless necessary.
This allows you to handle different types of exceptions differently.

java
try {
    // Code that may throw FileNotFoundException
} catch (FileNotFoundException e) {
    // Handle file not found exception
} catch (IOException e) {
    // Handle other I/O exceptions
}

Finally Block:
- Use a finally block to contain code that should execute regardless of whether an exception occurred.
- Commonly used for cleanup operations like closing files or releasing resources.
```
java
try {
    // Code that may throw an exception
} catch (ExceptionType e) {
    // Handle the exception
} finally {
    // Cleanup code
}
```
Throwing Exceptions:
- Use the throw keyword to explicitly raise exceptions when you encounter exceptional conditions.
- Provide meaningful error messages or context in the exception.
```
java
if (errorCondition) {
    throw new CustomException("This is an error message.");
}
```
Logging Exceptions:
- Consider logging exceptions using a logging framework (e.g., Log4j, SLF4J) to record details about the exception, its context, and the stack trace.
- Logging helps in diagnosing and debugging issues in production.
Propagate or Wrap Exceptions:
- Decide whether to propagate exceptions (throw them up the call stack) or catch and wrap them in a more appropriate exception type.
- Wrapping exceptions can provide a higher-level context for the error.
Handle Gracefully:
- Design your exception handling to allow the application to gracefully recover from errors when possible.
- Provide user-friendly error messages or notifications.
Use Checked and Unchecked Exceptions:
- Some languages, like Java, have checked and unchecked exceptions.
- Use checked exceptions for recoverable errors and unchecked exceptions for unrecoverable errors.
Unit Testing Exception Handling:
- Write unit tests to verify that your exception handling code behaves as expected.
- Test both the expected cases (exception is thrown) and the error-handling cases.
Document Exception Handling:
- Clearly document the exceptions that can be thrown by your methods, along with their meanings and potential solutions.

Handling exceptions is an essential part of writing reliable software. Effective exception handling can prevent crashes, improve user experience, and make your code more resilient to unexpected situations.

Why do you need finally block?

The finally block is an essential part of exception handling in many programming languages because it provides a mechanism to ensure that specific code is executed regardless of whether an exception is thrown or not. Here are several important reasons why you need a finally block:

Cleanup Operations:
- One of the primary use cases for the finally block is to perform cleanup operations, such as closing files, releasing resources (e.g., database connections), or undoing actions that were taken before the exception occurred.
- This ensures that resources are properly released, preventing resource leaks and potential issues, even in the presence of exceptions.
```
java
try {
    // Code that may throw an exception
} catch (Exception e) {
    // Handle the exception
} finally {
    // Cleanup resources, close files, etc.
}
```
Guaranteed Execution:
- The code within the finally block is guaranteed to execute, regardless of whether an exception is thrown and caught or whether the code within the try block finishes successfully.
- This guarantee helps maintain program stability and ensures that critical cleanup tasks are always performed.
Exception Propagation:
- In cases where an exception is caught and handled in a catch block, the finally block will execute before the control is transferred out of the try-catch structure.
- This allows you to perform cleanup operations before the exception is potentially propagated further up the call stack.
Resource Management:
- For scenarios involving resources like database connections or network sockets, the finally block is an ideal place to ensure these resources are properly closed or released.
- Failure to do so can lead to resource exhaustion and degrade application performance.
Completing Transactions:
- In database operations or other transactional processes, the finally block is used to commit or rollback transactions based on the outcome of the try block.
- This helps maintain data integrity and ensures that the transaction is completed correctly.
Common Cleanup Logic:
- In situations where multiple catch blocks handle different exceptions but share common cleanup logic, the finally block can be used to avoid duplicating cleanup code.
- This promotes code reuse and maintainability.

In summary, the finally block is crucial for ensuring that essential cleanup and resource management tasks are executed reliably in the presence of exceptions. It plays a critical role in maintaining the integrity and stability of a program by guaranteeing that specific code is executed regardless of the control flow within the try-catch structure

Ramesh Insights In Automation

Automation QA Testing Course Content

Exception Handling Information

Why an exception occurs?

Hierarchy of Java Exception classes

Difference between Checked and Unchecked Exceptions

1) Checked Exception

2) Unchecked Exception

Common Scenarios of Java Exceptions

1) A scenario where ArithmeticException occurs

2) A scenario where NullPointerException occurs

3) A scenario where NumberFormatException occurs

4) A scenario where ArrayIndexOutOfBoundsException occurs

Java try-catch block

Java try block

Syntax of try catch in java

Syntax of try-finally block

Java catch block

Java Multi-catch block

Points to remember

Example 1

Java finally block

Syntax of Finally block

A Simple Example of finally block

Why use java finally

Finally block in java can be used to put "cleanup" code such as closing a file, closing connection etc

Cases when the finally block doesn’t execute

Finally and Close()

Java throw keyword

Example of throw keyword

Java throws keyword

What is the need of having throws keyword when you can handle exception using try-catch?

Example of throws Keyword

Difference between throw and throws in Java

Difference between final, finally and finalize

No comments:

Post a Comment