Java Operadores de Atribuição

O operador de atribuição = guarda um valor numa variável; você o usa desde a aula de Variáveis. Mas muitas vezes queremos atualizar o valor que já está lá: somar ao saldo, descontar do estoque, dobrar a pontuação. Para isso o Java tem os operadores compostos, como +=. Eles são atalhos, mas escondem um detalhe importante que esta aula mostra com cuidado.

Relembrando o =

O = é uma ordem: "calcule o lado direito e guarde o resultado na variável do lado esquerdo". Leia sempre como "recebe".

saldo

A variável que vai receber o valor. Precisa ser uma variável: não dá para escrever 10 = saldo.

=

Recebe.

saldo + 50

A expressão, calculada primeiro, com o valor atual de saldo.

;

Fim da instrução.

Em saldo = saldo + 50;, o Java lê o saldo atual, soma 50 e guarda o resultado de volta em saldo. O valor antigo é substituído. Esse padrão, "pegar o valor atual, fazer uma conta e guardar de volta", é tão comum que ganhou atalhos.

Os operadores compostos

Um operador composto junta uma operação aritmética com o =. saldo += 50 quer dizer exatamente "saldo recebe saldo mais 50". Imagine a conta bancária da Ana ao longo de um dia:

public class Main {
    public static void main(String[] args) {
        double saldo = 100.0;
        System.out.println(saldo);
        saldo += 50;
        System.out.println(saldo);
        saldo -= 30;
        System.out.println(saldo);
        saldo *= 2;
        System.out.println(saldo);
        saldo /= 4;
        System.out.println(saldo);
        int pontos = 17;
        pontos %= 5;
        System.out.println(pontos);
    }
}

$ javac Main.java && java Main
100.0
150.0              « += 50: depósito
120.0              « -= 30: saque
240.0              « *= 2: dobrou
60.0               « /= 4: dividiu por 4
2                  « 17 %= 5: ficou o resto, 2

As mesmas regras dos Operadores Aritméticos valem aqui: com int, n /= 4 faz divisão inteira (6 /= 4 deixa 1), e /= 0 lança ArithmeticException. Para somar ou subtrair exatamente 1, prefira x++ e x--.

O lado direito é calculado inteiro, antes

Em x *= 2 + 3, o Java calcula todo o lado direito (2 + 3 = 5) e só depois multiplica: o resultado é x = x * (2 + 3), e não x = x * 2 + 3. Com x valendo 10, dá 50, como mostra o próximo programa.

Com String: += acrescenta texto

Como o + cola textos, o += acrescenta texto ao final de uma String. Os outros compostos não funcionam com texto.

public class Main {
    public static void main(String[] args) {
        String mensagem = "Olá";
        mensagem += ", Ana";
        mensagem += "!";
        System.out.println(mensagem);
        int total = 10;
        total += 2 * 3;
        System.out.println(total);
        int x = 10;
        x *= 2 + 3;
        System.out.println(x);
        int a, b, c;
        a = b = c = 7;
        System.out.println(a + " " + b + " " + c);
    }
}

$ javac Main.java && java Main
Olá, Ana!
16                 « total += 2 * 3: 10 + 6
50                 « x *= 2 + 3: 10 * 5, não 10 * 2 + 3
7 7 7              « atribuição em cadeia

A última linha mostra a atribuição em cadeia: a = b = c = 7 é resolvido da direita para a esquerda. Primeiro c recebe 7; o resultado dessa atribuição (o próprio 7) vai para b, e depois para a. Isso funciona porque, em Java, uma atribuição também produz um valor: o valor guardado. É por isso que System.out.println(x += 5); compila e mostra o novo valor de x. Funciona, mas evite: atribuir e usar na mesma linha confunde quem lê.

public class Main {
    public static void main(String[] args) {
        double total = 0;
        double arroz = 22.90;
        double feijao = 8.60;
        double cafe = 6.00;
        // some os três preços ao total com +=

        System.out.println("Total: " + total);
    }
}

