Operadores de Atribuição e sua Precedência em Java

Em Java, os operadores de atribuição composta representam uma forma abreviada de combinar a atribuição com outra operação. Essa construção torna as expressões mais concisas, mantendo o mesmo resultado obtido com a versão expandida.

Por exemplo, o operador de atribuição simples, representado por =, apenas atribui diretamente o valor de uma expressão a uma variável:

c = b;

Já os operadores de atribuição compostos combinam a atribuição com uma operação aritmética, lógica ou de deslocamento. Eles permitem que você realize uma operação e atribua o resultado à variável em uma única etapa.

c += b;   // equivalente: c = c + b
c -= b;   // equivalente: c = c - b
c *= b;   // equivalente: c = c * b
c /= b;   // equivalente: c = c / b
c %= b;   // equivalente: c = c % b

c &= b;   // equivalente: c = c & b
c |= b;   // equivalente: c = c | b
c ^= b;   // equivalente: c = c ^ b

c <<= b;  // equivalente: c = c << b
c >>= b;  // equivalente: c = c >> b
c >>>= b; // equivalente: c = c >>> b

Abaixo, um exemplo prático com a aplicação desses operadores em sequência:

int a = 5;
a += 10;     // resultado: 15
a -= 3;      // resultado: 12
a *= 2;      // resultado: 24
a /= 6;      // resultado: 4
a <<= 4;     // resultado: 64
a >>= 2;     // resultado: 16
System.out.println(a); // saída: 16

Precedência dos Operadores

A precedência de operadores determina a ordem de avaliação das operações dentro de uma expressão. Operadores com precedência mais alta são avaliados antes daqueles com precedência mais baixa, mesmo que estejam em posição posterior no código.

Por exemplo, a multiplicação (*) tem precedência maior que a adição (+). Na expressão abaixo, a multiplicação ocorre antes da soma:

int result = 2 + 3 * 4; // resultado: 14

Esse cálculo equivale a 2 + (3 * 4).

Já com o uso de parênteses, a ordem de avaliação pode ser modificada explicitamente:

int result = (2 + 3) * 4; // resultado: 20

Os parênteses forçam a adição a ser executada antes da multiplicação, alterando o resultado final.

A seguir, a tabela de precedência dos operadores Java, do mais prioritário ao menos:

1. a++ a--
2. ++a --a +a -a ~ !
3. * / %
4. + -
5. << >> >>>
6. <= >= instanceof
7. == !=
8. &
9. ^
10. |
11. &&
12. ||
13. ? : (operador ternário)
14. =, +=, -=, *=, /=, %=, &=, ^=, |=, <<=, >>=, >>>=

Compreender a ordem de precedência é essencial para evitar erros de lógica. O uso consciente de parênteses, além de garantir o comportamento esperado, melhora a legibilidade do código.

📝 Exercícios

Tarefa 1: Qual será o valor final de x?

int x = 8;
x *= 2 + 1;
System.out.println(x);

24

Tarefa 2: O que será impresso?

int a = 6;
int b = 2;

if (a % b == 0 && a > b) System.out.println("primeira");
if (a % b == 1 || a > b) System.out.println("segunda");

primeira

Tarefa 3: Qual será o valor final de a e b?

int a = 3;
int b = 1 + (a *= 2);
System.out.println("a: " + a + ", b: " + b);

a: 6, b: 7