relacionais - precedencia de operadores em java




Por que os operadores de designação++,-=,*=,/= compostos de Java não precisam ser convertidos? (7)

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) ?


À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á typecasting automático. Em C ++ não haverá nenhum erro compilando o código acima, mas em Java você obterá algo como Incompatible type exception .

Então, para evitar isso, 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 com a = a + b , não há typecasting acontecendo, e assim o compilador fica irritado com você por não typecasting. Mas com a += b , o que ele realmente está fazendo é typecasting b para um tipo compatível com a . Então, se você fizer

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);

Em Java, as conversões de tipos são executadas automaticamente quando o tipo de 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 -> short -> int -> long -> float -> double. 

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 do que o segundo e, consequentemente, a informação pode ser perdida. Para forçar essa conversão, devemos realizar uma conversão explícita.
Tipo - Conversão


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

Por exemplo, o código a seguir está correto:

short x = 3;
x += 4.6;

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

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

Ponto sutil aqui ...

Há um typecast implícito para i+j quando j é um double e i é um int. Java ALWAYS converte sempre um inteiro em um duplo quando há uma operação entre eles.

Para esclarecer i+=j onde i é um inteiro e j é um duplo pode ser descrito como

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

Veja: esta descrição do casting implícito

Você pode querer typecast j para (int) neste caso para maior clareza.


Sim,

basicamente quando escrevemos

i += l; 

o compilador converte isso para

i = (int)(i + l);

Acabei de verificar o código do arquivo .class .

Realmente é bom saber


você precisa converter de long para int explicitly no caso de i = i + l então ele irá compilar e fornecer a 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 de += ele simplesmente funciona bem porque o operador implicitamente faz o tipo de conversão do tipo de variável certa para o tipo de variável esquerda, portanto, não precisa ser convertido explicitamente.





assignment-operator