Selection Statement in Java

In Java, a selection statement is a programming technique that allows us to manage how the program executes depending on different conditions. It enables the ability to decide what to do and execute alternative code blocks based on the actual value of a given condition or specified conditions.

Types of Selection Statements in Java:

1. if statement
2. if-else Statement
3. Nested if Statement
4. if-else if-else Statement
5. Switch Statement

i. if statement:

Among Java's basic control flow statements, the if statement allows us to run a block of code if a given condition is true. The code within the if block is skipped if the condition is evaluated too false.

Syntax:

if(condition)
{
//If the condition is true, then the code will be executed
}

Filename: IfStatement.java

import java.util.Scanner;
public class IfStatement
{
public static void main(String[] args)
{
Scanner sc = new Scanner(System.in);
int x=29;
System.out.print("Enter a number: ");
int y = sc.nextInt();
if(y<x) // if the condition is true, then the code will be executed
{
System.out.println("The number is less than " +x);
}
}
}

Output:

Enter a number: 16
The number is less than 29

Advantages:

• We can improve the readability and understanding of the code for different developers by using well-organized if statements with different conditions and proper indentation.
• Suppose statements can be used to determine which code blocks are being executed depending on the current conditions when debugging the code. It can be useful in identifying and resolving logical errors.

Disadvantages:

• While multiple conditions can be handled with else-if statements, which is better than if statements, there are situations in which a switch statement might be more suitable and readable.
• It can result in code duplication to have similar conditions in several if statements. Because we might need to update the logic in different places if it changes, this could make it more difficult to maintain the code.

ii. if-else Statement:

Java's if-else statement is a statement of control flow that allows us to execute a single block of code in the event that a condition is false, and a different block of code ensures that the given condition is true. In the example that the initial condition is not satisfied, it provides an alternative path for the program to execute.

Syntax:

if(condition)
{
//If the condition is true, then the code will be executed
}
else
{
//If the condition is false, then the code will be executed here
}

Filename: IfElseStatement.java

import java.util.Scanner;
public class IfElseStatement
{
public static void main(String[] args)
{
Scanner sc = new Scanner(System.in);
int x=29;
System.out.print("Enter a number: ");
int y = sc.nextInt();
if(y<x) // if the condition is true, then the code will be executed
{
System.out.println("The number is less than " +x);
}
else // if the condition is false, then the code will be executed here
{
System.out.println("The number is greater than " +x);
}
}
}

Output:

Enter a number: 31
The number is greater than 29

Advantages:

• If the first condition is not satisfied, the if-else statement gives the program an alternative solution. It enables you to manage various conditions and situations.
• A complicated decision-making can be produced by combining several if-else statements. It makes the program more flexible and enables us to handle different kinds of conditions.

Disadvantages:

• The code may get more complicated and challenging to read because the number of paths and conditions increases. It could make maintenance more difficult.
• It is possible to ignore the else branch in complicated if-else structures, which could result in unexpected behavior if none of the requirements are satisfied.

iii. Nested if Statement:

In Java, an if statement that appears inside another if statement is called a Nested if statement. It indicates that the code block contains an if statement that is executed if the condition of an outer if statement is applied. In other words, the code block is controlled by the outer if statement, which contains the inner if statement nested inside it.

Syntax:

if (condition1)
{
// Here, the code will be executed if the condition1 is true
if (condition2)
{
// Here, the code will be executed if the condition2 is true
}
else
{
// Here, the code will be executed if any of the condition is false
}
}

Filename: NestedIf.java

import java.util.Scanner;
public class NestedIf
{
public static void main(String []args)
{
Scanner sc=new Scanner(System.in);
System.out.print("Enter a number: ");
int a=sc.nextInt();
if( a < 1000 ) // Here the code will be executed if condition "a > 1000" is true
{
System.out.println("You have entered a number which is less than 1000.");
if(a > 500) //Here the code will be executed if condition "a > 500" is true
{
System.out.println("You have entered a number which is greater than 500.");
}
}
else //Here, the code will be executed if any of the conditions is false
{
System.out.println("You have entered a number which is greater than 1000.");
}
}
}

Output:

Enter a number: 777
You have entered a number which is less than 1000.
You have entered a number which is greater than 500.

Explanation:

