1
00:00:00,310 --> 00:00:02,040
Hola bienvenidos a esta elección.

2
00:00:02,040 --> 00:00:07,620
A continuación vamos a continuar viendo el tema de tipos primitivos pero ahora utilizando tipos flotantes

3
00:00:07,970 --> 00:00:09,130
que están listos.

4
00:00:09,150 --> 00:00:12,720
Vamos bien vamos a eliminar este código de nuestra clase

5
00:00:15,630 --> 00:00:22,260
y se lo dejamos el método main bien en esta elección vamos a ver los tipos primitivo flop y doble.

6
00:00:22,430 --> 00:00:32,060
Vamos a declarar primero una variable de tipo flat llamada Flow bar y le asignamos un tipo numérico.

7
00:00:32,060 --> 00:00:40,540
Por ejemplo el valor de 1000 imprimimos este valor con ese Addy guardamos cambios y ejecutamos

8
00:00:43,330 --> 00:00:49,460
y podemos observar que a diferencia de los tipos numéricos en este caso en automático le agrega un punto

9
00:00:49,460 --> 00:00:50,480
decimal.

10
00:00:50,480 --> 00:00:53,680
Así que con esto ya estamos manejando tipos flotantes en Java.

11
00:00:53,810 --> 00:01:03,340
Sin embargo si nuestro número le queremos agregar un tipo flotante por ejemplo 1000 0.10 entonces aquí

12
00:01:03,360 --> 00:01:09,090
nos marca un error ya que por default las literales en Java de tipo flotante son de tipo doble.

13
00:01:09,790 --> 00:01:15,420
Y el error que nos marca es si existe incompatibilidad de tipos ya que existe posible pérdida de información

14
00:01:15,660 --> 00:01:19,720
al querer convertir nuestra literal de tipo doble a un tipo float.

15
00:01:20,050 --> 00:01:26,070
Así que por default no podemos asignar simplemente una literal con punto flotante a una variable de

16
00:01:26,070 --> 00:01:27,080
tipo float.

17
00:01:27,090 --> 00:01:33,900
Para esto debemos especificar que esta literal debe de ser de tipo Flour y para ello utilizamos la letra

18
00:01:33,990 --> 00:01:41,710
F y con esto lo que estamos haciendo es convertir nuestra literal de tipo doble que es el tipo por default

19
00:01:41,740 --> 00:01:46,880
en tipo flotante a tipo flat guardamos los cambios y ejecutamos

20
00:01:50,990 --> 00:01:58,380
y podemos observar que si vemos el valor de 1000 puntos uno los ceros hacia la derecha se omiten y únicamente

21
00:01:58,380 --> 00:02:05,310
se imprime el valor punto 1 pero con esto ya podemos asignar el valor de una literal flotante a una

22
00:02:05,310 --> 00:02:10,380
variable de tipo float y de igual manera si utilizamos var.

23
00:02:10,680 --> 00:02:15,810
En este caso se está declarando una variable de tipo flotante ya que del lado derecho estamos utilizando

24
00:02:15,840 --> 00:02:23,610
una literal de tipo flotante pero si quitamos esta letra f entonces esta literal del lado derecho es

25
00:02:23,610 --> 00:02:29,790
de tipo doble y por lo tanto esta variable ya no es de tipo flotante sino de tipo double.

26
00:02:29,810 --> 00:02:32,440
Esto lo vamos a ver a continuación.

27
00:02:32,680 --> 00:02:40,340
De momento vamos a dejar nuestra literal f y vamos a extraer la información de nuestra clase float.

28
00:02:40,340 --> 00:02:52,040
Para ello vamos a escribir lo siguiente bits en el tipo float dos puntos y concatenados el valor de

29
00:02:52,040 --> 00:02:59,330
nuestra clase float e imprimimos la constante 6 guardamos imprimimos el valor

30
00:03:02,720 --> 00:03:06,240
y podemos observar que un tipo flotante utiliza 32 bits

31
00:03:16,000 --> 00:03:20,680
ahora imprimimos el número de bits guardamos cambios ejecutamos

32
00:03:24,240 --> 00:03:29,630
y podemos observar que son 4 bits según lo que esperamos 32 bits son 4 bits

33
00:03:32,250 --> 00:03:35,040
posiblemente imprimimos el valor mínimo en el tipo float

34
00:03:42,810 --> 00:03:46,310
y es que vivimos float punto min valio

35
00:03:50,070 --> 00:03:51,900
guardamos cambios ejecutamos

