Control Statements in Java (With Examples and Syntax)

What Are Control Statements in Java?

Imagine you are building a Java program that needs to check whether a user is logged in, calculate their marks, and display results only if they pass. How can your program decide what to do next, depending on the user’s input or condition? That’s where our hero Control Statements in Java comes in!

Just like how humans make decisions every day (“If it rains, take an umbrella; otherwise, stay home”), a Java program also needs a way to make decisions and control how and when certain parts of the code run. Control statements in Java give your program the power to think and act accordingly, making it smart, flexible, and efficient.

Definition

In simple terms, control statements in Java are used to control the flow of execution of a program.
They allow a program to decide which block of code to run and how many times it should run, based on specific conditions.

In other words, control statements in Java help a program make decisions and repeat actions, just like a human deciding and acting according to a situation.

Why Control Statements Are Needed?

Without control statements, a Java program would execute every line sequentially, without any condition or decision. But in real-world applications, you often need to:

• -> Check conditions (e.g., if a user enters the correct password)
• -> Repeat tasks (e.g., printing data from a list)
• -> Choose actions (e.g., open one menu or another based on user input)

So, control statements in Java make your program dynamic and responsive — it doesn’t just run blindly but reacts smartly to data or events.

Role in Decision-Making and Loop Control

1. Decision-Making Statements:
   Java provides statements like if, if-else, and switch that help your program decide what to do next based on certain conditions.
   
   Example:
   If the user’s age is above 18, allow registration; else show an error message.
   
2. Loop Control Statements:
   Sometimes, you need to repeat a block of code multiple times — for example, displaying numbers from 1 to 10 or reading multiple inputs from a user.
   Java provides loops like for, while, and do-while for this purpose.
   
   Example:
   Repeat a message 5 times or print all elements of an array.

1. If Statement :

if (condition) {

    // code to execute if the condition is true

}

2. If-Else Statement :

if (condition) {

    // code runs if true

} else {

    // code runs if false

}

3. Switch Statement

switch (variable) {

case value1:

        // code block

        break;

    case value2:

        // code block

        break;

    default:

        // code block

}

4. For loop

for (int i = 0; i < 5; i++) {

    // code block

}

5. While Loop

while (condition) {

    // code block

}

6. Do-While Loop

do {

    // code block

} while (condition);

Why We Use Control Statements in Java?

 Need for Conditional Execution

Control statements in Java are fundamental programming constructs that allow us to direct the flow of program execution based on specific conditions or requirements. Without them, programs would execute sequentially from top to bottom, line by line, with no ability to make decisions or handle different scenarios.

 Real-World Analogies:

1. Traffic Light System

 public class TrafficLight {
               public static void main(String[] args) {
               String lightColor = "red";
        
                if(lightColor.equals("green")) {
                     System.out.println("GO - Drive ahead");
                 } else if(lightColor.equals("yellow")) {
                        System.out.println("SLOW DOWN - Prepare to stop");
                  } else if(lightColor.equals("red")) {
                         System.out.println("STOP - Wait for green light");
                 } else {
                          System.out.println("Invalid light color");
        }
    }
}

2. Login Validation

public class LoginSystem {
    public static void main(String[] args) {
        String username = "admin";
        String password = "12345";

        if(username.equals("admin") && password.equals("12345")) {
            System.out.println("Access granted");
        } else {
            System.out.println("Access denied");
        }
    }
}

Compile-time vs runtime flow

Compile-time Flow

Definition: Compile-time flow refers to the static structure and sequence of code as written by the programmer. It’s determined when the code is compiled and represents all possible execution paths that exist in the source code.

Example:

public class CompileTimeExample {
    public static void main(String[] args) {
        // All these lines exist at compile-time
        System.out.println("Line 1: Start program");      // Path A
        System.out.println("Line 2: Process data");       // Path B
        System.out.println("Line 3: Validate input");     // Path C
        System.out.println("Line 4: End program");        // Path D
    }
}

Runtime Flow

Definition: Runtime flow refers to the dynamic execution path that actually occurs when the program runs. It’s determined by conditions, user input, and data values during execution, and may follow different paths through the code.

Example:

public class RuntimeExample {
    public static void main(String[] args) {
        System.out.println("Step 1: Program starts");           // Always executes
        
        int userAge = 25; // This value could change at runtime
        boolean hasLicense = true; // This could be false
        
        // Runtime decides which path to take
        if(userAge >= 18 && hasLicense)
       {
            System.out.println("Step 2: Can drive car");        // May execute
        } 
         else if(userAge >= 18) 
       {
            System.out.println("Step 2: Need driving license"); // May execute
        }
       else 
      {
            System.out.println("Step 2: Too young to drive");   // May execute
        }
        System.out.println("Step 3: Program ends");             // Always executes
    }
}

Types of Control Statements in Java

