Implicit Type Conversion (Widening)

When performing assignments or arithmetic operations, Java automatically converts data types of lower precision (smaller bit size) to higher precision (larger bit size) to prevent data loss. This process is known as widening or implicit conversion. The standard conversion hierarchy follows these paths:

• char → int → long → float → double
• byte → short → int → long → float → double

Conversions can skip levels in this hierarchy (e.g., int directly to double).

int numericCode = 'A';       // Valid: char implicitly widens to int
double preciseValue = 100;   // Valid: int implicitly widens to double

Mixed-Data Type Arithmetic

When an expression involves multiple data types, the system automatically promotes all operands to the type with the largest capacity before performing the calculation. The result of the operation will match this largest type.

int baseValue = 10;

// Error: '1.1' is a double. The expression results in a double,
// which cannot be stored in a float without an explicit cast.
// float result = baseValue + 1.1; 

double correctResult = baseValue + 1.1;   // Valid: result is double

// Valid: Using the 'f' suffix makes 1.1 a float, 
// so the expression results in a float.
float floatResult = baseValue + 1.1f; 

Narrowing Conversion Restrictions

Java does not support automatic conversion from a high-precision type to a low-precision type. Attempting to assign a larger type (like double) to a smaller type (like int) directly will result in a compilation error due to potential precision loss.

// Error: Required precision for double is higher than int
// int number = 3.14;

Byte, Short, and Char Assignment Rules

There is no automatic conversion between byte, short, and char. Special rules apply when assigning values to byte variables:

• Literal Assignment: If the value is a literal constant, the compiler checks if it falls within the range of the target type (-128 to 127 for byte).
• Varible Assignment: If the source is a variable (even if its value is with in range), the compiler checks the type. Assigning an int variable to a byte variable fails because int has higher precision.

byte smallNum = 50;   // Valid: 50 is within byte range

int temp = 50;
// Error: Cannot convert from int to byte, even though value (50) is safe
// byte anotherByte = temp; 

char letter = 'x';
byte b = letter;      // Error: Incompatible types: char cannot be converted to byte

Arithmetic Promotion of Small Types

When byte, short, or char values participate in arithmetic operations, they are automatically promoted to int before the operation takes place. The result is always an int, requiring explicit casting to store it back into a smaller type.

byte b1 = 10;
byte b2 = 20;
short s1 = 5;

// Error: The result of (b2 + s1) is promoted to int
// short sum = b2 + s1; 

int validSum = b2 + s1; // Valid

// Error: The result of (b1 + b2) is promoted to int
// byte byteSum = b1 + b2; 

Boolean Type Exclusion

The boolean primitive type does not participate in automatic type conversions with numeric types. It cannot be cast to or from byte, short, char, or int.

General Expression Promotion

The data type of a complex expression is determined by the operand with the highest rank. All lower-ranking operands are promoted to match this highest rank before the final evaluation.

byte  b = 1;
short s = 2;
int   i = 3;
double d = 5.5;

// b, s, and i are promoted to double to match 'd'
// The final result is a double
double total = b + s + i + d;