Overview of Primitive Data Types

Java provides eight built-in primitive data types that are not objects and store raw values. These are categorized into integers, floating-point numbers, characters, and booleans.

Integer Types

• byte: An 8-bit signed integer. It occupies 1 byte of memory with a range of -128 to 127. The default value is 0. It is primarily used to save memory in large arrays.
• short: A 16-bit signed integer occupying 2 bytes. Its range extends from -32,768 to 32,767. Like byte, it can save memory but is less frequently used in general application logic.
• int: A 32-bit signed integer occupying 4 bytes. With a range of approximately -2.1 billion to 2.1 billion, it is the default choice for integral values unless a larger range is required.
• long: A 64-bit signed integer occupying 8 bytes. It accommodates very large integers. It is good practice to suffix long literals with an uppercase 'L' to distinguish them from int literals.

Floating-Point Types

• float: A single-precision 32-bit IEEE 754 floating-point number. It should be suffixed with 'F' or 'f' when assigning values. It is useful when saving memory is a priority over high decimal precision.
• double: A double-precision 64-bit IEEE 754 floating-point number. This is the default type for decimal numbers. While optional, suffixing with 'D' or 'd' is acceptable.

Other Types

• boolean: Represents a binary logical state with only two possible values: true or false. Its size is not precisely defined by the JVM specification, but it typically defaults to false.
• char: A single 16-bit Unicode character. It ranges from '\u0000' (or 0) to '\uffff' (or 65,535). It must be enclosed in single quotes.

Type Hierarchy and Conversion

Numeric types follow a specific hierarchy based on capacity and precision. The order from lowest to highest is generally:

byte < short < int < long < float < double

char is effectively an unsigned integer that behaves similarly to short in arithmetic contexts.

Automatic Type Promotion (Widening)

When assigning a value of a lower-ranked type to a variable of a higher-ranked type, Java performs an automatic conversion.

long largeNumber = 100L;
double preciseNumber = largeNumber; // Automatic widening
System.out.println("Long: " + largeNumber + ", Double: " + preciseNumber);

Narrowing Primitive Conversion

Converting from a higher-ranked type to a lower-ranked one requires an explicit cast. This process may lead to data loss due to truncation or overflow.

double pi = 3.14159;
int truncatedPi = (int) pi; // Explicit cast, fractional part lost
System.out.println("Double: " + pi + ", Int: " + truncatedPi);

int maxValue = 130;
byte limited = (byte) maxValue; // Overflow occurs
System.out.println("Original Int: " + maxValue + ", Casted Byte: " + limited);

In the example above, since the byte maximum is 127, the value 130 wraps around to a negative number.

Numeric Promotion in Arithmetic Operations

Binary arithmetic operators trigger specific type promotion rules to ensure data integrity.

1. If any operand is a double, the other is converted to double.
2. Otherwise, if any operand is a float, the other is converted to float.
3. Otherwise, if any operand is a long, the other is converted to long.
4. Otherwise, both operands are converted to int.

This rule implies that operations involving byte, short, or char always result in an int, regardless of whether the values fit into the original types.

short shortVal = 50;
byte byteVal = 20;

// The result of shortVal + byteVal is promoted to int
int result = shortVal + byteVal;

// This would cause a compilation error without the cast
// short anotherShort = shortVal + byteVal; 

System.out.println("Result type: " + ((Object)result).getClass().getSimpleName());
System.out.println("Value: " + result);

Consequently, when performing calculations on types smaller than int, explicit casting is necessary to store the result back into the smaller type.