Sintaxis básica:
`` `Java
flotante myfloat =1.23f; // o 1.23f
`` `` ``
Explicación:
* El número: Este es el valor numérico que desea representar como un número de punto flotante. Puede incluir un punto decimal (`.`) para separar el entero y las partes fraccionales.
* `f` o` f` sufijo: Esto es *crucial *. Sin el sufijo `f` o` f`, el compilador Java tratará el literal como un `doble` (el tipo de punto flotante predeterminado) y producirá un error de compilación porque está tratando de asignar una variable` doble` a una variable `flotante '.
Ejemplos:
* decimal simple:
`` `Java
flotante pi =3.14159f;
`` `` ``
* Parte entero solamente:
`` `Java
float wholenumber =10f;
`` `` ``
* solo parte fraccional:
`` `Java
float justFraction =.5f; // equivalente a 0.5f
`` `` ``
* notación científica (notación exponencial):
`` `Java
FLOAT MUYSMALL =1.0E-6F; // 1.0 x 10^-6 =0.000001
float muygarge =2.5e8f; // 2.5 x 10^8 =250000000.0
`` `` ``
* Números negativos:
`` `Java
Float negativo Value =-2.718f;
`` `` ``
Consideraciones importantes:
* Precisión: `Float` es un tipo de punto flotante de 32 bits de precisión. Ofrece menos precisión que `doble` (que es de doble precisión de 64 bits). Por lo tanto, `float` podría no ser adecuado para los cálculos que requieren una precisión muy alta.
* `double` vs.` float`: Si no usa explícitamente el sufijo `f` o` f`, Java interpreta el literal de punto flotante como un 'doble'. Puede asignar un literal `float` directamente a una variable` doble 'sin ningún problema.
`` `Java
doble myDouble =1.23f; // perfectamente válido
duplicar otro Double =1.23; // también válido (1.23 se trata como un doble literal)
`` `` ``
* Casting (evite si es posible): * Puede * lanzar explícitamente un `doble` a un` float`, pero esto puede conducir a la pérdida de precisión:
`` `Java
doble AdeoL =3.14159265359;
flotante a flote =(flotante) aduba; // es posible la pérdida de precisión
`` `` ``
En general, es mejor usar literales de `float` desde el principio si necesita almacenar el valor en una variable 'flotante'.
* `nan` e infinito: También puede representar `nan` (no un número) e infinito usando 'float':
`` `Java
float nonumber =float.nan;
float positionInfinity =float.positivo_infinity;
float negativoinfinity =float.negative_infinity;
`` `` ``
En resumen:
Para definir correctamente un `` flotador 'literal en Java, siempre agregue el sufijo `f` o` f` al número. Esto le dice al compilador que trate el literal como un valor de punto flotante de una sola precisión. Recuerde que `Float` tiene menos precisión que 'Double', por lo tanto, elija el tipo apropiado en función de los requisitos de precisión de su aplicación.