36
00:03:54,490 --> 00:03:57,430
y podemos ver que el valor mínimo ya es un número.

37
00:03:57,490 --> 00:04:01,360
Connotación exponencial ya que es un número demasiado grande.

38
00:04:01,390 --> 00:04:07,990
Podemos observar que es 1.4 exponente al menos 45 e imprimimos el valor máximo

39
00:04:16,560 --> 00:04:27,760
float punto más Balio guardamos cambios ejecutamos el valor máximo en positivo es 3.4 exponente a la

40
00:04:27,760 --> 00:04:35,190
38 así que con esto podemos observar que los rangos son muchísimo más grandes a pesar de que contiene

41
00:04:35,190 --> 00:04:37,420
32 bits como el tipo entero.

42
00:04:37,500 --> 00:04:44,160
Al utilizar un tipo flotante puede utilizar notación exponencial y por lo tanto almacenar números mucho

43
00:04:44,160 --> 00:04:45,310
más grandes.

44
00:04:45,780 --> 00:04:55,550
Vamos a ver ahora el tipo doble definimos una variable de tipo doble llamada ovular y en este caso podemos

45
00:04:55,550 --> 00:05:02,210
observar que si podemos utilizar directamente un tipo flotante ya que esta literal por default es de

46
00:05:02,210 --> 00:05:08,720
tipo doble y por lo tanto lo asigna sin ningún problema a nuestra variable de tipo doblá vamos a imprimirla

47
00:05:11,990 --> 00:05:19,320
guardamos cambios ejecutamos y podemos observar el valor.

48
00:05:19,320 --> 00:05:24,420
Sin embargo también si quisiéramos ser más explícitos en esta literal que sea de tipo doble podemos

49
00:05:24,420 --> 00:05:31,950
utilizar la literal de ya que también en ocasiones podemos definir literales de tipo entero.

50
00:05:31,980 --> 00:05:38,340
Sin embargo especificar que es una literal de tipo doble así que con la de en mayúscula o minúscula

51
00:05:38,670 --> 00:05:41,380
estamos especificando que esta literal es de tipo doble.

52
00:05:42,010 --> 00:05:49,310
Y si del lado izquierdo utilizamos var debido a que en este caso estamos indicando que la literal es

53
00:05:49,310 --> 00:05:53,390
de tipo doble también la variable va a ser de tipo doble.

54
00:05:53,750 --> 00:05:59,690
Sin embargo si quitamos la de entonces esta variable ya no sería de tipo doble sino sería de tipo entero

55
00:06:00,080 --> 00:06:06,350
así que es importante la literal que definamos cuando estamos trabajando con var engordamos cambios

56
00:06:06,350 --> 00:06:07,160
ejecutamos

57
00:06:10,710 --> 00:06:17,080
y podemos observar que aunque la literal fue 100 estamos observando el resultado de 100.1 bien y ahora

58
00:06:17,080 --> 00:06:20,240
vamos a ver los valores de nuestra clase Doble.

59
00:06:20,950 --> 00:06:30,910
Podemos apoyarnos de este código y simplemente hacemos el cambio la clase que se utiliza es la clase

60
00:06:30,980 --> 00:06:31,630
W.

61
00:06:53,100 --> 00:06:59,030
Hacemos cada uno de los cambios y con esto ya tenemos la información de la clase de.

62
00:06:59,510 --> 00:07:09,020
Guardamos cambios y ejecutamos y podemos observar que el tipo utiliza 64bits así que es el tipo permitido

63
00:07:09,020 --> 00:07:11,030
más grande que podemos utilizar.

64
00:07:11,030 --> 00:07:18,690
Esto quiere decir que son 8 bits y el valor mínimo posible que almacena este número es 4.9 exponente.

65
00:07:18,690 --> 00:07:26,600
Al menos 324 así que ya es un número también bastante grande y el valor máximo es 1.79 exponente a la

66
00:07:26,690 --> 00:07:31,070
€300 8 así que ese es el uso de los tipos primitivos.

67
00:07:31,160 --> 00:07:36,380
Ya hemos visto los tipos enteros y en esta lección hemos visto los tipos flotante.

68
00:07:36,640 --> 00:07:40,420
Así que con esto ya hemos visto todos los tipos numéricos primitivos en Java.

69
00:07:40,530 --> 00:07:43,790
Bien eso es todo por esta elección y nos vemos en el siguiente video.

70
00:07:43,800 --> 00:07:44,420
Saludos.
