TOC

Operadores compostos Java

Operadores compostos Java

*1. Visão geral *

Neste tutorial, veremos os operadores compostos Java, seus tipos e como o Java os avalia.

Também explicaremos como a transmissão implícita funciona.

===* 2. Operadores de atribuição composta *

Um operador de atribuição é um operador binário que atribui o resultado do lado direito à variável do lado esquerdo. O mais simples é o operador de atribuição _ “=” _:

int x = 5;

Esta declaração declara uma nova variável x, atribui x o valor de 5 e retorna 5.

*Operadores de atribuição compostos são uma maneira mais curta de aplicar uma operação aritmética ou bit a bit e atribuir o valor da operação à variável no lado esquerdo.*

Por exemplo, as duas instruções de multiplicação a seguir são equivalentes, o que significa que a e b terão o mesmo valor:

int a = 3, b = 3, c = -2;
a = a *c;//Simple assignment operator
b* = c;//Compound assignment operator

É importante observar que a variável à esquerda de um operador de atribuição composta já deve estar declarada. Em outras palavras, operadores compostos não podem ser usados ​​para declarar uma nova variável.

Como o operador de atribuição "=", os operadores compostos retornam o resultado atribuído da expressão:

long x = 1;
long y = (x+=2);

X e y manterão o valor 3.

A atribuição _ (x + = 2) _ faz duas coisas: primeiro, adiciona 2 ao valor da variável x, que se torna 3; _ segundo, retorna o valor da atribuição, que também é _3.

*3. Tipos de operadores de atribuição composta *

Java suporta 11 operadores de atribuição composta. Podemos agrupá-los em operadores aritméticos e bit a bit.

Vamos examinar os operadores aritméticos e as operações que eles executam:

  • Incrementação: _ + = _

  • Decrementação: _- = _ Multiplicação: _ = _

  • Divisão: _/= _

  • Módulo: _% = _

Então, também temos os operadores bit a bit:

  • AND, binário: _ & = _

  • OR exclusivo, binário: _ ^ = _

  • OR inclusivo, binário: _ | = _

  • Deslocamento à esquerda, binário: _ << = _

  • Deslocamento à direita, binário: _ >> = _ *Deslocar o preenchimento zero à direita: _ >>> = _

Vamos dar uma olhada em alguns exemplos dessas operações:

//Simple assignment
int x = 5;//x is 5

//Incrementation
x += 5;//x is 10

//Decrementation
x -= 2;//x is 8

//Multiplication
x* = 2;//x is 16

//Modulus
x %= 3;//x is 1

//Binary AND
x &= 4;//x is 0

//Binary exclusive OR
x ^= 4;//x is 4

//Binary inclusive OR
x |= 8;//x is 12

Como podemos ver aqui, a sintaxe para usar esses operadores é consistente.

*4. Avaliação de operações de atribuição de compostos *

Há duas maneiras pelas quais o Java avalia as operações compostas.

Primeiro,* quando o operando do lado esquerdo não é uma matriz, *o Java irá, na seguinte ordem:

  1. Verifique se o operando é uma variável declarada

  2. Salve o valor do operando esquerdo

  3. Avalie o operando do lado direito

  4. Execute a operação binária conforme indicado pelo operador composto

  5. Converta o resultado da operação binária no tipo da variável à esquerda (conversão implícita)

  6. Atribua o resultado convertido à variável esquerda

Em seguida,* quando o operando do lado esquerdo é uma matriz, * as etapas a seguir são um pouco diferentes:

  1. Verifique a expressão da matriz no lado esquerdo e gere um NullPointerException ou ArrayIndexOutOfBoundsException se estiver incorreto

  2. Salve o elemento da matriz no índice

  3. Avalie o operando do lado direito

  4. Verifique se o componente da matriz selecionado é um tipo primitivo ou de referência e continue com as mesmas etapas da primeira lista, como se o operando do lado esquerdo fosse uma variável.

Se alguma etapa da avaliação falhar, o Java não continuará executando as etapas a seguir.

*Vamos dar alguns exemplos relacionados à avaliação dessas operações para um elemento da matriz:*
int[] numbers = null;

//Trying Incrementation
numbers[2] += 5;

Como seria de esperar, isso gerará uma NullPointerException.

No entanto, se atribuirmos um valor inicial à matriz:

int[] numbers = {0, 1};

//Trying Incrementation
numbers[2] += 5;

Nos livraríamos da NullPointerException, _ mas ainda receberíamos uma _ArrayIndexOutOfBoundsException, pois o índice usado não está correto.

Se corrigirmos isso, a operação será concluída com êxito:

int[] numbers = {0, 1};

//Incrementation
numbers[1] += 5;//x is now 6

Finalmente, a variável x será 6 no final da atribuição.

*5. Fundição implícita *

Uma das razões pelas quais os operadores compostos são úteis é que eles não apenas fornecem uma maneira mais curta para as operações, mas também convertem variáveis ​​implicitamente.

Formalmente, uma expressão de atribuição composta da forma:

E1 op = E2

é equivalente a:

_E1 - (T) (E1 op E2) _

onde T é o tipo de E1.

Vamos considerar o seguinte exemplo:

long number = 10;
int i = number;
i = i* number;//Does not compile

Vamos analisar por que a última linha não será compilada.

O Java promove automaticamente tipos de dados menores para dados maiores, quando estão juntos em uma operação, mas gera um erro ao tentar converter de tipos maiores para menores .

Portanto, primeiro, i será promovido para long e, em seguida, a multiplicação fornecerá o resultado 10L. O resultado longo será atribuído a i, que é um int, e isso gerará um erro.

Isso pode ser corrigido com uma conversão explícita:

i = (int) i *number;

Neste caso, os operadores de atribuição composta de Java são perfeitos porque fazem uma conversão implícita:

i* = number;

Essa instrução funciona perfeitamente, convertendo o resultado da multiplicação para int e atribuindo o valor à variável do lado esquerdo, i.

6. Conclusão

Neste artigo, examinamos os operadores compostos em Java, fornecendo alguns exemplos e diferentes tipos deles. Explicamos como o Java avalia essas operações.

Por fim, também analisamos a conversão implícita, uma das razões pelas quais esses operadores de taquigrafia são úteis.

Como sempre, todos os trechos de código mencionados neste artigo podem ser encontrados em nosso GitHub repository .

Related