Control statements in Java are used to control the flow of execution of a program. They help in making decisions, repeating tasks, and jumping to specific parts of the program.

There are three major categories of control statements:

1. Selection Statements

These statements are used to make decisions and execute different blocks of code based on conditions.

Examples:

• -> if statement
• -> if-else statement
• -> if-else-if ladder
• -> switch statement

2. Iteration (Looping) Statements

These statements are used to execute a block of code multiple times as long as a given condition is true.

 Examples:

• -> for loop
• -> while loop
• -> do-while loop
• -> Enhanced for-each loop

3. Jump Statements

These statements are used to transfer control from one part of the program to another.

Examples:

• -> break statement
• -> continue statement
• -> return statement

Conditional / Decision-Making Statements

Conditional or decision-making statements are used in Java to execute certain parts of the code based on specific conditions. They help the program make decisions and control the flow of execution.

Types of Conditional Statements:

• -> if statement: Executes a block of code only if the given condition is true.
• -> if-else statement: Executes one block if the condition is true, and another block if it is false.
• -> nested if-else statement: An if statement inside another if or else block to check multiple conditions.
• -> switch statement: Used to execute one block of code from multiple options based on the value of an expression.

Example: Login Authentication using if-else

class LoginAuth {
    public static void main(String[] args) {
        String username = "admin";
        String password = "1234";
       if(username.equals("admin") && password.equals("1234")) 
       {
            System.out.println("Login Successful!");
        }
       else
       {
 System.out.println("Invalid Username or Password!");
        }
    }
}

Explanation:

• -> The program checks if the entered username and password match the correct credentials.
• -> If both are correct, it prints “Login Successful!”
• -> Otherwise, it displays “Invalid Username or Password!”

Looping / Iteration Statements

Loops in Java are control structures that allow a block of code to be executed repeatedly based on a specified condition. Java provides several types of loops to handle different iteration scenarios:

1. For Loop

• -> Used when the number of iterations is known beforehand.
• -> Consists of initialization, condition, and increment/decrement parts.

2. While Loop

• -> Used when the number of iterations is unknown, and the loop continues as long as a condition remains true.
• -> The condition is checked before each iteration

3. Do-While Loop

The condition is checked after the first iteration

Similar to a while loop, but it guarantees at least one execution of the loop body.

Example

public class Looping{
    public static void main(String[] args) {
        for(int i = 1; i <= 10; i++) {
            System.out.println(i);
} 
}
}

Jump / Branching Statements

Jump/branching statements in Java are used to alter the normal flow of a program execution when some conditions are met. They are used to terminate a loop, skip an iteration, or exit a method or block of code.

For Example:

public class JumpStatementsExample {

    // Method demonstrating break, continue, and return
    public static void main(String[] args) {

        System.out.println("=== Example of break statement ===");
        for (int i = 1; i <= 5; i++) {
            if (i == 3) {
                System.out.println("Breaking the loop when i = 3");
                break; // exits the loop when i = 3
            }
            System.out.println("i = " + i);
        }

        System.out.println("\n=== Example of continue statement ===");
        for (int i = 1; i <= 5; i++) {
            if (i == 3) {
                System.out.println("Skipping the iteration when i = 3");
                continue; // skips this iteration and moves to next
            }
            System.out.println("i = " + i);
        }

        System.out.println("\n=== Example of return statement ===");
        printMessage();
    }

    // Method using return statement
    static void printMessage() {
        for (int i = 1; i <= 5; i++) {
            if (i == 3) {
                System.out.println("Returning from method when i = 3");
                return; // exits the method
            }
            System.out.println("i = " + i);
        }
        System.out.println("This line will not be executed after return.");
    }
}

Output:

=== Example of break statement ===
i = 1
i = 2
Breaking the loop when i = 3

=== Example of continue statement ===
i = 1
i = 2
Skipping the iteration when i = 3
i = 4
i = 5

=== Example of return statement ===
i = 1
i = 2
Returning from the method when i = 3

Flow of Control in Java

In Java, the flow of control refers to the order in which statements are executed in a program. Normally, Java executes code from top to bottom, one line after another. But sometimes, you may want to change this order — for example, to repeat a block of code, make a decision, or skip certain steps.

This is where control flow statements come in. These statements help you manage how your program runs and what happens next based on conditions or loops. There are three main types of control flow statements in Java:

1. Sequential Flow

This is the default flow in Java. Statements are executed one after another in the same order as written in the code.

Example:

System.out.println("Start");
System.out.println("Processing");
System.out.println("End");

Output:

Start
Processing
End

Here, the statements run sequentially from top to bottom.

2. Decision-Making / Selection Statements

These statements help Java decide what to do based on a condition. If the condition is true, one block of code executes; otherwise, another block runs.

Examples include:

• -> if
• -> if-else
• -> else-if
• -> switch

