Por que os operadores de atribuição composta + =, - =, * =, / = do Java não requerem conversão?

Até hoje, pensei que, por exemplo:

i += j;

Foi apenas um atalho para:

i = i + j;

Mas se tentarmos isso:

int i = 5;
long j = 8;

Então i = i + j;não irá compilar, mas i += j;irá compilar bem.

Isso significa que, de fato, i += j;é um atalho para algo assim i = (type of i) (i + j)?

Como sempre com essas perguntas, o JLS mantém a resposta. Nesse caso, §15.26.2 Operadores de atribuição composta . Um extrato:

Uma expressão de atribuição composta do formulário E1 op= E2é equivalente a E1 = (T)((E1) op (E2)), onde Té o tipo de E1, exceto que E1é avaliada apenas uma vez.

Um exemplo citado em §15.26.2

[...] o seguinte código está correto:

short x = 3;
x += 4.6;

e resulta em x tendo o valor 7 porque é equivalente a:

short x = 3;
x = (short)(x + 4.6);

Em outras palavras, sua suposição está correta.

Um bom exemplo dessa transmissão é usar * = ou / =

byte b = 10;
b *= 5.7;
System.out.println(b); // prints 57

ou

byte b = 100;
b /= 2.5;
System.out.println(b); // prints 40

ou

char ch = '0';
ch *= 1.1;
System.out.println(ch); // prints '4'

ou

char ch = 'A';
ch *= 1.5;
System.out.println(ch); // prints 'a'

Muito boa pergunta. A especificação da linguagem Java confirma sua sugestão.

Por exemplo, o seguinte código está correto:

short x = 3;
x += 4.6;

e resulta em x tendo o valor 7 porque é equivalente a:

short x = 3;
x = (short)(x + 4.6);

Sim,

basicamente quando escrevemos

i += l; 

o compilador converte isso em

i = (int)(i + l);

Acabei de verificar o .classcódigo do arquivo.

Realmente uma coisa boa de saber

você precisa converter de longpara int explicitlyem caso de i = i + l compilação e saída correta. gostar

i = i + (int)l;

ou

i = (int)((long)i + l); // this is what happens in case of += , dont need (long) casting since upper casting is done implicitly.

mas, no caso +=disso, funciona bem, porque o operador faz implicitamente a conversão de tipo do tipo da variável direita para o tipo da variável esquerda, portanto, não é necessário converter explicitamente.

O problema aqui envolve a conversão de tipos.

Quando você adiciona int e long,

1. O objeto int é convertido para comprido e ambos são adicionados e você obtém um objeto comprido.
2. mas o objeto longo não pode ser implicitamente convertido para int. Então, você precisa fazer isso explicitamente.

Mas +=é codificado de tal maneira que faz a conversão de tipo.i=(int)(i+m)

No Java, as conversões de tipo são executadas automaticamente quando o tipo da expressão no lado direito de uma operação de atribuição pode ser promovido com segurança para o tipo de variável no lado esquerdo da atribuição. Assim, podemos atribuir com segurança:

 byte -> curto -> int -> longo -> flutuar -> duplo. 

O mesmo não funcionará ao contrário. Por exemplo, não podemos converter automaticamente um longo para um int porque o primeiro requer mais armazenamento que o segundo e, consequentemente, as informações podem ser perdidas. Para forçar essa conversão, devemos realizar uma conversão explícita.
Tipo - Conversão

Às vezes, essa pergunta pode ser feita em uma entrevista.

Por exemplo, quando você escreve:

int a = 2;
long b = 3;
a = a + b;

não há conversão automática de texto. Em C ++, não haverá nenhum erro ao compilar o código acima, mas em Java você terá algo parecido Incompatible type exception.

Portanto, para evitá-lo, você deve escrever seu código assim:

int a = 2;
long b = 3;
a += b;// No compilation error or any exception due to the auto typecasting

A principal diferença é que a = a + b, com , não há transmissão de texto em andamento e, portanto, o compilador fica com raiva de você por não ter feito a transmissão. Mas com a += bo que realmente está fazendo é converter bpara um tipo compatível a. Então se você faz

int a=5;
long b=10;
a+=b;
System.out.println(a);

O que você realmente está fazendo é:

int a=5;
long b=10;
a=a+(int)b;
System.out.println(a);

Ponto sutil aqui ...

Há uma conversão implícita de i+jquando jé um duplo e ié um int. Java SEMPRE converte um número inteiro em um duplo quando houver uma operação entre eles.

Para esclarecer i+=jonde ié um número inteiro e jé um duplo, pode ser descrito como

i = <int>(<double>i + j)

Veja: esta descrição da conversão implícita

Você pode querer estereotipado jpara (int), neste caso, para maior clareza.

Especificação de linguagem Java define E1 op= E2como equivalente a E1 = (T) ((E1) op (E2))onde Té um tipo de E1e E1é avaliada uma vez .

Essa é uma resposta técnica, mas você pode estar se perguntando por que esse é o caso. Bem, vamos considerar o seguinte programa.

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

O que esse programa imprime?

Você adivinhou 3? Pena que este programa não será compilado. Por quê? Bem, acontece que a adição de bytes em Java é definida para retornar umint . Acredito que isso ocorreu porque a Java Virtual Machine não define operações de byte para economizar em bytecodes (há um número limitado delas, afinal), usar operações inteiras é um detalhe de implementação exposto em uma linguagem.

Mas se a = a + bnão funcionar, isso significaria a += bque nunca funcionaria para bytes se E1 += E2fosse definido E1 = E1 + E2. Como mostra o exemplo anterior, esse seria realmente o caso. Como um truque para fazer o +=operador trabalhar para bytes e curtos, há uma conversão implícita envolvida. Não é tão bom assim, mas, durante o trabalho do Java 1.0, o foco estava em liberar a linguagem para começar. Agora, devido à compatibilidade com versões anteriores, esse hack introduzido no Java 1.0 não pôde ser removido.