Greatest Of Three Numbers In Java Using Nested If

When working with data, comparing values is a fundamental operation. Often, you need to identify the largest among a set of numbers to make decisions or process information further. In this article, you will learn how to determine the greatest of three numbers in Java using nested if statements, a common conditional logic construct.

Problem Statement

The challenge is to find the single largest number among three distinct numerical inputs. This is a basic but essential programming problem that helps in understanding conditional logic and comparison operators. Identifying the maximum value is crucial in various computational tasks, from simple data analysis to complex algorithm design.

Example

Consider three numbers: 10, 25, and 15. The greatest number among these three is 25.

Background & Knowledge Prerequisites

To understand this article, readers should have a basic grasp of:

• Java Syntax Fundamentals: Understanding how to declare variables and write basic statements.
• if-else Statements: Knowledge of how conditional statements work to execute code blocks based on conditions.
• Comparison Operators: Familiarity with operators like >=, >, etc., used for comparing values.
• Scanner Class: How to use the Scanner class for reading user input from the console.

Use Cases or Case Studies

Finding the greatest of numbers is applicable in many real-world scenarios:

• Ranking Systems: Determining the highest score in a competition or exam among a few participants.
• Data Validation: Checking if a value exceeds a certain threshold compared to two others.
• Financial Analysis: Identifying the highest performing stock or investment among a small selection.
• Sensor Data Processing: Finding the peak reading from three different sensors.
• Game Development: Deciding which player has the highest health or score in a small-scale comparison.

Solution Approaches

We will focus on using nested if statements to solve this problem.

Approach 1: Using Nested If Statements

This approach uses if statements embedded within other if or else blocks to compare numbers sequentially and determine the largest.

// Greatest of Three Numbers using Nested If
import java.util.Scanner;

// Main class containing the entry point of the program
public class Main {
    public static void main(String[] args) {
        // Step 1: Initialize Scanner for input
        Scanner input = new Scanner(System.in);

        // Step 2: Prompt user for three numbers
        System.out.print("Enter first number: ");
        int num1 = input.nextInt();

        System.out.print("Enter second number: ");
        int num2 = input.nextInt();

        System.out.print("Enter third number: ");
        int num3 = input.nextInt();

        // Step 3: Implement nested if-else logic to find the greatest
        int greatest;

        if (num1 >= num2) {
            // If num1 is greater than or equal to num2, compare num1 with num3
            if (num1 >= num3) {
                greatest = num1; // num1 is the greatest
            } else {
                greatest = num3; // num3 is the greatest
            }
        } else {
            // If num2 is greater than num1, compare num2 with num3
            if (num2 >= num3) {
                greatest = num2; // num2 is the greatest
            } else {
                greatest = num3; // num3 is the greatest
            }
        }

        // Step 4: Display the result
        System.out.println("The greatest number is: " + greatest);

        // Step 5: Close the scanner
        input.close();
    }
}

Run

Sample Output:

Enter first number: 10
Enter second number: 25
Enter third number: 15
The greatest number is: 25

Stepwise Explanation:

1. Input Collection: The program starts by initializing a Scanner object to read integer inputs from the user for three numbers (num1, num2, num3).
2. First Level Comparison (if (num1 >= num2)):

• It first checks if num1 is greater than or equal to num2.
• If num1 >= num2 is true: This means num1 is potentially the greatest (or num1 equals num2). The program then proceeds to an inner if statement to compare num1 with num3.
• Inner if (num1 >= num3): If num1 is also greater than or equal to num3, then num1 is confirmed as the greatest.
• Inner else: If num1 is not greater than num3 (meaning num3 is greater), then num3 is the greatest.
• If num1 >= num2 is false (else block): This means num2 is strictly greater than num1. The program then proceeds to an inner if statement to compare num2 with num3.
• Inner if (num2 >= num3): If num2 is greater than or equal to num3, then num2 is confirmed as the greatest.
• Inner else: If num2 is not greater than num3 (meaning num3 is greater), then num3 is the greatest.

1. Result Display: After the nested if-else block, the greatest variable holds the maximum value, which is then printed to the console.
2. Resource Cleanup: The Scanner object is closed to release system resources.

Conclusion

Using nested if statements is a straightforward way to compare multiple values sequentially. While it effectively solves the problem of finding the greatest of three numbers, it can become complex and less readable if the number of values to compare increases significantly. For a small, fixed number of comparisons, it provides a clear demonstration of conditional logic.

Summary

• The problem involves identifying the largest value among three given numbers.
• Nested if statements provide a structured way to compare numbers sequentially.
• The logic branches based on initial comparisons, leading to further comparisons until the greatest number is isolated.
• This approach is intuitive for a small, fixed set of comparisons, helping to build foundational understanding of conditional programming.