Try, catch, throw and throws in Java

try block

The try block is a domain that has a list of statements in which exceptions may occur. Try block cannot be used alone; therefore, it is always accompanied by either catch block, finally block, or both.
 

Syntax:

try{
	//code that may throw an exception
} catch(Exception_class_Name ref){
	//rest of the code
}

Nested try block

As the name implies, a nested try block is a try block inside a try block.
 

Example:

public class Main {
	// main function
	public static void main(String args[]) {
		try {
			try {
				// we try to divide a number by 0.
				// this will create an Arithmetic Exception
				int x = 5 / 0;
			}
			// this catch block will handle 
			// Arithmetic Exception
			catch (ArithmeticException e)
			{
				System.out.println("Arithmetic xception handled in this catch block");
			}
			try {
				int arr[] = { 5, 0 };
				System.out.println(arr[3]);
			}
			// this catch block will handle
			// Array Index Out of Bounds Exeception
			catch (ArrayIndexOutOfBoundsException e)
			{
				System.out.println("Array Index Out of Bounds Exception is handled in this catch block");
			}
		} catch (Exception exception) {
			System.out.println("remaining code");
		}
	}
}

Output:

Try it on online java compiler

catch block

The catch block is a method that is utilized to grasp exceptional cases. It always accompanies try block. Finally block can accompany a catch block after it accompanies a try block. A number of catch blocks can be linked with a try block. It can handle many exception cases in all linked blocks. The particular catch block assigned the code with exception handles the exception.

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

Multi-Catch block

If you need to perform multiple tasks in response to multiple exceptions, you can use the multi-catch block.

Example:

import java.util.*;
public class Main {
	// main function
	public static void main(String args[]) {
		ArrayList<String> al = new ArrayList<String> ();
		al.add("Coding");
		al.add("Ninjas");
		try {
			String wrongAccess = al.get(5);
		} catch (ArithmeticException ae) {
			System.out.println("Wrong arithmetic expression. Please try again!");
		} catch (IndexOutOfBoundsException indxExcep) {
			System.out.println("You tried to access wrong index. Please check and try again!");
		} catch (Exception e) {
			System.out.println("This will handle any exception!");
		}
	}
}

Output:

Also see,  Swap Function in Java

throw block

In Exception Handling, the throw keyword explicitly throws an exception from a method or constructor. We can throw either checked or unchecked exceptions in Java by throw keyword. The "throw" keyword is mainly used to throw a custom exception. The only object of the throwable class or its subclasses can be thrown. When a throw statement is encountered, program execution is halted, and the nearest catch statement is searched for a matching kind of exception.
 

Example:

public class ThrowExample {
	static void checkEligibilty(int stuage, int stuweight) {
		// check if the student's age is less than 15
		// and the student's weight is greater than 45
		if (stuage<15 && stuweight<45) {
			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:

throws block

Any method that might cause exceptions must identify all of the exceptions that can occur during its execution. The programmer calling the method is aware of which exceptions must be handled. The throws keyword can be used to do this.

Example:

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 Main {
	public static void main(String args[]) {
		try {
			ThrowExample obj = new ThrowExample();
			obj.myMethod(1);
		} catch (Exception ex) {
			System.out.println(ex);
		}
	}
}

Output:

Must Read Static Blocks In Java. Fibonacci Series in Java and Hashcode Method in Java

Frequently Asked Questions

Is catch block mandatory in Java?

No, not at all. Unless and until a finally block follows the try block, it is unnecessary to put catch after the try block. Keep in mind that after a try, a catch, a finally, or both can be useful.
 

Why is finally block needed?

In Java, the finally block is used to place critical code such as cleanup code, closing a file, or closing a connection. The finally block checks whether an exception has been raised and whether it has been handled. Regardless of whether the exception happens, a fina block contains all the crucial statements.
 

How many exceptions are there in Java?

There are three types of exceptions:
1. The checked exception. 
2. The error. 
3. The runtime exception.

Conclusion

This blog has discussed exception handling methods like try, catch, throw, and throws in Java with examples. Along with a few more important terminologies with its code.

Recommended Topic: Difference Between Data Analyst and Business Analyst

We hope that this blog has helped you enhance your knowledge regarding try, catch, throw and throws in Java and if you would like to learn more, check out our articles on the link. Do upvote our blog to help other ninjas grow. 

Happy Coding!