Full Stack Web Development Internship Program
- 29k Enrolled Learners
- Weekend/Weekday
- Live Class
Errors can occur at any time, but what matters is, how we handle and rectify them to maintain the normal flow. Java, being the most prominent object-oriented language, provides a powerful mechanism which allows you to handle these errors/exceptions. Wouldn’t it be wonderful if you had a Cheat Sheet as a quick reference to handle all the exceptions? So, here I bring you the Java Exceptions Cheat Sheet that acts as a solution guide for exception handling.
Related Learning: Java String Cheat Sheet
Exception Handling in Java is one of the most powerful mechanisms to handle the runtime errors for maintaining the normal flow of an application. When an exceptional condition occurs within a method, Java creates an exception object and throws it. The created exception object contains information about the error, like error type, state of the program etc.
In Java, an exception is an event that disrupts the normal flow of the program. It is an object which is thrown at runtime.
Types of Exceptions:
public class JavaExceptionExample{
public static void main(String args[]){
try{
int data=100/0;
}catch(ArithmeticException e){System.out.println(e);}
System.out.println("rest of the code...");
}
}
public String getMessage()
// Returns a detailed message about the exception
public String toString()
// Returns the name of the concatenated class with the result of getMessage()
public void printStackTrace()
// Prints the result of toString() along with the stack trace
public stackTraceElement [] getStackTrace()
// Returns an array containing each element on the Stack Trace
public Throwable fillInStackTrace()
// Fills the stack trace by adding previous information present in the stack.
There are 2 types of exceptions:
Built-in Exceptions
Built-in Java Exceptions are the exceptions which are available in Java libraries. These exceptions are suitable to explain certain error situations.
User-Defined Exceptions
Sometimes, the built-in exceptions in Java are not able to describe a certain situation. In such cases, a user can also create exceptions which are called ‘User-Defined Exceptions’.
Key points to note:
1. A user-defined exception must extend Exception class.
2. The exception is thrown using throw keyword.
// User Defined Exception
class MyException extends Exception{
String str1;
MyException(String str2) { str1=str2;}
public String toString(){
return ("MyException Occurred: "+str1);
}
}
class Example1{
public static void main(String args[]){
try{
System.out.println("Start of try block");
throw new MyException(“Error Message");
}
catch(MyException exp){System.out.println("Catch Block"); System.out.println(exp);
}
}
Java try block is used to enclose the code that might throw an exception.
try{
//code that may throw exception
}catch(Exception_class_Name ref){}
Java catch block is used to handle the Exception. It must be used after the try block only.
public class Testtrycatch1{
public static void main(String args[]){
int data=50/0;//may throw exception
System.out.println("rest of the code...");
}
}
The try block within a try block is known as nested try block in java.
class Exception{
public static void main(String args[]){
try{
try{
System.out.println("going to divide");
int b=59/0;
}catch(ArithmeticException e){System.out.println(e);}
try{
int a[]=new int[5];
a[5]=4;
}
catch(ArrayIndexOutOfBoundsException e) {System.out.println(e);} System.out.println("other statement);
}catch(Exception e)
{System.out.println("Exception handeled");}
System.out.println("casual flow");
}
}
If you have to perform various tasks at the occurrence of various exceptions, you can use java multi-catch block.
public class SampleMultipleCatchBlock{
public static void main(String args[]){
try{
int a[]=new int[5];
a[5]=30/0;
}
catch(ArithmeticException e)
{System.out.println("task1 is completed");}
catch(ArrayIndexOutOfBoundsException e)
{System.out.println("task 2 completed");}
catch(Exception e)
{System.out.println("task 3 completed");}
System.out.println("remaining code");
}
}
throw | throws |
Used to explicitly throw an exception | Used to declare an exception |
Checked exceptions cannot be propagated using throw only | Checked exceptions can be propagated |
Followed by an instance | Followed by a class |
Used within a method | Used with a method signature |
Cannot throw multiple exceptions | Can declare multiple exceptions |
//Java throw example
void a()
{
throw new ArithmeticException("Incorrect");
}
//Java throws example
void a()throws ArithmeticException
{
//method code
}
//Java throw and throws example
void a()throws ArithmeticException
{
throw new ArithmeticException("Incorrect");
}
finally block is a block that is used to execute important code such as closing connection, stream etc. It is always executed whether an exception is handled or not.
class SampleFinallyBlock{
public static void main(String args[]){
try{
int data=55/5;
System.out.println(data);
}
catch(NullPointerException e)
{System.out.println(e);}
finally {System.out.println("finally block is executed");}
System.out.println("remaining code");
}
}
final | finally | finalize |
It is a Keyword | It is a block | It is a method |
Used to apply restrictions on class, methods & variables. | Used to place an important code | Used to perform clean-up processing just before the object is garbage collected |
final class cant be inherited, method cant be overridden & the variable value cant be changed | It will be executed whether the exception is handled or not. | – |
finally example where exception occurs and handled
class SampleFinallyBlock{
public static void main(String args[]){
try{
int data=25/0;
System.out.println(data);
}
catch(NullPointerException e)
{System.out.println(e);}
finally {System.out.println("finally block is executed");}
System.out.println("remaining code");
}
}
If the superclass method does not declare an exception, subclass overridden method cannot declare the checked exception but it can declare the unchecked exception.
import java.io.*;
class Parent{
void msg()
{System.out.println("parent");}
}
class ExceptionChild extends Parent{
void msg()throws IOException{
System.out.println("ExceptionChild");
}
public static void main(String args[]){
Parent p=new ExceptionChild();
p.msg();
}
}
If the superclass method declares an exception, subclass overridden method can declare same, subclass exception or no exception but cannot declare parent exception.
import java.io.*;
class Parent{
void msg()throwsArithmeticException
{System.out.println("parent");}
}
class ExceptionChild2 extends Parent{
void msg()throws Exception {System.out.println("child");}
public static void main(String args[]){
Parent p=new ExceptionChild2();
try{
p.msg();
}catch(Exception e){}
}
With this, we come to an end of Java Exceptions Cheat Sheet. Check out the Java training by Edureka, a trusted online learning company with a network of more than 250,000 satisfied learners spread across the globe. Edureka’s Comprehensive Java Course Certification training is designed for students and professionals who want to be a Java Developer. The course is designed to give you a head start into Java programming that includes Interfaces, Exception Handling and JDBC Projects.
Related Learning: Java OOP Cheat Sheet
Course Name | Date | Details |
---|---|---|
Java Course Online | Class Starts on 7th December,2024 7th December SAT&SUN (Weekend Batch) | View Details |
edureka.co