1. double
tipo
Java proporciona el double
tipo para trabajar con números reales (fraccionales). Ocupa 8 bytes
en memoria (el doble que el int
tipo) y puede almacenar valores en el rango de a . A modo de comparación: el tipo puede almacenar un valor en el rango de a .-1.7*10308
+1.7*10308
int
-2*109
+2*109
En números reales, la parte fraccionaria se escribe después de un punto decimal. Por ejemplo, 123,456, 2,5, 100,00 o 0,01. Cuando las computadoras manejan tales números, los llamamos números de coma flotante .
Por cierto, además del double
tipo, también tenemos el float
tipo (que tiene un tamaño de solo 4 bytes). Su nombre proviene del punto flotante . Y el nombre double
proviene de double float . A double
es el doble de grande que a float
: 8 bytes
contra 4
. También se le llama número de coma flotante de doble precisión .
2. Crear un double
tipo
El tipo doble se utiliza para almacenar números reales. Para crear una variable en código que pueda almacenar números reales, debe usar una declaración como esta:
double name;
Donde nombre es el nombre de la variable. Ejemplos:
Declaración | Descripción |
---|---|
|
price Se crea una variable real. |
|
weight Se crea una variable real. |
|
lightSpeed Se crea una variable real. |
Al igual que con el int
tipo, puede usar la abreviatura para crear múltiples double
variables simultáneamente:
double name 1, name 2, name 3;
E incluso asignarles valores inmediatamente:
double name 1 = value 1, name 2 = value 2, name 3 = value 3;
Ejemplos:
Declaración | Nota |
---|---|
|
Las tiendas de variables5.0 |
|
Las tiendas de variables2.0 |
|
3. Asignación de números enteros y reales
Sería malo si los números enteros pudieran asignarse solo a int
variables y los números reales, solo a double
variables. Queremos poder convertir entre los dos tipos de números. Y Java proporciona esta capacidad.
En primer lugar, tanto los números reales como los enteros se pueden asignar a double
las variables. Al asignar números enteros, simplemente se convierten en números reales. Por supuesto, se puede perder algo de precisión en el proceso.
Declaración | Nota |
---|---|
|
Las tiendas de variables5.0 |
|
Las tiendas de variables2.0 |
|
Las x tiendas de variables1000000.0 |
En segundo lugar, si un número entero y un número real están involucrados en alguna expresión, entonces el número entero se convierte primero en un número real y solo entonces se realiza la operación con el otro número real.
Declaración | Nota |
---|---|
|
Las x tiendas de variables5000.0 |
|
El número 10 se mostrará en la pantalla. |
|
El número 10.0 se mostrará en la pantalla. |
Y finalmente, también es posible asignar números reales a int
las variables. Cuando hacemos esto, la parte fraccionaria del número real se descarta: el número se redondea hacia abajo al número entero más cercano.
Además, el compilador requiere que el programador documente explícitamente lo que está sucediendo (para asegurarse de que otros programadores entiendan que se descarta la parte fraccionaria). En general, dicha conversión se ve así en el código:
integer_variable = (int)(real_number);
Ejemplos:
Declaración | Nota |
---|---|
|
Las x tiendas de variables5 |
|
Las x tiendas de variables5 |
|
Las x tiendas de variables11 |
4. Dividir números enteros y números reales en Java
Al dividir un número entero por otro número entero, el resto siempre se descarta. Entonces, ¿cómo podemos dividir 5
por 2
para obtener 2.5
?
Al principio, parece que la opción correcta es:
double d = 5 / 2;
Pero no es tan simple. El problema aquí es que la máquina Java primero calcula el valor de 5 / 2
y solo luego asigna el resultado a la d
variable. Y la 5 / 2
operación es división entera. Ese medio d
contendrá 2
o, para ser más precisos,2.0
La solución correcta es escribir al menos uno de los números involucrados en la división como un número real (es decir, con un punto decimal):
double d = 5.0 / 2;
double d = 5 / 2.0;
double d = 5.0 / 2.0;
En cada una de las expresiones, d
contendrá2.5
Pero, ¿y si estamos trabajando con variables? ¿Qué pasa si tenemos un código como este?:
int a = 5;
int b = 2;
double d = a / b;
Aquí hay una solución ingeniosa (y obvia): obligar a la máquina Java a convertir variables en números reales multiplicándolos por uno como un número real ( 1.0
)
int a = 5;
int b = 2;
double d = a * 1.0 / b;
Tenga en cuenta que la multiplicación y la división tienen la misma precedencia y se realizan de izquierda a derecha. Eso significa que importa dónde multiplicamos el 1.0.
Ejemplos:
Declaración | Orden de ejecución | Resultado |
---|---|---|
|
(1.0 * a) / b; |
2.5 |
|
(a * 1.0) / b; |
2.5 |
|
(a / b) * 1.0; |
2.0 |