Branching Statements in Java

Branching statements are the statements used to jump the flow of execution from one part of a program to another. The branching statements are mostly used inside the control statements. Java has mainly three branching statements, i.e., continue, break, and return. The branching statements allow us to exit from a control statement when a certain condition meet.

In Java, continue and break statements are two essential branching statements used with the control statements. The break statement breaks or terminates the loop and transfers the control outside the loop. The continue statement skips the current execution and pass the control to the start of the loop. The return statement returns a value from a method and this process will be done explicitly.

The break Statement

The labeled and unlabeled break statement are the two forms of break statement in Java. The break statement is used for terminating a loop based on a certain condition. Let's understand each form of break statement one by one with their examples.

1) Unlabeled break statement

The unlabeled break statement is used to terminate the loop that is inside the loop. It is also used to stop the working of the switch statement. We use the unlabeled break statement to terminate all the loops available in Java.

Syntax:

for (int; testExpression; update){
	//Code
	if(condition to break){
		break;
	}
}

Let's take an example to understand how the unlabeled break statement works to terminate the loop.

UnlabeledBreakExample.java

class UnlabeledBreakExample {
    public static void main(String[] args) {

        String[] arr = { "Shubham", "Anubhav", "Nishka", "Gunjan", "Akash" };
        String searchName = "Nishka";

        int j;
        boolean foundName = false;

        for (j = 0; j < arr.length; j++) {
            if (arr[j] == searchName) {
                foundName = true;
                break;
            }
        }

        if (foundName) {
            System.out.println("The name " + searchName + " is found at index " + j);
        } else {
            System.out.println("The name " +searchName + " is not found in the array");
        }
    }
}

Output:

Explanation

In the above program, we search for a name in an array of type string. The break keyword is used in the for loop using a conditional statement. When the condition is met for the search name, the break statement exit us from the loop and pass the control flow to the outside of the loop.

2) Labeled break statement

Labeled break statement is another form of break statement. If we have a nested loop in Java and use the break statement in the innermost loop, then it will terminate the innermost loop only, not the outermost loop. The labeled break statement is capable of terminating the outermost loop.

Syntax:

label:
for (int; testExpression; update){
	//Code
	for (int; testExpression; update){
		//Code
		if(condition to break){
			break label;
		}
	}
}

Let's take an example to understand how the labeled break statement works to terminate the loop.

LabeledBreakExample.java

class LabeledBreakExample {
    public static void main(String[] args) {
         int j, k;
		
        // Labeling the outermost loop as outerMost   
        outerMost:
        for(j=1; j<5; j++) {

            // Labeling the innermost loop as innerMost
            innerMost:
            for(k=1; k<3; k++ ) {
                System.out.println("j = " + j + " and k = " +k);
             
                // Terminating the outemost loop 
                if ( j == 3)
                    break outerMost;
            }
        }
    }
}

Output:

Explanation

In the above program, we have created nested for loop. In the innermost loop, we set a condition to break the outermost loop. When the condition is met, the break statement terminates that loop whose label is associated with the break keyword.

The continue Statement

The continue statement is another branching statement used to immediately jump to the next iteration of the loop. It is a special type of loop which breaks current iteration when the condition is met and start the loop with the next iteration. In simple words, it continues the current flow of the program and stop executing the remaining code at the specified condition.

When we have a nested for loop, and we use the continue statement in the innermost loop, it continues only the innermost loop. We can use the continue statement for any control flow statements like for, while, and do-while.

Syntax

control-flow-statement;    
continue;

ContinueExample.java

public class ContinueExample {  
	public static void main(String[] args) {  
		//Declare variables   
		int x = 1;
		int y = 10;  
		//Using do while loop for using contiue statement   
		do{  
			if(x == y/2){                   
                			x++;  
				continue;//The continue statement skips the remaining statement  
			}  
			System.out.println(x);  
			x++;  
		}while(x <= y);  
	}  
} 

Output:

Explanation

In the above program, we use a do-while loop. We declare two variables x and y. The do-while loop executes until the x<=y. In the do block of the loop, we check whether the x is equal to y/2 or not. If the condition is matched, the statement skips the print and increment statement and continue the loop.

The return Statement

The return statement is also a branching statement, which allows us to explicitly return value from a method. The return statement exits us from the calling method and passes the control flow to where the calling method is invoked. Just like the break statement, the return statement also has two forms, i.e., one that passes some value with control flow and one that doesn't.

Syntax

Or,

Note: The type of the returned value should be matched with the type of the method's declared returned value.

ReturnExampleWithoutValue.java

class ReturnExampleWithoutValue { 
    //Declare calling method
    void increment(int number) 
    { 
        if (number < 10) 
            return; //pass the control flow to where this method call
        number++;
        System.out.println(number);
    } 
    public static void main(String[] args) 
    { 
        ReturnExampleWithoutValue obj = new ReturnExampleWithoutValue();
        obj.increment(4);
        System.out.println("In main");
        obj.increment(12);
        System.out.println("In main");
    } 
}

Output:

Explanation

In the above code, we create a class having the increment() method. In this method, we check whether the number smaller than 10 or not. If the number is less than 10, the return statement passes the control flow to where the method calls and doesn't execute the increment and print statement.

ReturnExampleWithValue.java

class ReturnExampleWithValue { 
    int sum(int x, int y) 
    { 
        int sum = 0; 
        sum = x + y; 
        return sum; 
    }	
    int difference(int x, int y) 
    { 
        int diff = 0; 
        diff = x - y; 
    
        return diff; 
    }	
    public static void main(String[] args) 
    { 
        ReturnExampleWithValue obj = new ReturnExampleWithValue();	
        System.out.println("The sum of 10 and 3 is : "+ obj.sum(10, 3));
        System.out.println("The difference between 10 and 3 is : "+ obj.difference(10, 3));
    } 
}

Output:

Explanation

In the above program, we create two methods that return the integer value. The first method returns the sum of numbers and the second method returns the difference between the numbers. In both methods, an integer value is associated with the return statement to pass the value with the control flow to where the method calls. In the main method, both the methods are called from the print statement, so the print statement directly prints the value returned from the methods.

Next TopicCollections Sort in Java 8

← prev next →