# Positive or Negative Number in Java

Positive or Negative in Java is essential for many programming tasks. Identifying whether a number is positive or negative helps in decision-making, error handling, and data validation. Common use cases include financial calculations, game development, and scientific computations, where the sign of a number significantly impacts outcomes and processes.

### What are Positive and Negative Number in Java?

Positive and Negative Numbers are fundamental in mathematics and programming. A positive number is any number greater than zero. For example, 5, 10.7, and 1 are positive numbers. A negative number is any number less than zero. For example, -3, -7.5, and -1 are negative numbers.

### Basic Approach to Determine Positive or Negative Numbers in Java

To determine if a number is positive or negative in Java, you can use the if-else statement. This control structure allows you to execute different code blocks based on whether a condition is true or false.

#### Positive or Negative Numbers in Java – Code Example

Here is a simple Java program that demonstrates how to check if a number is positive or negative using the if-else statement:

```public class PositiveOrNegative {
public static void main(String[] args) {
int number = -5; // You can change this value to test with different numbers

if (number > 0) {
System.out.println(number + " is a positive number.");
} else if (number < 0) {
System.out.println(number + " is a negative number.");
} else {
System.out.println(number + " is neither positive nor negative.");
}
}
}```

Explanation

• The program defines an integer variable number and assigns it a value.
• The if statement checks if number is greater than 0. If true, it prints that the number is positive.
• The else if statement checks if number is less than 0. If true, it prints that the number is negative.
• If neither condition is true (i.e., the number is 0), the else statement prints that the number is neither positive nor negative.

This basic approach is fundamental in programming and serves as a building block for more complex operations involving numerical data.

## Positive or Negative Number in Java

In Java, you can determine whether a number is positive, negative, or zero using various methods. Here, we will explore two approaches: using relational operators and the Math.signum() method.

### 1. Positive or Negative Number in Java Using Relational Operators

Code Example:

```//importing Scanner class for user input
import java.util.Scanner;

//creating class
public class Main {
public static void main(String[] args) {

//creating Scanner object
Scanner input = new Scanner(System.in);

//prompting user to enter a number
System.out.print("Enter a number: ");

//storing user input in a variable
int num = input.nextInt();

//using relational operator to check if number is greater than 0
if(num > 0) {
//if number is greater than 0, print positive
System.out.println("Positive");
}
//using relational operator to check if number is less than 0
else if(num < 0) {
//if number is less than 0, print negative
System.out.println("Negative");
}
//if number is not greater than 0 or less than 0, it must be equal to 0
else {
//print zero
System.out.println("Zero");
}
}
}```

Explanation of the Code:

• This simple approach efficiently categorizes the user-provided number based on its sign using straightforward conditional logic.
• This Java program determines whether a number entered by the user is positive, negative, or zero.
• It begins by importing the `Scanner` class for user input. After prompting the user to enter a number, it reads and stores the input using `input.nextInt()`.
• The program then uses relational operators (`>`, `<`) within an `if-else` structure to check the value of `num`. If `num` is greater than 0, it prints “Positive”.
• If `num` is less than 0, it prints “Negative”. If neither condition is true (i.e., `num` is equal to 0), it prints “Zero”.

#### Output:

``````Enter a number: 5
5 is a positive number.``````

## 2. Positive or Negative Number in Java UsingMath.signum()Method

Code Example:

```// Importing the java.util package for Scanner class
import java.util.*;

// Creating a class named Main
public class Main {
// Main method
public static void main(String[] args) {
// Creating a Scanner object for user input
Scanner input = new Scanner(System.in);

// Prompting the user to enter a number
System.out.print("Enter a number: ");

// Storing the user input in a variable
double num = input.nextDouble();

// Using the Math.signum() method to determine the sign of the number
// If the number is positive, the method returns 1.0
// If the number is negative, the method returns -1.0
// If the number is zero, the method returns 0.0
double sign = Math.signum(num);

// Checking the value of the sign variable
if (sign == 1.0) {
// If the value is 1.0, the number is positive
System.out.println(num + " is a positive number.");
} else if (sign == -1.0) {
// If the value is -1.0, the number is negative
System.out.println(num + " is a negative number.");
} else {
// If the value is 0.0, the number is zero
System.out.println(num + " is neither positive nor negative.");
}
}
}```

Explanation of the Code:

