> ## Documentation Index > Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt > Use this file to discover all available pages before exploring further. # Java Multiplication The `*` operator in Java is a binary arithmetic operator that performs multiplication on two numeric operands. It calculates the product of its left and right operands, strictly adhering to Java's rules for binary numeric promotion and IEEE 754 arithmetic standards. ```java theme={"dark"} Type result = operand1 * operand2; ``` ## Operand Types The `*` operator accepts operands of any primitive numeric type (`byte`, `short`, `char`, `int`, `long`, `float`, `double`). It also accepts their corresponding object wrapper classes (e.g., `Integer`, `Double`), which the Java compiler automatically unboxes into their primitive equivalents before evaluation. It cannot be applied to `boolean` or non-wrapper reference types. ## Binary Numeric Promotion Before the multiplication occurs, Java applies binary numeric promotion to equalize the operand types. The promotion follows a strict hierarchy: 1. If either operand is of type `double`, the other is promoted to `double`. The result is a `double`. 2. Otherwise, if either operand is `float`, the other is promoted to `float`. The result is a `float`. 3. Otherwise, if either operand is `long`, the other is promoted to `long`. The result is a `long`. 4. Otherwise, both operands are promoted to `int` (this includes `byte`, `short`, and `char`). The result is an `int`. ```java theme={"dark"} byte a = 10; byte b = 5; // result is of type int, not byte int result = a * b; ``` ## Precedence and Associativity The `*` operator has multiplicative precedence. It is evaluated after unary operators (like `++` or `!`) but before additive operators (`+` and `-`). It features **left-to-right associativity**, meaning an expression with multiple multiplicative operators (`*`, `/`, `%`) is evaluated from left to right. ```java theme={"dark"} // Evaluated as (a * b) * c int result = a * b * c; ``` ## Overflow Behavior Java handles multiplication overflow differently depending on whether the operands are integers or floating-point numbers: * **Integer Arithmetic (`int`, `long`):** If the mathematical product exceeds the maximum or minimum bounds of the resulting type, the operation silently wraps around using two's complement arithmetic. It does **not** throw an `ArithmeticException`. * **Floating-Point Arithmetic (`float`, `double`):** If the product exceeds the maximum representable finite value, the result overflows to positive or negative `Infinity`, depending on the signs of the operands. ## IEEE 754 Special Cases When multiplying floating-point numbers, the `*` operator follows IEEE 754 specifications for special values: * **NaN (Not a Number):** If either operand is `NaN`, the result is `NaN`. * **Infinity by Zero:** Multiplying positive or negative `Infinity` by `0` or `0.0` results in `NaN`. * **Infinity by Finite:** Multiplying `Infinity` by any non-zero finite value results in `Infinity`. The sign of the resulting `Infinity` is positive if both operands have the same sign, and negative if they have different signs. * **Signed Zeros:** Java supports `-0.0` and `+0.0`. Multiplying two zeros yields a zero, with the sign determined by the standard XOR sign rules (e.g., `-0.0 * +0.0` yields `-0.0`).

Tired of Poor Java Skills? Fix That With Deep Grasping! Learn More