When we enter the number, based on the entered number, it will go to the if statement; if the condition satisfies in the outer, then it prints the output; if not, then it will go into the inner if statement and print the output based on the condition, in the else prints the output if both inner and outer if statements not satisfy.

Advantages:

• More complicated decision-making logic is possible with nested if statements. It is possible to handle a large range of instances by evaluating various conditions in a structured manner.
• Nestled if statements can be useful in preventing unnecessary evaluations. For example, the program can completely ignore the inner conditions if one of the outside conditions is false.

Disadvantages:

• While handling various conditions can be executed with nested if statements, there are situations where switch statements, or different control flow constructs might be more suitable and readable.
• It can be more difficult to debug nested if statements when we have to carefully go through the code to determine which condition or conditions are producing a particular behavior.

iv. if-else-if-else Statement:

In Java, we may use the if-else-if-else statement as a control flow construct to check several conditions and run separate code blocks according to which condition is true. It offers an alternative path that the program can take in the occurrence that the first condition is not satisfied.

Syntax:

if (condition1)
{
// Here, the code will be executed if the condition1 is true
}
else if (condition2)
{
// Here, the code will be executed if the condition2 is true
}
else
{
// Here, the code will be executed if any of the conditions are true
}

Filename: IfElseIfElse.java

import java.util.Scanner;
public class IfElseIfElse
{
public static void main(String[] args)
{
Scanner scanner = new Scanner(System.in);
System.out.print("Enter your Percentage: ");
int per = scanner.nextInt();
if (per >= 90 && per <= 100)
{
System.out.println("You have scored O grade");
}
else if (per >= 80 && per < 90)
{
System.out.println("You have scored A grade");
}
else if (per >= 70 && per < 80)
{
System.out.println("You have scored B grade");
}
else if (per >= 60 && per < 70)
{
System.out.println("You have scored C grade");
}
else if (per >= 0 && per < 60)
{
System.out.println("You have scored D grade");
}
else
{
System.out.println("Please enter a valid Percentage between 0 and 100.");
}
}
}

Output:

Enter your Percentage: 72
You have scored B grade
Enter your Percentage: 108
Please enter a valid Percentage between 0 and 100.

Advantages:

• It enables us to analyze several conditions in a structure's manner. An additional condition to be verified, which is provided by each else if block, enabling a more complicated decision-making process.
• If-else-if-else's structure enables hierarchical decision-making. The appropriate block of code is executed when the first true condition is satisfied. Conditions are tested one after the other. It is helpful in managing various conditions according to their importance.

Disadvantages:

• Code duplication can occur from checking the same requirements more than once in several else-if statements. The redundancy can improve the possibility of introducing errors and make maintaining the codebase more difficult.
• In some conditions, if-else-if-else statements might not be the best suitable option. Other techniques like switch statements or polymorphism may provide better alternatives in complicated decision-making conditions.

v. Switch Statement:

Java's switch statement is a control flow statement that enables one to select which among multiple code blocks to execute depending on a variable's or expression's value. It provides an easy method for managing several conditions, each with a unique set of rules. When there is a variable that has more than one possible value, and we want to execute different code for each value, the switch statement will be useful.

Syntax:

switch (expression)
{
case1:
// Here, the code will be executed if expression == case1
break;
case2:
// Here, the code will be executed if expression == case2
break;
default:
// Here, the code will be executed if no cases are matched
}

Filename: Switch.java

import java.util.Scanner;
public class Switch
{
public static void main(String[] args)
{
Scanner sc = new Scanner(System.in);
System.out.print("Choose a number between 1 to 7: ");
int a = sc.nextInt();
String day;
switch (a)
{
case 1: // Here the code will be executed if a == case1
day = "Sunday";
break;
case 2: // Here the code will be executed if a == case2
day = "Monday";
break;
case 3: // Here the code will be executed if a == case3
day = "Tuesday";
break;
case 4: // Here the code will be executed if a == case4, same for the remaining cases also
day = "Wednesday";
break;
case 5:
day = "Thursday";
break;
case 6:
day = "Friday";
break;
case 7:
day = "Saturday";
break;
default: // Here, the code will be executed if no cases are matched with the expression "a."
day = "invalid day";
}
System.out.println("It is a " + day);
}
}

