Sintassi di base:
`` `Java
fluttuare myfloat =1.23f; // o 1.23f
`` `
Spiegazione:
* Il numero: Questo è il valore numerico che desideri rappresentare come numero di punto mobile. Può includere un punto decimale (`.`) per separare le parti interi e frazionarie.
* `f` o` f` suffisso: Questo è *cruciale *. Senza il suffisso `F` o` F`, il compilatore Java tratterà il letterale come un `doppio` (il tipo di punto galleggiante predefinito) e produrrà un errore di compilation perché stai cercando di assegnare una variabile` doppia ".
Esempi:
* Decimal semplice:
`` `Java
float pi =3.14159f;
`` `
* Solo parte intera:
`` `Java
Float Thuonumber =10F;
`` `
* Solo parte frazionaria:
`` `Java
Float justFraction =.5f; // equivalente a 0,5f
`` `
* Notazione scientifica (notazione esponenziale):
`` `Java
fluttuare moltosmall =1.0e-6f; // 1,0 x 10^-6 =0,000001
fluttuare moltolarge =2.5e8f; // 2,5 x 10^8 =250000000.0
`` `
* Numeri negativi:
`` `Java
Float NegativeValue =-2.718f;
`` `
Considerazioni importanti:
* Precisione: `Float` è un tipo a punto galleggiante a precisione a precisione a 32 bit. Offre meno precisione di `double` (che è a doppia precisione a 64 bit). Pertanto, `float` potrebbe non essere adatto a calcoli che richiedono una precisione molto elevata.
* `double` vs.` float`: Se non usi esplicitamente il suffisso `f` o` f`, Java interpreta il letterale del punto mobile come un `doppio`. È possibile assegnare un letterale `float 'direttamente a una variabile` doppia `senza problemi.
`` `Java
doppio mydouble =1.23f; // perfettamente valido
raddoppia un altro double =1.23; // anche valido (1.23 è trattato come un doppio letterale)
`` `
* Casting (evitare se possibile): * Puoi * esplicitamente lanciare un `doppio` a un` float`, ma questo può potenzialmente portare alla perdita di precisione:
`` `Java
Double Adouble =3.14159265359;
float afloat =(float) adouble; // perdita di precisione è possibile
`` `
È generalmente meglio usare i letterali `float 'dall'inizio se è necessario archiviare il valore in una variabile` float'.
* `nan` e infinito: Puoi anche rappresentare `nan` (not-a-number) e infinito usando` float`:
`` `Java
float notanumber =float.nan;
float positivoInfinity =float.positive_infinity;
float negativeInfinity =float.negative_infinity;
`` `
In sintesi:
Per definire correttamente un letterale `float 'in Java, aggiungi sempre il suffisso` f` o `f` al numero. Questo dice al compilatore di trattare il letterale come un valore a punto mobile a singola precisione. Ricorda che `float` ha meno precisione di` double`, quindi scegli il tipo appropriato in base ai requisiti di precisione della tua applicazione.
Programmazione © www.354353.com