Operadores de Atribuição Composta

Além do operador de atribuição simples, =, há muito outros chamados de operadores de atribuição composta.

De vários operadores compostos apenas dois são cobrados que você saiba na prova de certificação, += e -=.

Operadores complexos são realmente formas glorificadas de operadores simples, com construções aritméticas ou operações lógicas que são aplicados do lado esquerdo da expressão e do lado direito guarda o resultado do valor resultante da declaração.

Por exemplo, as duas declarações depois de x e z são equivalentes:

int x =2, z = 3;

x = x * z; //operador de atribuição simples

x *= z; //operador de atribuição composta

O lado esquerdo do operador composto pode apenas ser aplicada em variáveis que já estão definidas e não pode ser utilizada para declarar uma nova variável.

No exemplo anterior, se x não estivesse definido, então a expressão x *= z não compilaria.

Operadores compostos são úteis não só para simplificar operações, eles internamente executam o casting.

No exemplo a última linha não irá compilar porque o long não será promovido para o int.

long x = 10;

int y = 5;

y = y * x; //não compila

Para compilar temos que fazer o cast (int), mas podemos utilizar o operador composto para resolver isso.

long x = 10;

int y = 5;

y *= x;

O operador composto irá primeiro fazer o cast do y para long, sendo assim a multiplicação será feita por dois long e depois será feito o cast para int no resultado.

Uma última coisa para saber sobre operador composto é que o resultado da atribuição é uma expressão em si mesma, igual ao valor da atribuição. Vamos ver um exemplo:

long x = 5;

long y = (x = 3);

System.out.println(x); //Saída 3

System.out.println(y); //Saída 3

O segredo aqui é o (x = 3) ele faz duas coisas. Primeiro, muda o valor de x para 3. Segundo, retorna o valor atribuído que é 3.

Operadores Relacionais

Operadores relacionais comparam duas expressões e retorna um boolean. Vamos ver exemplos:

int x = 10, y = 20, z = 10;

System.out.println(x < y) // true

System.out.println(x <= y) // true

System.out.println(x >= z) // true

System.out.println(x > z) // false

Outro operador relacional é utilizado para aplicar em objetos:

a instanceof b = É true se a referência a, pertence a classe, sub classe ou é uma implementação de interface de b.

Operadores Lógico

Os operadores lógicos &, | e ^, podem ser aplicados em valores numéricos e booleanos.

Quando eles são aplicados no tipo boolean, eles são utilizados como operadores lógicos. Se forem aplicados no tipo numérico são utilizados como operadores bitwise. Você não precisa saber como funciona o bitwise no exame. https://www.vivaolinux.com.br/artigo/Bitwise-Escovando-os-bits

Algumas dicas para lembrar dessa tabela:

AND só é true se ambos operadores forem true.

Inclusivo OR é apenas false se ambos operadores forem false.

Exclusivo OR é apenas true se os operadores são diferentes.

Temos os operadores lógicos && e || que muitas vezes são chamados de operadores short-circuit. Os operadores short-circuit são quase idênticos aos operadores bitwise & e |.

Veja o exemplo:

boolean x = true || (y < 4);

Olhando a tabela, o valor x só pode ser false se ambos os lados da expressão forem false.

Se sabemos que o lado direito da expressão é true, não precisamos verificar o lado direito, já que qualquer resultado do y o valor final será true.

O exemplo mais comum onde os operadores de short-circuit são utilizados é a verificação de objetos null:

if(x != null && x.getValue() < 5){ //faça alguma coisa}

Nesse exemplo, se x é null, então o operador short-circuit previne o NullPointerException, desde que a avaliação de x.getValue() < 5 nunca é testada. Se utilizarmos o operador bitwise uma exceção será lançada.

if(x != null & x.getValue() < 5)

{

//uma exceção é lançada porque x é null

//faça alguma coisa

}

Veja esse exemplo. Qual será o valor do x?

int x = 6;

boolean y = (x >= 6) || (++x <= 7);

System.out.println(x);

O valor será 6 porque a primeira verificação (x>=6) é true. Está sendo utilizado o short-circuit (ou inclusivo). Já vimos que com o short-circuit pode ser verificado só a expressão da direita, e a esquerda nunca ser verificada, é o que acontece nesse exemplo.

Se a expressão é um ou inclusivo e olhando para a tabela verdade se a primeira verificação é true, então não importa o resultado da verificação da esquerda, porque o valor continuará sendo true.

Não fazendo a verificação da esquerda o x nunca irá executar a expressão (++x <= 7), sendo assim o valor de x continuará com o valor 6.