public class Main {
    public static void main(String[] args) {
        double total = 0;
        double arroz = 22.90;
        double feijao = 8.60;
        double cafe = 6.00;
        total += arroz;
        total += feijao;
        total += cafe;
        System.out.println("Total: " + total);
    }
}

O casting escondido do +=

Até aqui, x += 5 e x = x + 5 pareceram idênticos. Quase. Veja com uma variável byte:

public class Main {
    public static void main(String[] args) {
        byte b = 10;
        b += 1;
        System.out.println(b);
        b = b + 1;
    }
}

$ javac Main.java
Main.java:6: error: incompatible types: possible lossy conversion from int to byte
        b = b + 1;
              ^
1 error

A linha 4 (b += 1) passou; a linha 6 (b = b + 1) não. Por quê?

• b + 1 é uma conta, e contas com byte são feitas em int (a promoção de Conversão de Tipos). Guardar um int num byte exige casting. Daí o erro.
• Os operadores compostos têm um casting embutido. Pela especificação do Java, b += 1 equivale a b = (byte) (b + 1): o resultado é convertido de volta para o tipo da variável, sem você pedir.

Isso é conveniente com byte, short e char (você já viu letra += 2 avançar letras em char e boolean). Mas o mesmo casting escondido também corta valores sem avisar:

public class Main {
    public static void main(String[] args) {
        int estoque = 10;
        estoque += 3.7;
        System.out.println(estoque);
        int preco = 10;
        preco *= 1.5;
        System.out.println(preco);
        byte b = 120;
        b += 10;
        System.out.println(b);
        char letra = 'A';
        letra += 2;
        System.out.println(letra);
    }
}

$ javac Main.java && java Main
13                 « 10 + 3.7 = 13.7, cortado para 13 sem erro nenhum!
15                 « 10 * 1.5 = 15.0, que vira 15
-126               « 120 + 10 = 130 não cabe num byte: deu a volta
C                  « 'A' + 2 continua char

public class Main {
    public static void main(String[] args) {
        byte nivel = 5;
        nivel = nivel + 1;
        System.out.println("Nível " + nivel);
    }
}

public class Main {
    public static void main(String[] args) {
        byte nivel = 5;
        nivel += 1;
        System.out.println("Nível " + nivel);
    }
}

Quando dá errado

public class Main {
    public static void main(String[] args) {
        int pontos = 10;
        pontos =+ 5;
        System.out.println(pontos);
        pontos =- 3;
        System.out.println(pontos);
    }
}

$ javac Main.java && java Main
5                  « esperava 15
-3                 « esperava 2

public class Main {
    public static void main(String[] args) {
        int idade = 18;
        if (idade = 18) {
            System.out.println("Maior de idade");
        }
    }
}

$ javac Main.java
Main.java:4: error: incompatible types: int cannot be converted to boolean
        if (idade = 18) {
                  ^
1 error

$ javac Main.java
Main.java:4: error: variable total might not have been initialized
        total += 5;
        ^
1 error

$ javac Main.java
Main.java:4: error: illegal start of expression
        x + = 2;
            ^
1 error

$ javac Main.java
Main.java:4: error: unexpected type
        10 = estoque;
        ^
  required: variable
  found:    value
1 error

Referência

Existem ainda os compostos de operadores de bits: &=, |=, ^=, <<=, >>= e >>>=. Eles seguem a mesma lógica (x &= y é x = x & y); o &= e o |= com boolean aparecem em Operadores Lógicos.

Exercícios

Resumo

• = calcula a direita e guarda na esquerda; a esquerda precisa ser uma variável.
• +=, -=, *=, /= e %= atualizam a variável usando o valor atual: saldo += 50 é saldo = saldo + 50. Todo o lado direito é calculado antes.
• Com String, += acrescenta texto.
• Os compostos têm casting embutido: byte b += 1 compila (e b = b + 1 não), mas int x += 3.7 corta para inteiro sem avisar.
• Cuidado com =+ (vira "recebe mais") e com = no lugar de == num if.