Finally block in Java - Mini Project: Build & Apply

Using the Finally Block in Java

📖 Scenario: Imagine you are writing a simple Java program that reads a number from the user and divides 100 by that number. Sometimes the user might enter zero, which causes an error. You want to make sure that a message is always shown at the end, no matter what happens.

🎯 Goal: You will create a Java program that uses a try, catch, and finally block. The program will handle division by zero errors and always print a final message.

📋 What You'll Learn

Create an integer variable called number with the value 0

Create a try block that divides 100 by number

Create a catch block that catches ArithmeticException and prints "Cannot divide by zero"

Create a finally block that prints "End of program"

💡 Why This Matters

🌍 Real World

In real programs, you often need to handle errors like dividing by zero or missing files. The <code>finally</code> block helps you clean up or show messages no matter what happens.

💼 Career

Understanding <code>try</code>, <code>catch</code>, and <code>finally</code> blocks is important for writing reliable Java applications, which is a key skill for many programming jobs.

1

DATA SETUP: Create the variable number

Create an integer variable called number and set it to 0.

Java

// Create an integer variable called number and set it to 0
// Your code here

Hint

Use int number = 0; to create the variable.

2

CONFIGURATION: Start the try block

Add a try block that will contain the division operation 100 / number.

Java

int number = 0;
// Start a try block below
// Your code here

Hint

Write try { to start the block.

3

CORE LOGIC: Complete the try, catch, and finally blocks

Inside the try block, create an integer result that divides 100 by number. Then add a catch block for ArithmeticException that prints "Cannot divide by zero". Finally, add a finally block that prints "End of program".

Java

int number = 0;
try {
    // Divide 100 by number and store in result
    // Your code here
} catch (ArithmeticException e) {
    // Print "Cannot divide by zero"
    // Your code here
} finally {
    // Print "End of program"
    // Your code here
}

Hint

Remember to put the division inside try, handle the exception in catch, and always print the final message in finally.

4

OUTPUT: Run the program and print the messages

Run the program so it prints the messages from the catch and finally blocks.

Java

int number = 0;
try {
    int result = 100 / number;
} catch (ArithmeticException e) {
    System.out.println("Cannot divide by zero");
} finally {
    System.out.println("End of program");
}
// Run the program to see output
// Your code here

Hint

Make sure your program prints both messages exactly as shown.

Practice

1.

What is the main purpose of the finally block in Java exception handling?

easy

A. To catch exceptions thrown in the try block

B. To throw new exceptions

C. To execute code regardless of whether an exception occurs or not

D. To declare exceptions that a method can throw

Solution

1. Step 1: Understand the role of try-catch-finally

   The try block contains code that might throw exceptions, catch handles them, and finally runs code after both.

2. Step 2: Identify the purpose of finally

   The finally block always executes, whether an exception occurs or not, to finalize or clean up resources.

3. Final Answer:

   To execute code regardless of whether an exception occurs or not -> Option C

4. Quick Check:

   finally always runs = B [OK]

Hint: finally always runs after try/catch blocks [OK]

Common Mistakes:

• Thinking finally only runs if an exception occurs
• Confusing finally with catch block
• Assuming finally can catch exceptions

2.

Which of the following is the correct syntax to add a finally block after a try-catch in Java?

try {
    // code
} catch(Exception e) {
    // handle
} ??? {
    // cleanup
}

easy

A. finally

B. end

C. finalize

D. final

Solution

1. Step 1: Recall Java exception syntax

   Java uses the keyword finally to define the block that runs after try and catch.

2. Step 2: Match the correct keyword

   Among options, only finally is the valid keyword for this block.

3. Final Answer:

   finally -> Option A

4. Quick Check:

   finally keyword syntax = D [OK]

Hint: finally keyword always spelled 'finally' [OK]

Common Mistakes:

• Using 'final' instead of 'finally'
• Confusing with 'finalize' method
• Using invalid keywords like 'end'

3.

What will be the output of the following Java code?

public class Test {
    public static void main(String[] args) {
        try {
            System.out.print("Try-");
            return;
        } catch(Exception e) {
            System.out.print("Catch-");
        } finally {
            System.out.print("Finally");
        }
        System.out.print("End");
    }
}

medium

A. Try-Catch-End

B. Try-Catch-Finally-End

C. Try-End

D. Try-Finally

Solution

1. Step 1: Analyze try block execution

   The try block prints "Try-" and then returns, so normally method would exit here.

2. Step 2: Check finally block behavior with return

   Even with return, finally block executes, printing "Finally" before method exits.

3. Step 3: Confirm code after finally

   Code after finally (System.out.print("End")) is unreachable due to return, so not executed.

4. Final Answer:

   Try-Finally -> Option D

5. Quick Check:

   finally runs even after return = C [OK]

Hint: finally runs even if try returns early [OK]

Common Mistakes:

• Assuming code after finally runs after return
• Thinking catch block runs without exception
• Ignoring finally block execution

4.

Identify the error in the following code snippet:

try {
    int a = 5 / 0;
} finally {
    System.out.println("Cleanup");
}

medium

A. No error, code is valid

B. finally block cannot be used without catch

C. Syntax error in try block

D. Missing catch block for exception

Solution

1. Step 1: Check try-finally syntax rules

   Java allows try-finally without catch; try must be followed by catch or/and finally.

2. Step 2: Analyze exception handling

   Division by zero throws ArithmeticException at runtime, finally executes cleanup, then exception propagates to caller.

3. Step 3: Confirm no error

   The code compiles and runs validly (prints "Cleanup" before propagating exception); no syntax or structural error.

4. Final Answer:

   No error, code is valid -> Option A

5. Quick Check:

   try-finally valid without catch = D [OK]

Hint: try-finally without catch is valid [OK]

Common Mistakes:

• Thinking finally requires catch block
• Confusing runtime exception with syntax error
• Believing finally alone causes compile error

5.

Consider this method:

public static int test() {
    try {
        System.out.print("Try-");
        throw new RuntimeException();
    } catch(RuntimeException e) {
        System.out.print("Catch-");
        return 1;
    } finally {
        System.out.print("Finally-");
        return 2;
    }
}

What will System.out.print(test()); output?

hard

A. Try-Catch-Finally-1

B. Try-Catch-Finally-2

C. Try-Finally-2

D. Catch-Finally-1

Solution

1. Step 1: Trace try block execution

   Try prints "Try-" then throws RuntimeException.

2. Step 2: Catch block handles exception

   Catch prints "Catch-" and returns 1, but return is not final yet.

3. Step 3: finally block overrides return

   Finally prints "Finally-" and returns 2, overriding previous return 1.

4. Step 4: Combine printed output and return value

   Printed output is "Try-Catch-Finally-" and method returns 2, so print(test()) outputs "2" after prints.

5. Final Answer:

   Try-Catch-Finally-2 -> Option B

6. Quick Check:

   finally return overrides catch return = A [OK]

Hint: finally return overrides other returns [OK]

Common Mistakes:

• Ignoring finally return overriding catch return
• Assuming catch return is final
• Missing printed output before return