Try-catch-finally Example in Java

Introduction

Try-Catch-Finally is a classic Java console program that demonstrates the concept with complete source code and sample output. Exceptions represent runtime errors; Java uses try-catch-finally to handle them safely.

This tutorial walks through the program line by line, explains how the logic works, and highlights best practices you can apply in your own code.

Try block:

• Try block has the main code, which code may throw an exception.

a try block syntax looks like the following:

try {
  //main code
}

Catch block:

• The catch block contains exception code that is executed when thrown by the Try Block.
• Possible to declare one or more catch block for different type of exception
• No code can be between try block and the first catch block.
• Catch blocks declare directly after the try block.

a catch block syntax looks like the following:

try {

} catch (ExceptionType1 name) {
 //exception code
} catch (ExceptionType2 name) {
 //exception code
}

Finally, block:

• The finally block always executes after try block or catch block.
• finally block is a block that is used to execute clean up code such as streaming or closing connection, etc.
• Declare cleanup code in a finally block is always a best practice in Java, even when no exceptions have occurred.

a finally block syntax looks like the following:

try {

} catch (ExceptionType1 name) {
 //exception code
} catch (ExceptionType2 name) {
 //exception code
}
finally {
  if (out != null) {
    // Close Out - Clean Up Code
  } else {
    // No need to close Out
  }
}

General Syntax

try{
	//Do Something
}catch(Exception e){
	//Do something with caught exception
}finally{
	//Do something always - even when there is an exception
}

public class TryCatchFinally {
    static void splitString(String text){
        try{  
            String[] splittedString =text.split("/");  
            for(int i = 0; i < splittedString.length; i++){
                System.out.println("Splitted string array of index "+i+" is : "+splittedString[i]);
            }
        }  
        catch(Exception e){
            System.out.println("Exception while performing division : "+e.toString());
        }  
        finally{
            System.out.println("I am inside finally block");
        }  
    }
    
    public static void main(String args[]){
        Scanner scanner = new Scanner(System.in);
        System.out.println("Enter number 1 : ");
        String text = scanner.nextLine();
        if(text.length()>0){
            splitString(text);
        }else{
            //Passing null as input for splitting
            splitString(null);
        }
    }
}

Sample Output

Run the program locally to see the output.

When to use

Use this try-catch-finally example when learning or revising core Java syntax.

How it works

1. Execution begins in the main method — the JVM calls this method when you run the class.

2. String[] splittedString =text.split("/"); updates a variable used in the calculation or output.

3. A loop repeats the block until its condition becomes false.

4. A println / print call writes text to the console — part of the sample output below.

5. A println / print call writes text to the console — part of the sample output below.

6. A println / print call writes text to the console — part of the sample output below.

7. A Scanner reads typed input from the keyboard (System.in).

8. A println / print call writes text to the console — part of the sample output below.

Best Practices

• Use meaningful variable and class names that describe their purpose.
• Compile and run the program locally — modify values to see how output changes.
• Read compiler errors carefully; they usually point to the exact line to fix.

Common Mistakes

• Copying code without understanding each line — practice by changing one statement at a time.
• Mismatching the public class name and the .java filename.
• Forgetting semicolons at the end of statements.