Java desde 0: Números Decimales

Tags: tutorial, java, beginners, spanish
Published: 2021-01-16 04:00:14

Última actualización: 20/1/2020

## ¿Qué haremos?

### [Números Decimales](#section-1) — Teoría
### [Operaciones](#section-2) — Práctica
### [Letras especiales en números](#section-3) — Teoría

## Tutorial

### Números Decimales <a name="section-1"></a>

En el capítulo anterior hablamos sobre los números enteros, este capítulo hablaremos de los números decimales. Si lo se más números… woohoo…

Java tiene 8 datos primitivos, veremos 2 de estos hoy, ya vimos 4 en el tutorial pasado:

* `float`: Un número que puede estar desde del 1.4 **E** -45 al 3.4028235 **E** 38.
* `doubles`: Un número que puede estar desde del 1.4 **E** -45 al .9 **E** -324.

**¡Genial, números y letras(E)! ¿Qué sigue? ¿Álgebra?**

Hey no espera esas (**E**) significan notación científica o sea multiplicar o dividir por 10. A ver te recuerdo.

```java
// Mutiplicando
1.5 * 10 = 15
0.15 * 10^2 = 15
0.015 * 10^2 = 15

// Dividiendo
15 / 10 = 1.5
15 / 10^2 = 0.15
15 / 10^3 = 0.015
```
El signo (`^`) significa elevado o sea que `10^2 = 100` y `10^3 = 1000`. Si te cuesta multiplicar y dividir solo cuenta el número de 0s. Java representa el (`^`) de esta forma (`E`). Entonces `0.22E2 sería: 0.22 * 100^ 2`.

Entonces porque los tipos de datos que son decimales tienen un rango de número digamos “raro”. Bueno todo gracias a esto:

{% wikipedia https://en.wikipedia.org/wiki/IEEE_754 %}

Si lo sé más mátematicas… descuida no tocaremos eso por ahora. Solo piensa que los decimales tienen **32 bits y 64 bits** o si quieres adornarlo usa “**Punto flotante IEEE 754 de 32 bits y 64 bits”.**

```java
double decimal = 12.345;
```

*Declaración de una variable decimal.*

### Operaciones <a name="section-2"></a>

Solo daremos las básicas…

```java
10 + 10 // Sumar
10 + 10 // Sumar
10 - 10 // Restar
10 * 10 // Multiplicar
10 / 10 // Dividir
```

Y si te preguntabas puedes guardar los resultados de las operaciones en variables.

```java
int número = 10 + 10;
```

### Letras especiales en números <a name="section-3"></a>

El tutorial pasado dije que explicaría que significa la ‘L’ en el tipo de dato `long` y eso es lo que haremos ahora.

Resulta que Java por predeterminados interpreta que los números enteros son tipo de dato `int` y que los números decimales son tipo de dato `double`.

Entonces para java…

```java
12.345 // Esto es un double
12345 // Esto es un int
```

Si utilizas otro tipo de dato como `long` o `float` entonces esto dará error al compilarlo.

```java
long decimal = 12.345; // Esto es un double
long entero = 12345; // Esto es un int
```

**A ver no entiendo ¿Por qué no pasa con los otros tipos de datos? como**`byte`**o**`short`.

Para eso tenemos que hablar de precisión. ¿Recuerdas los rangos de los tipos de datos del último tutorial? ¿No? Bueno yo tampoco. Te pasaré una tabla para entender esto de la precisión.

![Frame 17](https://dev-to-uploads.s3.amazonaws.com/i/140o3xg67gk9o5jzeml9.png)
 
Entonces esto ya que `byte` y `short` tienen menos bits que `int` no tienes que poner ninguna letra pero si con `long`. Imagina una caja 8 bit, esta cabe dentro del 16 bit, 32 bit y 64 bit ya que contiene mas bits pero 32 bit no puede estar dentro de 16 bit o 8 bit pero si de 64 bit. Te ilustro mejor para que entiendas:

![](https://dev-to-uploads.s3.amazonaws.com/i/ljs2grk8t1nt7gdiqf08.png)
 
Como puedes ver el `long` no puede estar dentro de un `int` ya que es demasiado grande. Si comparas las cajas su tamaño se duplica cada vez más. Por esto hay que saber que utilizar para no utilizar más de lo que se debe.

**Entonces, ¿Cuál es el uso en Java para especificar el tipo de datos?**

Tienes que saber que es una literal para entender porque pasa, una literal es un número en java que no es computado sino escrito por el programador o sea:

```java
byte a = 10; // Esto es un literal
byte b = 10; // Esto es un literal
byte c = (byte) (a + b); // Esto es una variable creada en ejecución
```

La variable `c` se crea a partir de otras dos variables, su valor no es fijo o constante ya que el valor `a` y `c` se desconoce hasta que se ejecute el archivo, sin embargo `a` y `c` tienen un valor fijo o constante que es 10, este ya se conoce y el compilador no tendrá que calcular este valor, entonces los números `10` Java los ve como números enteros tipo `int` no como tipo `byte`. Como `byte` es mas pequeño que que `int` pues entonces este puede estar dentro de el. Cuando sumamos dos números tipo `byte` en Java los suma como tipo `int`. Así que tenemos que explícitamente decirle a la variable `c` que no la sume como `int` sino como `byte` .

Si hacemos esto con `long` entonces no pasará nada ya que los `int` pueden estar dentro de `long`.

```java
long a = 10;
long b = 10;
long c = a + b;
```

Pero si con `byte` y `short`. Esto pasa igual con los `float`.

```java
float a = (float) 10.0;
float b = (float) 10.0;
float c = a + b;
```

Ya que los `float` son interpretados como `double` entonces hay que hacer lo mismo con las variables `a` y `b` pero no la `c` ya que las literales son convertidas a `float`.

Puedes opcionalmente usar letras como `f` para float así:

```java
float a = 10.0f;
```

## Ejercicio

El [programa](https://gitpod.io/#/https://github.com/CodeWithClassyBear/java-desde-0/tree/master/N%C3%BAmeros%20Decimales) no esta correcto, tendrás que encontrar los errores de este según lo aprendido. Puedes revisar `NúmerosDecimalesRespuesta` sino puedes resolver el problema.

## Para saber más

```java
// El número 26, en decimal
int decimal = 26;
// El número 26, en hexadecimal
int hexVal = 0x1a;
// El número 26, en binario
int vinVal = 0b11010;
```

Veremos el número hexadecimal luego en la serie.

---

Si tienes preguntas o alguna sugerencia me puedes dejar un comentario :)

Me encuentro también en [Medium](https://classy-bear.medium.com) haciendo tutoriales.

Donaciones:
* Bitcoin — `bc1qhr9jhlj5wvrkah5v4kkdvf6ggskjpf8m82f5cj`
* BAT o Brave Rewards — `0x391b5DAe375ca6a20fACd0f7afc461fAc56d1864`
* Patreon — [classyBear](https://www.patreon.com/classyBear)