> ## 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 Assignment
The `=` operator in Java is the simple assignment operator. It evaluates the expression on its right-hand side (RHS) and stores the resulting value or memory reference into the variable specified on its left-hand side (LHS).
```java theme={"dark"}
targetVariable = expression;
```
## Technical Characteristics
* **Associativity:** Right-to-left. When multiple assignment operators are present in a single statement, the Java compiler evaluates them from the rightmost expression to the leftmost.
* **Precedence:** Very low. It ranks below arithmetic, relational, bitwise, and logical operators, ensuring that the RHS expression is fully evaluated before the assignment occurs.
* **Return Value:** An assignment operation is itself an expression that yields the assigned value. This characteristic enables chained assignments.
* **Type Compatibility:** The evaluated type of the RHS expression must be identical to, or implicitly promotable/castable to, the declared type of the LHS variable. If the types are incompatible, the compiler throws an `incompatible types` error.
## Memory Mechanics
The behavior of the `=` operator differs fundamentally based on the data type being assigned:
**1. Primitive Types**
For the eight primitive types (`byte`, `short`, `int`, `long`, `float`, `double`, `char`, `boolean`), the `=` operator copies the actual bit-level value from the RHS to the LHS.
```java theme={"dark"}
int a = 50;
int b = a; // The literal value 50 is copied into the memory space allocated for 'b'
```
**2. Reference Types**
For objects and arrays, the `=` operator copies the memory address (the reference) of the object, not the object itself. After assignment, both the LHS and RHS variables point to the exact same object instance in the heap memory.
```java theme={"dark"}
MyClass ref1 = new MyClass();
MyClass ref2 = ref1; // ref2 now holds the same memory address as ref1; no new object is created
```
## Syntax Visualization
```java theme={"dark"}
// Standard assignment
int x = 10;
// Expression evaluation prior to assignment (due to precedence)
int y = x + 5 * 2;
// Chained assignment (due to right-to-left associativity and return value)
int a, b, c;
a = b = c = 100;
// Evaluates as: a = (b = (c = 100));
```
Tired of Poor Java Skills? Fix That With Deep Grasping!
Learn More
