Jump Statement in Java: Break, Continue and Return

Do you know about the “Jump statement in Java“? Understanding the jump statements is a crucial step toward gaining expertise in Java. This article is all about Break, Continue, and Return statements, that will help you in increasing the efficiency and flexibility of your code. If you encounter any challenges while going through this article and require help with your Java Assignment, you have the option to enlist the services of skilled programmers at CodingZap. They are experts in the field and ready to assist you.

Let us try to find out some essential facts & details about the jump statements in Java programming languages. So, we will start our discussion with the very basic details.

What Are Jump Statements In Java?

  The Java jump statements are considered as one of the special syntax or the set of statements that has the power to skip some lines inside of the code, for the sake of solving an issue. In simple words, the Java jump statements are utilized for jumping some lines of code. Well, there are many statements in Java and one of them is the if else statement. If else statement in Java has many benefits. Like, when there are two or more paths available, then we need to use the if else statement

The above flowchart helps to analyze the jump statements in Java. While encountering any of the jump statements in Java, the flow will take a different path or branch to get executed. Hence, the jump statements are often termed “Branching Statements”.

What Are The Types Of Jump statements In Java?

  There are mainly three major variations present for Jump statements or branching statements in Java programming languages. Each one of them is used for different purposes. The types of Jump statements are the following:

1. Break Statement
2. Continue Statement
3. Return Statement

We will know all about them one by one briefly.  

How To Implement Break Statement In Java?

  The break statement in Java programming language is used to terminate any loop statement, especially an infinite loop. Whenever the compiler encounters one break statement, it will terminate the existing loop & come out of it.

One thing should be remembered, the break statement only works in especially an infinite loop, not any enclosing loops. The syntax is simple enough. Only one should need to write a break statement inside of the program. String is also an interesting concept in Java, and if you want to learn about comparing strings in Java then you can check out our article.

Code To Demonstrate The Use Of Break Statement:

 

public class Main
{
	public static void main(String[] args) {
	    System.out.println("Printing Started Untill Encounter Of Break: ");
        for (int i = 1; i < 10; i++) { // Starting A For Loop
            if (i == 5){ //Condition To Implement Break Statements
                System.out.println("--Encountered Break--");
                break; // Break Statement
            }
            System.out.println(i); // Printing Data
        }
	}
}

Steps Of The Program:

1. At first, one for-loop will be implemented. Along with some conditions provided there.
2. Now, one separate condition will be implemented inside the loop. If the condition is fulfilled, the break statement will be executed.
3. In all other cases, the for loop will print the elements one by one. We will normally print the data.

Output:

 

From the above output, we can see that the break jump statements were executed properly. Before fulfilling the condition, all the elements were getting printed.

When the condition is matched, the inner statement will be printed & break is executed. No other remaining statements are executed. So, the compiler gets out of the loop. As there is no next statement present, the program gets ended.  

How To Implement Break Statement In Java As Goto Statements?

  The break statement can be implemented as like goto statement. You will find some similarities with the Switch statement in programming languages. Once, the syntax will be encountered, it will be jumped to a specific point inside of the program. In the switch case condition, if some value gets matched, then some operation will be done. The same thing will be executed here also. If one condition is fulfilled, then the program control will be shifted to another line in the program. General Syntax: break label; Code To Demonstrate The Use Of Break Statement As Goto or Switch Case Statement:

public class Main
{
	public static void main(String[] args) {
	    for (int a = 1; a <= 2; a++) {
        first : { // Creating First Break
        second : { // Creating Second Break
            System.out.println();
            System.out.println("Data Number: " + a); // Printing Data Number
            
            if (a == 1) // Condition For First Lebel
                break first; // Break Statement
            if (a == 2) // Condition For Second Lebel
                break second; // Break Statement
        } // End Of Second Lebel
            System.out.println("Executed Second Lebel");
        } // End Of First Lebel
            System.out.println("Executed First Lebel");
        }
}
}

Steps Of The Program:  

1. First, a normal for loop will be declared where the number of iterations will be specific. The number of switch case, you want to declare, so many iterations it should have.
2. Now, the break label will be declared. We have marked the loop will execute for two iterations. So, there will be two labeled break statements inside of the existing loop. Declare it as we have done.
3. The labeled break statement will be declared along with an open brace. Inside of that, we will declare some conditions. Under those conditions, the labels will be described.
4. We will declare the next statement randomly & close the labeled break statement inside the program.

Output:

 

From the above output, we can notice that encountering a certain value, the particular statement meant for it was printed.

In the first case, as there was only one statement left after closing the labeled break statement, it was printed. The same was done for the second condition also.  

How To Implement Continue Statement In Java?

  The continue statement is one of the jump statements in Java programs. The continue statement works completely different format. It doesn’t end the loop execution. Rather, it helps to skip the iteration of the loop. Suppose, one continue statement is encountered inside of one loop. In that case, it will go back to the start of the loop & execute the next iteration of the loop. Whatever statements are present after the continue statements will not execute.

Code To Demonstrate The Use Of Continue Statement:

public class Main
{
	public static void main(String[] args) {
	    System.out.println("Printing Started: ");
        for (int i = 1; i <= 5; i++) { // Starting A For Loop
            if (i == 3){ // Condition To Implement Continue
                System.out.println("--Encountered Continue--");
                continue; // Continue Implemented
            }
            System.out.println(i); // Printing Data
        }
	}
}

Steps Of The Program:

1. One loop will be implemented first with some random conditions & starting index numbers.
2. The role of this loop will be to print the elements number one by one till the condition is satisfied. In the meantime, we have declared one condition that will work as the control statements.
3. Upon fulfilling the condition, the continued statement will be executed. But before that one print statement will also work.
4. Outside of that condition, the statement for printing the data should be placed.

Output:

The output shows that starting the current loop was printing each & every data. When the continue statement was encountered, the existing statement was present before that also, but the element data is not printed. This is because the continue statement transfers the compiler to the next iteration of the for loop. So, from that other values are printed unless the loop gets finished automatically.  

How To Implement Return Statement In Java?

  Oftentimes, the return statement is not considered as the jump statement in Java programs. Because in this case the return statement will not transfer the control to any other statement, rather it transfers control to a method. A method should be called from the main method or any other method. In that case, the return statement can be implemented inside of that method. The calling method is necessary for this jump statement to execute it. No looping statements are involved here.

Code To Demonstrate The Use Of Return Statement:

public class Main
{
	static void zapone() { // Creating Another Method
	    System.out.println("Printing In New Method");
	    return; // Returning Data
	}
	
	public static void main(String[] args) {
            zapone(); // Calling Method
            System.out.println();
            System.out.println("Printing In Main Method");
        }
	}

Steps Of The Program:

1. First, the second method will be declared other than the main method in the program.
2. We will provide one optional statement inside that to mark the entry of the method. Now, the return statement will be declared.
3. Inside the main function, that method will be called. After calling the method, another statement declared to print it as the ending statement.

 

Output:

  From the above output, we can see that the statement inside of the method declared is first. And after that, the statement inside the main method is printed. So, the control first goes to the new method & after that to the main method.

Conclusion:

As we saw, it is very important to know jump statements in Java programming language. The jump statements are declared to get easy control of the program. Sometimes, you might find a piece of code should be executed inside of the program depending upon some cases. Jump statements help to do that by declaring the condition to it. It is advisable to clear the basic Java programming skills before moving to this topic. We have witnessed that much basic information has been used on this topic. Clearing those topics before moving ahead will help you to grab the concept more easily.