numero - pasar entero a char java

reglas de asignación extraña java

Question

short s = ''a'';       // valid
Short ss = ''a'';      // valid
int i = ''a'';         // valid
Integer ii = ''a'';    // invalid

¿Por qué Integer ii = ''a'' no válido, pero int i = ''a'' válido? ¿Por qué Short ss = ''a'' valid, pero Integer ii = ''a'' invalid?

otra pregunta del conjunto:

byte b;
final short s = 1;
final Short ss = 1;
final int i =1;
final Integer ii = i;
final long L = 1;
final Long LL =1L;

b = s;     // valid
b = ss;    // invalid
b = i;     // valid
b = ii;    // invalid
b = L;     // invalid
b = LL;    // invalid  

Por qué b = L; inválido, mientras que b = s; válido ?

Por favor, no digas que es todo porque JLS lo dijo. Quiero saber por qué JLS tiene estas reglas incoherentes y no intuitivas. ¿Qué me perdí?

Answer 1

Entonces, la línea:

Short s = ''a''; // is valid ...

Porque char es un valor de 16 bits sin signo (el valor máximo es 65.536) y corto tiene un valor de 16 bits (el valor máximo es 32.767), por lo que hay una conversión primitiva de reducción (char a corto) seguida de una conversión de boxeo (corto a corto) )

short s = ''a''; // also valid: narrowing primitive conversion (char -> short)

Estos son casos especiales :

Además, si la expresión es una expresión constante de tipo byte , short , char o int :

• Se puede usar una conversión primitiva de estrechamiento si el tipo de la variable es byte , short o char , y el valor de la expresión constante es representable en el tipo de la variable.

Se puede usar una conversión de primitiva de estrechamiento seguida de una conversión de boxeo si el tipo de la variable es:

• Byte y el valor de la expresión constante es representable en el tipo byte .

• Corto y el valor de la expresión constante es representable en el tipo corto .

• El carácter y el valor de la expresión constante son representables en el tipo char .

Veamos los siguientes ejemplos:

Integer ii = ''a''; // is invalid: not a special case according to Oracle docs
int i = ''a'';      // is valid: widening primitive conversion (char -> int) is allowed

¿Por qué la línea b = L no es válida? Debido a que no es un caso especial descrito anteriormente y podemos perder información (b es byte , mientras que L es largo ), es por eso que debe realizar un lanzamiento explícito:

b = (byte) L; // narrowing primitive conversion (long -> byte)

Además, eche un vistazo a una tabla muy útil.

Hay mucha información sobre todas estas reglas en la documentación de JLS y no necesita preocuparse por ellas. Lo que puedo decir sobre su última pregunta es que sin una conversión de estrechamiento implícito, cualquier literal entero requeriría un molde en los siguientes casos:

// Cast is permitted but not required
byte  b = (byte)  100;
short s = (short) 200;

Pero las siguientes líneas de código parecen más concisas:

byte  b = 100;
short s = 200;