> ## 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 Assignment
The `*=` operator is a compound assignment operator in Java that multiplies the current value of the left-hand operand by the value of the right-hand expression, subsequently assigning the computed product back to the left-hand operand.
## Syntax
```java theme={"dark"}
variable *= expression;
```
## Mechanics and Equivalence
At a basic level, the operator serves as syntactic sugar. The expression `a *= b` is conceptually equivalent to `a = a * b`. However, the Java Language Specification (JLS) dictates a critical distinction regarding type conversion.
Formally, if `E1` is the left-hand operand of type `T`, and `E2` is the right-hand operand, the compound assignment `E1 *= E2` is equivalent to:
```java theme={"dark"}
E1 = (T) ((E1) * (E2));
```
## Implicit Narrowing Conversion
The most significant technical characteristic of the `*=` operator is its inclusion of an implicit cast to the type of the left-hand operand. When performing standard arithmetic operations (like `*`), Java automatically promotes integral types smaller than `int` (such as `byte`, `short`, or `char`) to `int`.
Using the standard assignment operator requires an explicit cast to avoid a compilation error, whereas the `*=` operator handles this cast automatically at the compiler level.
```java theme={"dark"}
byte a = 10;
byte b = 5;
// Standard multiplication requires an explicit cast
// a = a * b; // COMPILATION ERROR: incompatible types: possible lossy conversion from int to byte
a = (byte) (a * b); // Compiles successfully
// Compound assignment handles the cast implicitly
a *= b; // Compiles successfully. Equivalent to: a = (byte) (a * b);
```
## Evaluation Order
When using the `*=` operator, the left-hand operand is evaluated exactly once. This is a crucial distinction when the left-hand operand contains an expression with side effects, such as a method call or a complex array index calculation.
```java theme={"dark"}
// The method getIndex() is executed exactly once.
array[getIndex()] *= 2;
// In the expanded version, getIndex() would be executed twice.
array[getIndex()] = array[getIndex()] * 2;
```
## Type Compatibility
The `*=` operator can only be applied to primitive numeric types (`byte`, `short`, `char`, `int`, `long`, `float`, `double`) and their corresponding wrapper classes (via unboxing). It cannot be applied to `boolean` or reference types (such as `String` or `Object`).
Tired of Poor Java Skills? Fix That With Deep Grasping!
Learn More
