Table of Contents

## Numeric Data Types

Every data type has a range of values. The compiler allocates memory space for each variable or constant according to its data type. Java provides eight primitive data types: `byte`

, `boolean`

, `char`

, `double`

, `float`

, `int`

, `long`

, `short`

.

Java uses four types for integers: `byte`

, `short`

, `int`

, and `long`

. Choose the type that is most appropriate for your variable. For example, if you know an integer stored in a variable is within a range of a byte, declare the variable as a `byte`

. For simplicity and consistency, we use `int`

for integer.

Java uses two types for floating-point numbers: `float`

and `double`

. The `double`

type is twice as big as `float`

, so the `double`

is known as *double precision* and `float`

as *single precision*. Normally, you should use the `double`

type, because it is more accurate than the `float`

type.

## Reading Numbers from the Keyboard

You know how to use the nextDouble() method in the Scanner class to read a double value from the keyboard (if not, check out the Reading Input from Console tutorial). You can also use other methods to read numbers of the `byte`

, `short`

, `int`

, `long`

, and `float`

type. Like these ones:

1 2 3 4 5 6 7 8 |
Methods Description nextByte() reads an integer of the byte type. nextShort() reads an integer of the short type. nextInt() reads an integer of the int type. nextLong() reads an integer of the long type. nextFloat() reads a number of the float type. nextDouble() reads a number of the double type. *These are methods for the Scanner Objects |

Here are a few examples showing how to values of various types are read from the keyboard:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
Scanner input = new Scanner(System.in); System.out.print("Enter a byte value: "); byte byteValue = input.nextByte(); System.out.print("Enter a short value: "); short shortValue = input.nextShort(); System.out.print("Enter a Integer value: "); int intValue = input.nextInt(); System.out.print("Enter a Long value: "); long longValue = input.nextLong(); System.out.print("Enter a Float value: "); float floatValue = input.nextFloat(); |

If you enter a value with an incorrect range or format, a runtime error would occur. For example, you enter a value 128 for `byte byteValue = input.nextByte();`

, an error would occur because 128 is out of range for a `byte`

type integer (`byte`

types only accept 1s and 0s i.e. 10010).

## Numeric Operators

The operators for numeric data types include the standard *arithmetic* operators: addition `+`

subtraction `-`

multiplication `*`

division `/`

and remainder `%`

, as shown below. The *operands* are the values operated by an operator.

1 2 3 4 5 6 |
Name Meaning Example Results + Addition 34 + 1 35 - Subtraction 34.0 - 0.1 33.9 * Multiplication 300 * 30 9000 / Division 1.0 / 2.0 0.5 % Remainder 20 % 30 2 |

When both operands of a division are integers, the result of the division is the quotient; the fractional part is truncated. For example, `5 / 2`

yields `2`

, not `2.5`

; `-5 / 2`

yeilds `-2`

, not `-2.5`

. To perform a float-point division, one of the operands must be a floating-point number. For example, `5.0 / 2`

yields `2.5`

.

The `%`

operator, known as the *reminder* or *modulo* operator, yields the remainder after division. The operand on the left is the dividend. The operand on the right is the divisor. Therefore:

`7 % 3`

yields`1`

`3 % 7`

yields`3`

`12 % 7`

yields`3`

`12 % 4`

yields`0`

`26 % 8`

yields`2`

`20 % 13`

yields`7`

The `%`

operator is often used for positive integers, but it can also be used with negative integers and floating-point values. The remainder is negative only if the dividend is negative. For example:

`-7 % 3`

yields`-1`

`-12 % 4`

yields`0`

`-26 % -8`

yields –`2`

`20 % -13`

yields`7`

Remainder is very useful in programming. For example, an even number `% 2`

is always `0`

and an odd number `% 2`

is always `1`

or `-1`

.Thus, you can use this property to determine whether a number is even or odd.

## % Remainder Example 1 – Weekday

If today is Saturday, it will be Saturday again in 7 days. Suppose you and your friends are going to meet in 10 days. What day is in 10 days? You can find that the day is Tuesday using the following expression:

## % Remainder Example 2 – Display Time

In this example, I will be showing a program that obtains minutes and remaining seconds from an amount of time in seconds. For example, `500`

seconds contains `8`

minutes and `20`

seconds.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
import java.util.Scanner; public class DisplayTime { public static void main(String[] args) { Scanner input = new Scanner(System.in); // Prompt the user for input System.out.print("Enter an integer for seconds: "); int seconds = input.nextInt(); // int minutes = seconds / 60; //Find minutes in seconds int remainingSeconds = seconds % 60; //Seconds remaining System.out.println(seconds + " seconds is " + minutes + " minutes and " + remainingSeconds + " seconds"); } } |

**Output:**

**Explanation:** The `nextInt()`

method reads an integer for `seconds`

. Then the `seconds`

are divided by `60`

(`seconds / 60`

) to obtain the number of minutes. Then the `seconds`

goes through the remainder operator (`seconds % 60`

) to find the number of seconds remaining after divided by `60`

.

## Exponent Operations

The `Math.pow(a, b)`

method can be used to compute a^{b}. The `pow`

method is defined in the `Math`

class in the Java API. You invoke the method using the syntax `Math.pow(a, b)`

(e.g., `Math.pow(2, 3)`

), which returns the result of a^{b} (2^{3}). Here, `a`

and `b`

are parameters for the `pow`

method and the numbers `2`

and `3`

are actual values used to invoke the method. For example,

1 2 3 4 |
System.out.println(Math.pow(2, 3)); // Displays 8.0 System.out.println(Math.pow(4, 0.5)); // Displays 2.0 System.out.println(Math.pow(2.5, 2)); // Displays 6.25 System.out.println(Math.pow(2.5, -2)); // Displays 0.16 |