Branching Statement in Java

Branching statements in Java provide control over the flow of execution in a program. They allow you to alter the normal sequence of statements and handle exceptional situations. The main branching statements in Java are return, break, continue, throw, and try-catch. Let's explore each of these statements:

1. return statement

The return statement is used to exit a method and optionally return a value to the caller.
Syntax: return [expression];
When encountered, the return statement immediately terminates the execution of the current method and transfers control back to the caller.
Example:

public int sum(int a, int b) {
    return a + b; // Returns the sum of a and b
}

2. break statement

The break statement is used to terminate the enclosing loop or switch statement.
Syntax: break;
When encountered inside a loop or switch statement, the break statement immediately exits the loop or terminates the switch statement, and control is transferred to the next statement following the loop or switch.
Example

for (int i = 1; i <= 10; i++) {
    if (i == 5) {
        break; // Exits the loop when i is 5
    }
    System.out.println(i);
}

3. continue statement

The continue statement is used to skip the remaining code in the current iteration of a loop and move to the next iteration.
Syntax: continue;
When encountered inside a loop, the continue statement causes the loop to immediately jump to the next iteration, skipping any remaining code within the loop for the current iteration.
Example:

for (int i = 1; i <= 10; i++) {
    if (i % 2 == 0) {
        continue; // Skips the even numbers
    }
    System.out.println(i);
}

throw statement

The throw statement is used to manually throw an exception in Java.
Syntax: throw [Throwable];
The throw statement is typically used within an if statement or a method to indicate exceptional conditions or errors. It transfers control to the nearest catch block in the calling stack.
Example:

public void validateAge(int age) {
    if (age < 18) {
        throw new IllegalArgumentException("Age must be 18 or above");
    }
    // ...
}

try-catch statement

The try-catch statement is used to handle exceptions in Java.
Syntax:

try {
    // Code that may throw an exception
} catch (ExceptionType e) {
    // Code to handle the exception
}

The try block contains the code that may throw an exception, and the catch block catches and handles the exception. Multiple catch blocks can be used to handle different types of exceptions.

try {
    int result = divide(10, 0); // May throw an ArithmeticException
    System.out.println(result);
} catch (ArithmeticException e) {
    System.out.println("Error: " + e.getMessage());
}

These branching statements in Java provide you with the ability to control the flow of execution, handle exceptions, and customize the behavior of your program.

Next Article ❯