A Complete Guide - Java Programming try, catch, throw, throws, finally

Last Updated: 03 Jul, 2025   
  YOU NEED ANY HELP? THEN SELECT ANY TEXT.

Java Programming: try, catch, throw, throws, finally

1. try

  • Purpose: The try block is used to enclose the code that might throw an exception.
  • Usage: Always paired with catch or finally.
  • Example: 
    try { int result = 10 / 0; // This will throw an ArithmeticException
}

2. catch

  • Purpose: The catch block is used to handle the exception that is thrown from the try block.
  • Usage: Must be preceeded by a try block. Code inside catch is executed only if an exception occurs.
  • Example: 
    try { int result = 10 / 0;
} catch (ArithmeticException e) { System.out.println("Cannot divide by zero");
}

3. throw

  • Purpose: The throw keyword is used to explicitly throw an exception from a method or any block of code.
  • Usage: Used to generate custom exceptions or to force a method to throw a specific exception.
  • Example: 
    public void checkAge(int age) { if (age < 18) { throw new ArithmeticException("Access denied - You must be at least 18 years old."); } else { System.out.println("Access granted - You are old enough!"); }
}

4. throws

  • Purpose: The throws keyword is used to declare that a method might throw exceptions.
  • Usage: Partially offloads error checking to the method's caller (where the method is called). Useful in cases where the method can't handle the exception and needs the caller to handle it.
  • Example: 
    public void readFile() throws FileNotFoundException { File file = new File("nonexistent.txt"); FileInputStream fis = new FileInputStream(file); // Might throw FileNotFoundException
}

5. finally

  • Purpose: The finally block ensures that some code runs regardless of whether an exception was thrown or not.
  • Usage: Used to close resources, release locks, and perform final cleanup.
  • Example: 
    try { int result = 10 / 0;
} catch (ArithmeticException e) { System.out.println("Exception caught");
} finally { System.out.println("Finally block executed");
}

Integration Example:

Here is a detailed example to integrate all these concepts:

Online Code run

🔔 Note: Select your programming language to check or run code at

💻 Run Code Compiler

Step-by-Step Guide: How to Implement Java Programming try, catch, throw, throws, finally

1. Using try and catch:

The try block is used to contain code that might throw an exception, while the catch block is used to handle the exception.

public class TryCatchExample { public static void main(String[] args) { try { // Code that may throw an exception int result = 10 / 0; // This will throw ArithmeticException System.out.println("Result: " + result); } catch (ArithmeticException e) { // Handle ArithmeticException System.out.println("Caught an ArithmeticException: " + e.getMessage()); } System.out.println("Execution continues..."); }
}

Output:

Caught an ArithmeticException: / by zero
Execution continues...

2. Using Multiple catch Blocks:

You can have multiple catch blocks to handle different types of exceptions.

public class MultipleCatchExample { public static void main(String[] args) { try { // Code that may throw an exception int result = Integer.parseInt("abc"); // This will throw NumberFormatException System.out.println("Result: " + result); } catch (ArithmeticException e) { // Handle ArithmeticException System.out.println("Caught an ArithmeticException: " + e.getMessage()); } catch (NumberFormatException e) { // Handle NumberFormatException System.out.println("Caught a NumberFormatException: " + e.getMessage()); } System.out.println("Execution continues..."); }
}

Output:

Caught a NumberFormatException: For input string: "abc"
Execution continues...

3. Using finally:

The finally block is used to execute important code after try and catch, regardless of whether an exception is thrown or not.

public class FinallyExample { public static void main(String[] args) { try { // Code that may throw an exception int result = 10 / 0; // This will throw ArithmeticException System.out.println("Result: " + result); } catch (ArithmeticException e) { // Handle ArithmeticException System.out.println("Caught an ArithmeticException: " + e.getMessage()); } finally { // Code that will run no matter what System.out.println("Finally block: This always executes."); } System.out.println("Execution continues..."); }
}

Output:

Caught an ArithmeticException: / by zero
Finally block: This always executes.
Execution continues...

4. Using throw:

The throw keyword is used to explicitly throw an exception.

public class ThrowExample { public static void checkAge(int age) { if (age < 18) { // Throw an ArithmeticException if age is less than 18 throw new ArithmeticException("Access denied - You must be at least 18 years old."); } else { System.out.println("Access granted - You are old enough!"); } } public static void main(String[] args) { checkAge(15); // This will throw an exception }
}

Output:

Exception in thread "main" java.lang.ArithmeticException: Access denied - You must be at least 18 years old. at ThrowExample.checkAge(ThrowExample.java:7) at ThrowExample.main(ThrowExample.java:13)

5. Using throws:

The throws keyword is used to indicate that a method can throw an exception. It is mainly used to declare checked exceptions.

public class ThrowsExample { // Method that may throw a checked exception public static void readFile() throws Exception { // Code to read a file // This is just a placeholder, assuming we're throwing an Exception throw new Exception("File not found"); } public static void main(String[] args) { try { readFile(); // Calling the method that throws an exception } catch (Exception e) { System.out.println("Caught an exception: " + e.getMessage()); } }
}

Output:

You May Like This Related .NET Topic

📥 Download Code ▶️ Watch Online 📖 Read Description

Login to post a comment.