Example:

int marks = 85;
if (marks >= 50)
    System.out.println("You passed!");
else
    System.out.println("You failed!");

3. Looping / Iteration Statements

When you want to repeat a block of code multiple times, loops are used.

Examples include:

• -> For
• -> While
• -> do-while

Example:

for (int i = 1; i <= 3; i++) {
    System.out.println("Count: " + i);
}

4. Jump / Branching Statements

These statements are used to alter the normal flow of the program. They can stop a loop, skip an iteration, or exit a method.

Examples:

• break
• continue
• return

Flow of Control in Java – Flowchart

Here’s how the flow of control typically works in Java:

Syntax of Control Statements in Java

Control statements in Java determine how the program’s flow is managed — whether it runs sequentially, makes a decision, repeats a block, or jumps out of it. Below are the basic syntax examples for each type of control statement, written in a simple and easy-to-understand format.

1. Decision-Making Statements

-> if Statement: Used to execute a block of code only if a condition is true.

if (condition) {
    // code to execute if the condition is true
}

-> if-else Statement: Executes one block when the condition is true, and another when it’s false.

if (condition) {
    // code if condition is true
} else {
    // code if condition is false
}

-> else-if Ladder: Used to test multiple conditions one by one.

if (condition1) {
    // code if condition1 is true
} else if (condition2) {
    // code if condition2 is true
} else {
    // code if all conditions are false
}

-> switch Statement: Used when you have multiple possible values for a variable.

switch (expression) {
    case value1:
        // code block
        break;
    case value2:
        // code block
        break;
    default:
        // default code block
}

2. Looping (Iteration) Statements

-> for Loop: Used when you know exactly how many times to loop.

for (initialization; condition; update) {
    // code to be executed
}

-> while Loop: Used when you don’t know the number of iterations in advance.

while (condition) {
    // code to execute as long as the condition is true
}

-> do-while Loop: Executes the code block once before checking the condition.

do {
    // code to be executed
} while (condition);

3. Jump / Branching Statements

-> break Statement: Exits the current loop or switch block immediately.

break;

-> continue Statement: Skips the current iteration and moves to the next one.

continue;

-> return Statement: Exits from the current method and optionally returns a value.

return value; // or just return; for void methods

Category	Statement Examples	Purpose
Decision Making	if, if-else, switch	Choose between actions
Looping	for, while, do-while	Repeat tasks
Jumping	break, continue, return	Alter normal flow

Examples of Control Statements in Java

1. if-else Example: Used when you want your program to make a decision based on a condition.

public class IfElseExample {
    public static void main(String[] args) {
        int marks = 75;

        if (marks >= 50) {
            System.out.println("You passed the exam!");
        } else {
            System.out.println("You failed the exam.");
        }
    }
}

Output:

You passed the exam!

2. switch Example: Used when you need to execute different code blocks based on multiple possible values.

public class SwitchExample {
    public static void main(String[] args) {
        int day = 3;

        switch (day) {
            case 1:
                System.out.println("Monday");
                break;
            case 2:
                System.out.println("Tuesday");
                break;
            case 3:
                System.out.println("Wednesday");
                break;
            default:
                System.out.println("Invalid day");
        }
    }
}

Output:

Wednesday

3. for Loop Example: Used when you want to repeat a block of code a fixed number of times.

public class ForLoopExample {
    public static void main(String[] args) {
        for (int i = 1; i <= 5; i++) {
            System.out.println("Count: " + i);
        }
    }
}

Output:

Count: 1  
Count: 2  
Count: 3  
Count: 4  
Count: 5

4. break and continue Example: break stops the loop immediately, while continue skips one iteration and continues with the next.

public class BreakContinueExample {
    public static void main(String[] args) {
        for (int i = 1; i <= 5; i++) {
            if (i == 3) {
                System.out.println("Skipping number 3");
                continue; // skip this iteration
            }
            if (i == 5) {
                System.out.println("Breaking the loop at 5");
                break; // exit loop
            }
            System.out.println("Number: " + i);
        }
    }
}

Output:

Number: 1  
Number: 2  
Skipping number 3  
Number: 4 
Breaking the loop at 5

Quick Tip for Beginners:

• -> Use if-else when you want to make decisions.
• -> Use a switch when you have many options to choose from.
• -> Use loops (for, while, do-while) when you want to repeat code.
• -> Use break and continue to control loop execution smartly.

Difference Between Conditional, Looping, and Branching Statements

Control statements in Java are divided into three main types: Conditional, Looping, and Branching. Each plays a specific role in how the program decides, repeats, or skips certain actions. The table below gives a simple comparison to help you understand the differences clearly.

