Control Statement
In Java, control statements are used to control the flow of
execution in a program. Control statements include three main categories:
selection statements, iteration statements, and jump statements. In this
response, I'll focus on selection statements.
Selection
Statements in Java
Selection statements allow you to make decisions in your
program based on certain conditions. There are two primary selection statements
in Java: `if` and `switch`.
1. **if Statement:**
The `if` statement
is used to execute a block of code if a specified condition is true. It can
also be followed by an `else` block to execute code if the condition is false.
Example:
int num = 10;
if (num > 5) {
System.out.println("The
number is greater than 5.");
} else {
System.out.println("The number is not greater than 5.");
}
In this example,
the `if` statement checks whether `num` is greater than 5, and if it is, it
prints the first message; otherwise, it prints the second message.
In Java, the `for` loop has several variations to cater to
different use cases. Each version of the `for` loop serves a specific purpose
and provides flexibility in controlling the loop execution. Here are the main
variations of the `for` loop in Java:
I. **Basic `for` Loop:**
- The basic `for`
loop is the one mentioned earlier, which consists of three parts:
initialization, condition, and update.
- Syntax:
for
(initialization; condition; update) {
// code to be
executed
}
Example:
for (int i = 1; i
<= 5; i++) {
System.out.println("Iteration " + i);
}
for (int i = 0; i < 5; i++) {
System.out.println("Iteration " + i);
}
This is the most
common form of a `for` loop. It initializes a variable `i` to 0, checks if `i`
is less than 5, and increments `i` by 1 after each iteration.
Output:
Iteration 0
Iteration 1
Iteration 2
Iteration 3
Iteration 4
II. **Enhanced `for` Loop (for-each Loop):**
- The enhanced
`for` loop is used for iterating over elements in arrays or collections without
the need for explicit indexing.
- It is
particularly useful when you want to iterate through all elements in a
collection sequentially.
- Syntax:
for (ElementType
element : collection) {
// code to be
executed for each element
}
Example with an
array:
int[] numbers = {1,
2, 3, 4, 5};
for (int num :
numbers) {
System.out.println("Number: " + num);
}
for-each` loop (enhanced `for` loop)
int[] numbers = {1,
2, 3, 4, 5};
for (int number :
numbers) {
System.out.println("Number: " + number);
}
This loop is used
specifically for iterating over collections or arrays. It doesn't require
explicit initialization, condition, or update statements. Instead, it directly
accesses the elements of the array or collection.
Output:
Number: 1
Number: 2
Number: 3
Number: 4
Number: 5
III. **Infinite `for` Loop:**
- A `for` loop can
be used to create an infinite loop by omitting the condition.
- This is often used
when you want a loop to continue indefinitely until a break statement is
encountered.
- Syntax:
for (;;) {
// code to be
executed indefinitely
}
Example of an
infinite loop with a break condition:
int i = 1;
for (;;) {
System.out.println("Iteration " + i);
if (i == 5) {
break; //
exit the loop when i reaches 5
}
i++;
}
IV Nested `for` Loop
- You can have
`for` loops inside other `for` loops, allowing you to create nested loops for
more complex iterations.
- Nested loops are
often used for iterating through two-dimensional arrays or performing
multi-level iterations.
- Example:
for (int i = 1; i
<= 3; i++) {
for (int j = 1;
j <= 3; j++) {
System.out.println("i = " + i + ", j = " + j);
}
} **Infinite `for` loop:**
for (;;) {
System.out.println("This will run indefinitely");
}
Nested `for` loop
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
System.out.println("i: " + i + ", j: " + j);
}
}
This is an example of a nested `for` loop. It contains one `for` loop inside another. In this case, it will print all combinations of `i` and `j` from 0 to 2.
Output:
i: 0, j: 0
i: 0, j: 1
i: 0, j: 2
i: 1, j: 0
i: 1, j: 1
i: 1, j: 2
i: 2, j: 0
i: 2, j: 1
i: 2, j: 2
This `for` loop has
no initialization, condition, or update statements. It will run indefinitely
until interrupted.
(Note: You would
usually use a conditional statement inside an infinite loop to provide a way to
exit it.)
Output: This will
keep printing "This will run indefinitely" endlessly until manually
stopped.
These are some common variations of the `for` loop in Java.
They serve different purposes and are used in various scenarios based on the
specific requirements of your program.
2. **switch Statement:**
The `switch`
statement is used to select one of many code blocks to be executed based on the
value of a given expression.
Example:
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");
}
In this example,
the `switch` statement evaluates the value of `day` and executes the code block
corresponding to the matching case (in this case, "Wednesday").
Iteration Statements
In Java, iteration statements (also known as loops) are used
to repeatedly execute a block of code as long as a certain condition is true or
for a specified number of times. Java provides several types of iteration
statements, including:
1. **for loop**:
The `for` loop is a commonly used iteration
statement in Java. It has the following syntax:
Example
for
(initialization; condition; update) {
// code to be
executed repeatedly
}
Here's an example
of a `for` loop that prints numbers from 1 to 5:
Example
for (int i = 1; i
<= 5; i++) {
System.out.println(i);
}
- Syntax:
for
(initialization; condition; update) {
// code to be executed
}
- Example:
for (int i = 1; i
<= 5; i++) {
System.out.println("Iteration " + i);
}
Output:
Iteration 1
Iteration 2
Iteration 3
Iteration 4
Iteration 5
2. **while loop**:
The `while` loop repeats a block of code
as long as a specified condition is true. Its syntax is as follows:
Example
while (condition) {
// code to be
executed repeatedly
}
Here's an example
of a `while` loop that counts from 1 to 5:
Example
int i = 1;
while (i <= 5) {
System.out.println(i);
i++;
}
- Syntax:
```java
while (condition)
{
// code to be
executed
}
- Example:
int i = 1;
while (i <= 5)
{
System.out.println("Iteration " + i);
i++;
}
Output:
Iteration 1
Iteration 2
Iteration 3
Iteration 4
Iteration 5
3. **do-while loop**
The `do-while` loop is similar to the
`while` loop, but it guarantees that the code block is executed at least once
before checking the condition. Its syntax is as follows:
Example
do {
// code to be
executed repeatedly
} while
(condition);
Here's an example
of a `do-while` loop that prompts the user for input until they enter a valid
number:
Example
Scanner scanner =
new Scanner(System.in);
int number;
do {
System.out.print("Enter a number: ");
number =
scanner.nextInt();
} while (number
<= 0);
System.out.println("You entered a positive number: " +
number);
These iteration statements are fundamental in Java for
implementing repetitive tasks and controlling the flow of your program. You can
choose the type of loop that best suits your specific requirements based on the
condition and the structure of your code.
In Java, iteration statements, also known as loops, allow
you to execute a block of code repeatedly as long as a specified condition is
true. There are several types of iteration statements in Java, including `for`,
`while`, and `do-while` loops.
Syntax:-
do {
// code to be
executed
} while
(condition);
- Example:
int i = 1;
do {
System.out.println("Iteration " + i);
i++;
} while (i <=
5);
Output:
Iteration 1
Iteration 2
Iteration 3
Iteration 4
Iteration 5
Jump statements
In Java, jump statements are used
to control the flow of execution within a program. There are three primary jump
statements: `break`, `continue`, and `return`. Each of these statements serves
a different purpose and can be used in various scenarios to control the flow of
your code.
In Java, jump statements allow you
to alter the normal flow of control in a program. There are three main types of
jump statements: `break`, `continue`, and `return`.
1. `break` Statement:
- The `break`
statement is primarily used to exit a loop prematurely. It is commonly used in
`for`, `while`, and `do-while` loops.
- When the `break`
statement is encountered within a loop, it immediately terminates the loop, and
control is transferred to the statement immediately following the loop.
Example: Using
`break` in a for loop
for (int i = 1; i
<= 10; i++) {
if (i == 5) {
break; //
Exit the loop when i equals 5
}
System.out.println(i);
}
In this example,
the loop will print numbers from 1 to 4 and then exit when `i` equals 5.
The `break` statement is used to exit a loop or switch
statement prematurely. When encountered, it immediately terminates the
innermost loop or switch block, and the program resumes execution with the
statement immediately following the loop or switch.
Syntax:
break;
Example:
public class BreakExample {
public static void
main(String[] args) {
for (int i =
1; i <= 5; i++) {
if (i ==
3) {
break;
// exit the loop when i equals 3
}
System.out.println(i);
}
}
}
Output:
1
2
In this example, the loop will run from `i = 1` to `i = 5`.
When `i` equals `3`, the `break` statement is executed, causing the loop to
terminate prematurely. As a result, only `1` and `2` are printed.
2. `continue` Statement:
- The `continue`
statement is used to skip the rest of the current iteration and proceed to the
next iteration of a loop.
- It is often used
when you want to skip certain iterations based on a condition without
terminating the entire loop.
Example: Using
`continue` in a for loop
for (int i = 1; i
<= 10; i++) {
if (i % 2 == 0)
{
continue;
// Skip even numbers
}
System.out.println(i);
}
In this example,
the loop will print only the odd numbers from 1 to 10, skipping the even ones.
The `continue` statement is used to force the next iteration
of a loop without executing the statements that follow it in the loop body.
It's particularly useful when you want to skip certain iterations based on a
condition.
Syntax:
continue;
Example:
public class ContinueExample {
public static void
main(String[] args) {
for (int i =
1; i <= 5; i++) {
if (i ==
3) {
continue; // skip the rest of the loop body and go to the next iteration
when i equals 3
}
System.out.println(i);
}
}
}
Output:
1
2
4
5
In this example, when `i` equals `3`, the `continue`
statement is executed. This causes the loop to immediately jump to the next
iteration without executing any statements below it in the loop body.
3. `return` Statement:
- The `return`
statement is used to exit a method and optionally return a value to the caller.
It can also be used to terminate a constructor or an instance initializer
block.
- When a `return`
statement is encountered within a method, it immediately exits the method, and
control is returned to the caller.
Example: Using
`return` in a method
public int add(int
a, int b) {
int sum = a +
b;
return sum; //
Return the sum to the caller
}
The `return` statement is used to exit a method prematurely
and return a value to the caller. It can be used in methods that have a return
type other than `void`.
Syntax:
return expression;
Example:
public class ReturnExample {
public static int
sum(int a, int b) {
return a + b;
// returns the sum of a and b
}
public static void
main(String[] args) {
int result =
sum(3, 4);
System.out.println("Result: " + result);
}
}
Output:
Result: 7
In this example, the `sum` method
takes two arguments (`a` and `b`) and returns their sum. When the method is
called with `sum(3, 4)`, it calculates the sum and uses the `return` statement
to pass the result back to the caller.
Remember, the `return` statement
can only be used within methods, and the type of the returned value must match
the declared return type of the method.
These jump statements provide
flexibility in controlling the flow of your Java programs, allowing you to
handle different scenarios efficiently.
Comments
Post a Comment