Output:

Choose a number between 1 to 7: 7
It is a Saturday
Choose a number between 1 to 7: 8
It is a invalid day

Advantages:

• A simple and understandable method of expressing multi-way branching depending on a variable's value is through switch statements. Compared to a string of nested if-else statements, the structure is frequently more simplified and understandable.
• In some cases, switch statements can be more effective than several if-else statements. Switch statements can be made more effective by the Java compiler, especially when handling a lot of cases.

Disadvantages:

• An enumerated type, the String class, or a primitive data type (byte, short, int, or char) may be used as the expression in a switch statement. It may be much less adaptable in some conditions because of this limitation.
• Switch statements cannot directly evaluate Boolean expressions in comparison to if-else statements. Every case is founded on equality, which, in some circumstances, can be limited.

Why we need a Selection Statement in Java:

i. Complex Decision Making:

Nestled selection statements or the combination of if, else if, and else can be used to handle a number of conditions and cases in more complicated decision-making conditions. When a program must handle several conditions or situations in a more detailed manner, and the decision logic in the selection statement has many conditions, it is called Complex Decision Making in Java. It frequently involves combining if, else if, and else structures with nested selection statements to create a framework that handles various kinds of possible conditions.

ii. Control Flow:

In the program, selection statements determine how it is executed. Different sections of the code can run in different methods depending on the conditions, providing flexibility and adaptability. The sequence in which statements in a program are executed is called control flow. Which Java code block should be performed based on specific conditions is determined by control flow in selection statements (such as if, else if, and else statements). Control flow helps in controlling the program flow according to the evaluation of expressions or conditions.

iii. Error Handling:

Java selection statement error handling involves predicting and controlling conditions in which errors or unexpected conditions might arise while a program is being executed. Because selection statements cannot deal with errors directly, we can use them to construct logic that responds to particular error conditions. Selection statements are useful for identifying and managing error conditions. For example, we can verify user input and modify the response accordingly.

iv. Decision Making:

In Java Selection statements, the term "decision-making" describes a program's ability to decide or make decisions according to specific conditions. We can manage the program's flow by using selection statements, like if, else if, and else, which execute different code blocks based on the actual value of a given condition. Writing programs that are responsive and flexible needs this capability. Decisions must frequently be made by the program based on data, user interaction, or other factors. We may express these decision-making procedures in a logical and structured manner by using Selection statements.

v. Conditional Execution:

The ability to execute particular code blocks depending on whether or not specific conditions are satisfied is referred to as conditional execution in Java selection statements. If, else if, and else are examples of selection statements that allow us to control how the program executes conditionally. Certain code blocks are executed or skipped based on how a condition is determined. Depending on whether a given situation is true or false, selection statements allow us to execute different code blocks. It allows the program to determine what to perform and adaptively respond to various conditions.

vi. Handling Complex Cases:

Statements of selection are useful in managing various situations or conditions. Different actions or behaviors can be specified for each situation by checking different conditions.

Limitations:

• An enumerated type, the String class, or a primitive data type (byte, short, int, or char) may be used as the expression in a selection statement.
• Selection statements do not directly involve range checks. Checking for a variety of values is difficult because each case in a switch statement needs to be assigned an individual value.
• If a break statement is not used in a switch statement, cases within the switch statement don't flow to the next cases. If it is not utilized carefully, it may result in errors, and missing to include a break statement can result in unexpected errors.
• Selection statements have less usage with objects, but they perform well with enumerated and primitive data types. There are limitations to using objects in selection statements, and object value comparisons usually it is more complex.
• In some situations, a selection statement expression may be evaluated just once, and the result of the following cases is compared to the initial results. It may result in limitations, particularly if the expression involves complicated computation or mutable variables.
• Having a lot of nested statements might reduce the code clarity and might increase the chance of errors.

Conclusion:

In conclusion, Java's selection statements are important components that allow programmers to control how their program behaves in response to specified conditions. These statements, which include a switch, if, else if, if-else-if-else, and nested if, provide several types of methods for handling different conditions in a program and implementing decision-making logic. Programmers can make decisions by using selection statements to evaluate conditions and decide which code block to execute. They are essential in controlling the program's control flow, which allows it to respond quickly to various situations.