Type	Purpose	Common Keywords / Statements	Example	Explanation
Conditional Statements	Used to make decisions based on conditions.	if, if-else, else if, switch	if (age >= 18) { System.out.println(“Eligible”); }	Checks a condition and executes code only if it’s true.
Looping Statements	Used to repeat a block of code multiple times.	for, while, do-while	for(int i=1; i<=5; i++) { System.out.println(i); }	Runs the same code multiple times until the condition becomes false.
Branching Statements	Used to change or jump the normal flow of the program.	break, continue, return	if(i==3) break;	Stops, skips, or exits from a loop or method based on conditions.

Common Mistakes in Control Statements

1. Missing a break in the switch Statement

If you forget to use the break keyword after a case, the program will “fall through” to the next case unintentionally.

2. Infinite Loops

Forgetting to update a loop variable or using incorrect conditions can cause loops to run forever.

3. Misplaced or Missing Braces { }

Without proper braces, Java may not execute multiple statements as part of the same block.

4. Logical Errors in Conditions

Using = instead of == or wrong logical operators can produce unexpected results.

Control Statements in Java Interview Questions

1. What are control statements in Java?

Control statements in Java are used to decide the flow of execution in a program. They help to make decisions, repeat tasks, or jump to a specific part of the program based on certain conditions. The main types are conditional, looping, and branching statements.

2. What is the difference between if-else and switch statements?

The if-else statement is used for complex conditions or range-based comparisons, while the switch statement is used when you have multiple fixed values to check against a single variable. A switch is generally more readable when handling many possible cases.

3. Explain looping statements in Java.

Looping statements in Java allow a block of code to be executed repeatedly until a condition becomes false. The main looping statements are for, while, and do-while. They help reduce code repetition and improve efficiency.

4. What is the use of break and continue statements?

The break statement is used to exit from a loop or switch block immediately, while the continue statement skips the current iteration and moves to the next cycle of the loop.

5. Can you use a switch statement with strings in Java?

Yes, from Java 7 onwards, the switch statement supports strings. This makes code easier to read and manage when comparing multiple string values.

6. What happens if you forget a break in a switch statement?

If you forget a break, the program continues to execute the next cases one by one until a break is found or the switch block ends. This behavior is known as “fall-through.”

7. Can loops be nested in Java?

Yes, you can use one loop inside another. This is known as nested looping. However, it should be used carefully because it can make the code more complex and affect performance.

8. What are common mistakes made with control statements?

Common mistakes include missing a break in a switch statement, creating infinite loops by using wrong conditions, missing braces {} in if-else blocks, or using = instead of == in conditions.

9. What is the difference between while and do-while loops?

In a while loop, the condition is checked before executing the loop body, so it may not run at all. In a do-while loop, the condition is checked after the loop body, so it executes at least once.

10. Can you use multiple conditions in an if statement?

Yes, multiple conditions can be combined using logical operators like && (AND), || (OR), and ! (NOT) to make complex decisions in a single if statement.

Let’s learn control statements in Java with Payilagam

Understanding control statements in Java is one of the most important steps for anyone beginning their programming journey. These statements form the foundation for writing logical, structured, and efficient Java programs. Whether it’s making decisions with if-else, running loops, or managing program flow with break and continue, mastering control statements helps you think like a real developer.

At Payilagam, we focus on helping students build strong Java fundamentals with practical, hands-on sessions. As the Best Software Training Institute in Chennai, our expert trainers ensure you not only understand the concepts but also apply them confidently in real-world scenarios.

If you’re looking to kick-start your career in programming, join our Java Training in Chennai and learn to write clean, professional-level code. Start your learning journey with Payilagam today — where knowledge meets opportunity.

FAQs on Control Statements in Java

Q1. How many types of control statements are there in Java?

There are three main types of control statements in Java:

1. Conditional Statements – used for decision-making (if, if-else, switch).
   
2. Looping Statements – used for repetition (for, while, do-while).
   
3. Branching Statements – used to change or jump the program flow (break, continue, return).

Q2. What is the difference between control flow and looping?

• -> Control flow refers to the overall order in which statements are executed in a program, including decisions, loops, and jumps.
• -> Looping, on the other hand, is a part of control flow that repeats a block of code multiple times until a condition becomes false.

Q3. What is an example of a control statement in Java?

A simple example is the if-else statement: It checks a condition and executes code accordingly. For instance:
If a student’s score is above 50, print “Pass”; otherwise, print “Fail.”
This shows how control statements help make logical decisions in a program.

Q4. Why are control statements important in Java?

Control statements are important because they make a program logical, dynamic, and efficient.
They allow developers to control how the program behaves, whether to make decisions, repeat tasks, or stop execution when needed.

Q5. Can control statements be nested in Java?

Yes, control statements in Java can be nested. This means you can use one control statement inside another, such as an if inside a for loop or a switch inside an if block. However, it’s important to keep nesting clear and limited to maintain readability and avoid confusion.