Conversão de tipos em atribuições

• É comum atribuir um tipo de variável a outro em programação.

Exemplo: atribuir um valor int a uma variável float.

• Quando tipos compatíveis são combinados em uma atribuição, o valor do lado direito é automaticamente convertido para o tipo do lado esquerdo. No exemplo, o valor de i é convertido para float e então atribuído a f.

• Nem todos os tipos são compatíveis devido à rigorosa verificação de tipos de Java (ex: boolean e int não são compatíveis).

• Uma conversão automática ocorre quando:
  Os dois tipos são compatíveis.
  O tipo de destino é maior que o de origem.

• Quando essas condições são atendidas, ocorre uma conversão ampliadora.
  Exemplo: int pode conter todos os valores válidos de byte, permitindo uma conversão automática de byte para int.

• Tipos numéricos, incluindo inteiros e de ponto flutuante, são compatíveis em conversões ampliadoras.
  Exemplo válido: a transformação de long em double é uma conversão ampliadora executada automaticamente.

Existe a conversão automática de long para double, não há conversão automática de double para long, já que essa não é uma conversão ampliadora.

• Não há conversões automáticas de tipos numéricos para char ou boolean.

Convertendo tipos incompatíveis

• Conversões automáticas de tipos são úteis, mas não cobrem todas as necessidades de programação, aplicando-se apenas a conversões ampliadoras entre tipos compatíveis.

• Para outros casos, é necessário utilizar uma coerção (cast).

• Coerção é uma instrução que solicita explicitamente a conversão de um tipo para outro.

• Forma geral de uma coerção:
  (tipo-destino) expressão.

Exemplo:
(int) (x / y)
converte o resultado da expressão x / y para int.

• Os parênteses em torno de x / y são necessários para garantir que a coerção seja aplicada ao resultado da divisão e não apenas a x.

• Coerção (cast) é necessária quando não há conversão automática entre os tipos, como de double para int.

• Coerção envolvendo uma conversão redutora pode resultar na perda de informações.

• Por exemplo, ao converter um long para um short, informações serão perdidas se o valor do tipo long for maior do que o intervalo do tipo short, pois os bits de ordem superior serão removidos.

• Quando um valor de ponto flutuante é convertido para um tipo inteiro, o componente fracionário é perdido devido ao truncamento.

Exemplo:
ao atribuir o valor 1.23 a um inteiro, o valor resultante será apenas 1, com a perda do 0.23.

Saída:
Integer outcome of x / y: 3
Value of b: 100
Value of b: 1
ch: X

• A coerção de (x / y) para int resulta no truncamento do componente fracionário, perdendo informações.

• Não há perda de informação quando b recebe o valor 100, pois um byte pode conter esse valor.

• Ao tentar atribuir o valor 257 a b, ocorre perda de informações porque 257 excede o valor máximo de um byte.

• Nenhuma informação é perdida, mas uma coerção é necessária na atribuição de um valor byte a um char.