This Java program determines the sign of a number entered by the user using the `Math.signum()` method. It begins by importing the `java.util.*` package for the `Scanner` class and creating a `Scanner` object `input` to read user input. After prompting the user to enter a number, it stores the input as a `double` in the variable `num`.

The `Math.signum(num)` method is then used to determine the sign of `num`. If `num` is positive, `sign` will be `1.0`; if negative, `-1.0`; and if zero, `0.0`. Based on the value of `sign`, the program prints whether `num` is positive, negative, or zero using `if-else` statements. This approach efficiently categorizes the number based on its sign using the `Math.signum()` method’s straightforward return values.

#### Output:

``````Enter a number: -3
-3.0 is a negative number.``````

## 3. UsingInteger.signum

The Integer.signum method in Java returns the sign of the specified integer. It returns -1 if the number is negative, 0 if the number is zero, and 1 if the number is positive. Here’s how you can use it to determine if a number is positive or negative:

```public class PositiveNegativeExample {
public static void main(String[] args) {
int number = -10;

// Using Integer.signum to determine sign
int sign = Integer.signum(number);

if (sign == 1) {
System.out.println(number + " is a positive number.");
} else if (sign == -1) {
System.out.println(number + " is a negative number.");
} else {
System.out.println(number + " is neither positive nor negative.");
}
}
}```

Explanation of Integer.signum Code:

1. Initialization: int number = -10; initializes the number variable with a value of -10.
2. Using Integer.signum: int sign = Integer.signum(number); calculates the sign of number using Integer.signum method:
• Returns 1 if number is positive.
• Returns -1 if number is negative.
• Returns 0 if number is zero.
3. Conditional Statements:
• if (sign == 1) checks if the sign is positive and prints ” is a positive number.”.
• else if (sign == -1) checks if the sign is negative and prints ” is a negative number.”.
• else handles the case where the number is zero and prints ” is neither positive nor negative.”.

#### Output:

``-10 is a negative number.``

## 4. Positive or Negative Number in Java Using Bit Shift

In Java, another way to determine if a number is positive or negative is by using bit manipulation with the right shift operator (>>). Here’s how you can implement this approach:

```public class PositiveNegativeExample {
public static void main(String[] args) {
int number = 10;

// Using bit shift to determine sign
int sign = number >> 31;

if (sign == 0) {
System.out.println(number + " is a positive number.");
} else {
System.out.println(number + " is a negative number.");
}
}
}```

Explanation of Bit Shift Code:

1. Initialization: int number = 10; initializes the number variable with a value of 10.
2. Using Bit Shift: int sign = number >> 31;
• The expression number >> 31 shifts the bits of number 31 positions to the right.
• For a negative number, the rightmost bit (sign bit) becomes 1, and for a positive number, it remains 0.
3. Conditional Statement:
• if (sign == 0) checks if the rightmost bit is 0, indicating a positive number, and prints ” is a positive number.”.
• else handles the case where the rightmost bit is 1, indicating a negative number, and prints ” is a negative number.”.

#### Output:

``10 is a positive number.``

## Practical Applications of Positive or Negative Number in Java

Here are practical applications of determining positive or negative numbers in Java:

• Financial Transactions: Ensuring accurate accounting by differentiating between credits and debits in banking systems.
• Game Development: Implementing game logic based on player scores, health, or achievements to determine outcomes.
• Mathematical Calculations: Facilitating arithmetic operations where the directionality of values (positive or negative) affects results.
• Data Analysis: Analyzing trends in datasets where understanding the sign of values aids in interpreting statistical significance.
• User Input Validation: Verifying user-provided numerical inputs to ensure they meet specific criteria (e.g., positive amounts for transactions).
• Conditional Logic: Using conditionals to execute different paths in algorithms or programs based on whether numbers are positive, negative, or zero.
• Error Handling: Handling exceptions or errors in systems where certain conditions require positive or negative number validation.
• Simulation and Modeling: Simulating real-world scenarios where values represent gains, losses, or changes that impact outcomes.

In conclusion, understanding how to identify positive or negative numbers in Java is essential for precise programming. It ensures accurate calculations and logical operations. Explore and experiment with these concepts to deepen your Java skills. Visit Newtum for comprehensive courses and resources in Java, HTML, C, and more. Start coding and enjoy your learning journey!