Java Program to Check if a Number is Positive or Negative: A Step-by-Step Guide

When you’re starting out with Java programming, one of the fundamental tasks you’ll encounter is determining whether a number is positive, negative, or zero. This simple problem is an excellent exercise for beginners, helping you to grasp control structures like if-else statements in Java. In this article, we’ll dive deep into creating a Java Program to Check if a Number is Positive or Negative, break down the logic step-by-step, and provide a dry run to ensure you fully understand how the program works.

But before we get into the nitty-gritty, let’s first understand the problem statement clearly.

Understanding the Problem Statement

The task is straightforward: You need to write a Java program that reads an integer input and determines whether the number is positive, negative, or zero.

Here’s the breakdown of what each term means:

• Positive Number: Any number greater than zero.
• Negative Number: Any number less than zero.
• Zero: The number itself, which is neither positive nor negative.

This simple classification is critical in various applications, such as error handling, numerical computations, and user input validations.

Also Read: Copy Array | Copying Array and its Elements | Java Programming | Code with Kamlesh

Basic Concept of if-else Statement in Java

Before writing the actual program, it’s essential to understand the control flow structure we’ll be using. The if-else statement in Java allows us to execute certain sections of code based on whether a condition is true or false.

Syntax of if-else Statement

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

In our case, the condition will involve checking if the number is greater than, less than, or equal to zero.

Also Read: Count Inversions in an Array | Coding Interview Question | Count Inversions Merge Sort

Java Program to Check if a Number is Positive or Negative

Let’s write the code to accomplish this task.

import java.util.Scanner;

public class NumberCheck {
    public static void main(String[] args) {
        // Create a Scanner object to read input
        Scanner scanner = new Scanner(System.in);

        // Prompt the user to enter a number
        System.out.println("Enter a number: ");
        int number = scanner.nextInt();

        // Check if the number is positive, negative, or zero
        if (number > 0) {
            System.out.println("The number is positive.");
        } else if (number < 0) {
            System.out.println("The number is negative.");
        } else {
            System.out.println("The number is zero.");
        }

        // Close the scanner
        scanner.close();
    }
}

Also Read: Equilibrium Index of an Array Problem | LeetCode Solution in Java

Explanation of the Code

1. Importing the Scanner Class: We import the java.util.Scanner class to read user input. This is crucial for interacting with the user during runtime.
2. Creating the Scanner Object: The Scanner object is created to read the input from the console.
3. Prompting the User: A message is printed to the console asking the user to input a number.
4. Reading the Input: The nextInt() method reads the input number and stores it in the variable number.
5. Checking the Condition: We use an if-else structure to check whether the number is greater than zero, less than zero, or exactly zero. Depending on the condition, the corresponding message is printed.
6. Closing the Scanner: We close the scanner object to avoid resource leaks.

Also Read: Reverse An Array | Program to Reverse an Array

Dry Run of the Program

To understand the flow of execution, let’s walk through a dry run with an example input.

Example 1: Positive Number

Input: 25

• Step 1: The program starts and prompts the user to enter a number.
• Step 2: The user enters 25.
• Step 3: The program checks the condition if (number > 0). Since 25 > 0, the condition is true.
• Step 4: The program prints "The number is positive."
• Step 5: The program ends after closing the scanner.

Output: The number is positive.

Example 2: Negative Number

Input: -12

• Step 1: The program prompts the user to enter a number.
• Step 2: The user enters -12.
• Step 3: The program checks the first condition if (number > 0). Since -12 > 0 is false, it moves to the else if condition if (number < 0).
• Step 4: The else if condition is true, so the program prints "The number is negative."
• Step 5: The program ends after closing the scanner.

Output: The number is negative.

Example 3: Zero

Input: 0

• Step 1: The program prompts the user to enter a number.
• Step 2: The user enters 0.
• Step 3: The program checks the first condition if (number > 0). Since 0 > 0 is false, it moves to the else if condition if (number < 0). This condition is also false, so it moves to the else block.
• Step 4: The program executes the else block, printing "The number is zero."
• Step 5: The program ends after closing the scanner.

Output: The number is zero.

Read More: Subarray Sum Equals K | Leet Code Subarray Sum Equals K

Why This Program Matters

Understanding how to check if a number is positive or negative in Java is more than just a basic exercise. This concept is foundational for learning more advanced programming techniques, such as loops, error handling, and input validation. These skills are crucial when developing applications that require robust user input management or need to perform different operations based on numerical input.

Moreover, mastering these simple tasks builds your confidence in coding, as you’ll start recognizing patterns and applying them to more complex problems.

Read More: Subarray with Given Sum | Sliding Window Technique

Common Mistakes and How to Avoid Them

When writing a program to check if a number is positive or negative, beginners often make some common mistakes. Let’s explore a few of them and how to avoid these pitfalls:

1. Forgetting to Close the Scanner

Not closing the Scanner object after its use can lead to resource leaks. Always ensure that scanner.close() is called at the end of your program.

2. Misunderstanding the if-else Structure

It’s essential to understand the order of the conditions. If you mix up the conditions, the program might not give the correct output. For example, if you place the check for number == 0 before number > 0, you could skip the positive number check entirely.

3. Handling Non-Integer Input

This program assumes the user will always enter an integer. If you want to make your program more robust, you should handle cases where the input is not an integer. This can be done using exception handling, which is a more advanced topic.

4. Neglecting Edge Cases

Always consider edge cases, such as the minimum and maximum integer values, to ensure your program handles all potential inputs correctly.

Also Read: Noble Integer | Noble integer in an Array | InterviewBit Solution

Conclusion

Writing a Java Program to Check if a Number is Positive or Negative is a fundamental exercise that reinforces your understanding of control structures in Java. By mastering this concept, you lay the groundwork for tackling more complex programming challenges. The skills you gain from this exercise—such as using the if-else statement, handling user input, and considering edge cases—are essential for your growth as a Java developer.

Remember to practice, experiment with different inputs, and explore enhancements to make your code more robust. As you advance in your programming journey, these basic exercises will serve as a solid foundation for more sophisticated coding projects.

FAQs

What if the input is not an integer?
If the input is not an integer, the program will throw an InputMismatchException. To handle this gracefully, you can use a try-catch block around the input section.

Can I use the program for decimal numbers?
Yes, but you need to modify the program to read a float or double instead of an int. The logic for checking whether the number is positive, negative, or zero remains the same.

Why is closing the Scanner important?
Closing the Scanner is essential to free up system resources and prevent resource leaks. Failing to do so in a large program could eventually cause your program to run out of resources.

What happens if I check zero first in the if-else structure?
If you check for zero first, the program will correctly identify zero but might not correctly identify positive or negative numbers if the logic is not structured properly. It’s crucial to arrange your conditions in a logical order.

How can I enhance this program?
You can enhance this program by adding user input validation, exception handling, or extending it to check multiple numbers in a loop.

Is this program useful in real-world applications?
Yes, this program is a fundamental building block. The concept of checking and categorizing numbers is used in various real-world applications, such as data analysis, financial software, and scientific computations.