1
00:00:00,530 --> 00:00:02,350
Hola y bienvenidos a esta elección.

2
00:00:02,360 --> 00:00:08,000
A continuación vamos a ver el tema de manejo de tipos primitivos de tipo entero en Java están listos.

3
00:00:07,990 --> 00:00:15,490
Vamos bien con nuestro mismo proyecto de Hola mundo vamos a dejar únicamente el método main y la declaración

4
00:00:15,490 --> 00:00:16,370
de la clase.

5
00:00:16,510 --> 00:00:22,400
Quitamos este código y ahora vamos a ver el tema de manejo de tipos primitivos.

6
00:00:22,510 --> 00:00:30,710
Pero vamos a comenzar con los tipos enteros los tipos primitivos de tipo entero son los tipos Boy short

7
00:00:31,250 --> 00:00:33,260
hint y Long.

8
00:00:33,320 --> 00:00:42,490
Según hemos comentado ahora por ejemplo si definimos las variables siguientes bait y declaramos una

9
00:00:42,490 --> 00:00:49,960
variable bait var le podemos asignar cualquier valor por ejemplo en este caso el valor de 15 escribimos

10
00:00:50,020 --> 00:00:55,990
ese Addy para que nos manda imprimir esta variable guardamos cambios y ejecutamos

11
00:01:03,910 --> 00:01:06,710
y podemos observar que nos imprimes sin ningún problema.

12
00:01:06,710 --> 00:01:09,030
El valor de nuestra variable Boyz var.

13
00:01:09,200 --> 00:01:13,550
Sin embargo qué pasa si por ejemplo le asignamos el valor de 150.

14
00:01:13,550 --> 00:01:20,260
Podemos observar que en este caso nos está marcando tipos incompatibles ya que por un lado estamos utilizando

15
00:01:20,320 --> 00:01:28,320
el valor de 150 y del lado izquierdo queremos asignar este valor de 150 a una variable de tipo Bayt.

16
00:01:28,330 --> 00:01:34,060
Por lo tanto nos marca que existe posible pérdida de información al convertir una literal de tipo entero

17
00:01:34,270 --> 00:01:35,150
a un tipo Bayt.

18
00:01:35,770 --> 00:01:42,660
Esto debido a que el tipo entero ocupa 32bits y el tipo bait utiliza 8 bits.

19
00:01:43,010 --> 00:01:47,560
Entonces un valor de 32 bits si lo queremos almacenar en un valor de 8 bits.

20
00:01:47,720 --> 00:01:53,960
Podemos perder información al momento de asignarlo por eso nos marca este error de compatibilidad.

21
00:01:54,050 --> 00:02:02,100
Ahora cómo saber cuál es el rango máximo de los tipos Bayt vamos a hacer lo siguiente Vamos a quitar

22
00:02:02,400 --> 00:02:09,450
este error y vamos a imprimir lo siguiente respecto al tipo Bayt vamos a utilizar la clase bait para

23
00:02:09,450 --> 00:02:18,630
extraer la información del tipo bait así que vamos a utilizar ese dato e imprimimos bits en el tipo

24
00:02:18,630 --> 00:02:23,030
Bayt 2 puntos y utilizamos la clase bit

25
00:02:25,800 --> 00:02:26,380
punto

26
00:02:29,260 --> 00:02:35,630
y con la constante 6 podemos saber el número de bits que contiene este tipo bait guardamos y ejecutamos

27
00:02:38,740 --> 00:02:45,290
y podemos saber que contiene 8 bits el tipo bait bien vamos a continuar con más información de este

28
00:02:45,290 --> 00:02:49,460
tipo vamos a preguntar el número de bits

29
00:02:52,630 --> 00:03:02,940
del tipo bit utilizamos la clase bait y le preguntamos por el número de bits que contiene este tipo

30
00:03:06,790 --> 00:03:14,510
y debido a que contiene 8 bits entonces su valor es de un bit puede almacenar únicamente un bit y vamos

31
00:03:14,510 --> 00:03:15,620
a continuar.

32
00:03:15,620 --> 00:03:28,320
Vamos a ver el valor mínimo del tipo bit así que utilizamos la clase bit y la constante mil valio guardamos

33
00:03:28,350 --> 00:03:29,160
e imprimimos

34
00:03:32,680 --> 00:03:39,620
y podemos ver que el valor mínimo es de 128 así que podemos asignar valores negativos pero hasta el

35
00:03:39,620 --> 00:03:47,490
valor de menos 128 y por último vamos a ver el valor máximo del tipo 20.

36
00:03:47,800 --> 00:03:50,410
Para entender el error que nos marcó anteriormente

37
00:03:53,750 --> 00:04:03,160
así que utilizamos la constante Max Balio guardamos ejecutamos y podemos observar que el valor máximo

38
00:04:03,160 --> 00:04:07,510
que podemos asignar a un tipo Bayt es de 127.

39
00:04:07,510 --> 00:04:13,510
Por ello fue que hace un momento cuando asignamos el valor de 150 falló al momento de querer asignar

40
00:04:13,540 --> 00:04:21,220
este valor ya que como valor máximo podemos asignar únicamente el valor de 127 así que vamos a aprobar

41
00:04:21,280 --> 00:04:29,340
guardamos el valor de 127 en nuestra variable guardamos y ejecutamos y podemos observar que en este

42
00:04:29,340 --> 00:04:34,190
caso si se asigna correctamente el valor de 127 a nuestra variable.

43
00:04:34,590 --> 00:04:41,970
Pero si queremos asignar ya el valor de 128 en positivo entonces ya nos arroja el error de posible pérdida

44
00:04:41,970 --> 00:04:42,930
de conversión.

45
00:04:42,990 --> 00:04:50,580
Al querer asignar un tipo entero que es la literales 128 a un tipo bait por default las literales en

46
00:04:50,580 --> 00:04:57,030
IAVA son de tipo entero y la literal es lo que estamos escribiendo del lado derecho.

47
00:04:57,030 --> 00:05:02,640
Esta es la variable pero del lado derecho lo que estamos describiendo es la literal y por default literales

48
00:05:02,730 --> 00:05:04,260
son de tipo entero.

49
00:05:04,260 --> 00:05:10,980
Sin embargo si la literal cumple con el valor mínimo o el máximo entonces es posible asignarlo al tipo

50
00:05:10,980 --> 00:05:19,210
primitivo bien vamos a poner su valor máximo simplemente para que funcione ya nuestro programa.

51
00:05:19,440 --> 00:05:27,370
Ahora vamos a continuar vamos a aprobar ahora el tipo Llort definimos una variable de tipo Llort short

52
00:05:27,490 --> 00:05:29,760
bar igual

53
00:05:32,920 --> 00:05:34,820
por ejemplo al valor de 1000.

54
00:05:34,960 --> 00:05:41,410
Podemos observar que no marca ningún problema vamos a imprimir esta variable guardamos los cambios y

55
00:05:41,410 --> 00:05:42,160
ejecutamos

56
00:05:46,230 --> 00:05:51,900
y podemos ver que desbordar lo está imprimiendo sin ningún problema quiere decir que este valor lo soporta

57
00:05:51,900 --> 00:05:52,740
sin ningún problema.

58
00:05:53,040 --> 00:05:58,250
Pero cómo saber cuáles son los límites de este tipo de dato.

59
00:05:58,260 --> 00:06:04,980
Para ello vamos a apoyarnos de lo que ya hemos venido trabajando pero ahora para el tipo Llort.

60
00:06:05,110 --> 00:06:06,880
Así que copiamos estas líneas de código

61
00:06:09,640 --> 00:06:11,200
y vamos a imprimir la información.

62
00:06:11,440 --> 00:06:25,150
Pero ahora para el tipo short así que cambiamos de bait a short la clase que se va a utilizar ahora

63
00:06:25,210 --> 00:06:25,910
es short

64
00:06:33,770 --> 00:06:35,450
cambiamos las cuatro líneas de código

65
00:06:38,110 --> 00:06:42,490
para que podemos observar el detalle de la información del tipo short

66
00:06:45,310 --> 00:06:53,290
bien ya tenemos los cuatro valores guardamos cambios y ejecutamos y podemos observar que para el tipo

67
00:06:53,290 --> 00:07:03,710
Llor tenemos 16bits es decir que son dos bits y el valor mínimo es de menos 32 mil 768 y el valor positivo

68
00:07:03,860 --> 00:07:11,390
es 32 mil 767 quiere decir que si nos pasamos de estos números de este rango entonces vamos a tener

69
00:07:11,390 --> 00:07:14,480
problemas para asignar el valor a nuestra variable de tipo Yor.

70
00:07:14,660 --> 00:07:22,650
Vamos a comprobarlo tomamos el valor máximo y lo podemos asignar sin ningún problema al tipo var pero

71
00:07:22,650 --> 00:07:25,730
si nos pasamos entonces nos manda al error.

72
00:07:25,770 --> 00:07:32,370
De igual manera incompatibilidad de tipos posible pérdida de conversión al querer asignar un tipo entero

73
00:07:32,610 --> 00:07:39,790
que es la literal de tipo entero del lado derecho y lo queremos asignar a un tipo Llort así que debemos

74
00:07:39,790 --> 00:07:45,450
de tener cuidado también pero de esta manera podemos acceder rápidamente a la información del valor

75
00:07:45,450 --> 00:07:50,070
mínimo y máximo de nuestra variable primitiva de tipo Llort.

76
00:07:50,190 --> 00:07:52,500
Ahora vamos a definir una variable de tipo entero

77
00:07:55,670 --> 00:08:02,360
Ingvar le asignamos cualquier valor en este caso el valor por ejemplo de 5 000.

78
00:08:02,430 --> 00:08:08,730
Podemos observar que lo pueda asignar sin ningún problema imprimimos el valor de la variable guardamos

79
00:08:08,730 --> 00:08:10,020
cambios e imprimimos

80
00:08:12,860 --> 00:08:15,970
y podemos observar que imprime sin ningún problema esta variable.

81
00:08:16,140 --> 00:08:24,760
Bien ahora vamos a ver la información del tipo primitivo int así que ahora utilizamos estas líneas de

82
00:08:24,760 --> 00:08:33,520
código pero todos lo vamos a cambiar por Hint sin embargo en este caso la clase que vamos a utilizar

83
00:08:33,670 --> 00:08:39,080
no se llama int sino se llama integra el tipo primitivo se llama int.

84
00:08:39,370 --> 00:08:45,910
Pero la clase relacionada con este tipo es integer así que hacemos los cambios

85
00:09:08,790 --> 00:09:12,280
bien y con esto vamos a ver la información del tipo int.

86
00:09:12,280 --> 00:09:21,720
Guardamos cambios y ejecutamos y podemos observar que en este caso el tipo int tiene 32 bits esto es

87
00:09:21,900 --> 00:09:24,840
4 bits y el valor mínimo.

88
00:09:24,840 --> 00:09:32,040
Podemos observar que ya contiene mucho más dígitos y también el valor máximo ya es un número más grande

89
00:09:32,250 --> 00:09:39,240
ya que tenemos 32 bits para almacenar este número y vamos a hacer la prueba de valor máximo ponemos

90
00:09:39,240 --> 00:09:46,050
el valor máximo lo puede asignar sin ningún problema pero si nos pasamos por un dígito entonces ya nos

91
00:09:46,050 --> 00:09:51,660
marca un error de compatibilidad ya no nos marca posible pérdida de información sino que nos indica

92
00:09:51,660 --> 00:09:54,390
que el tipo entero es demasiado largo.

93
00:09:54,420 --> 00:10:01,120
Vamos a ver más adelante cómo corregir esto así que no nos podemos pasar del valor del tipo entero ya

94
00:10:01,120 --> 00:10:04,810
que no podremos asignarlo a esta variable de tipo entero.

95
00:10:04,810 --> 00:10:14,150
Y por último vamos a ver el tipo log definimos una variable primitiva de tipo long long var le asignamos

96
00:10:14,630 --> 00:10:23,110
cualquier valor por ejemplo el valor de 100 y ahora vamos a apoyarnos desde líneas de código para conocer

97
00:10:23,110 --> 00:10:31,460
la información del tipo primitivo log damos un formato clic derecho Format y hacemos los cambios bits

98
00:10:31,550 --> 00:10:32,260
de tipo log

99
00:10:42,100 --> 00:10:44,750
y utilizamos en este caso la clase lonko

100
00:10:48,240 --> 00:10:52,460
ya que es la clase relacionada a este tipo primitivo para conocer su información

101
00:10:55,360 --> 00:10:57,540
bien guardamos cambios y ejecutamos

102
00:11:00,510 --> 00:11:10,650
y podemos observar los bits para el tipo long es de 64 el número de bits es igual a 8 así que ya tenemos

103
00:11:10,650 --> 00:11:14,190
también bastante más espacio para almacenar este número.

104
00:11:14,220 --> 00:11:19,740
Por lo tanto el valor mínimo ya es un número bastante grande y el valor máximo también es un número

105
00:11:19,740 --> 00:11:21,030
bastante grande.

106
00:11:21,060 --> 00:11:28,170
Ese es el rango que tenemos para el tipo long y vamos a poner a prueba y aquí viene algo interesante

107
00:11:28,680 --> 00:11:35,880
respecto al manejo de literales en Java recordemos que las literales en Java si no establecemos otra

108
00:11:35,880 --> 00:11:43,080
cosa esta literal es de tipo entero quiere decir que su valor máximo es el que hemos escrito en esta

109
00:11:43,080 --> 00:11:47,570
variable y nosotros queremos escribir un número bastante más grande.

110
00:11:47,700 --> 00:11:53,100
Por lo tanto vamos a ver el error que nos arroja el valor del entero es demasiado largo.

111
00:11:53,100 --> 00:11:57,790
Ahora cómo hacemos para utilizar este valor máximo del tipo long.

112
00:11:58,170 --> 00:12:01,930
Necesitamos indicar que esta literal debe de ser de tipo log.

113
00:12:02,220 --> 00:12:09,900
Y para hacerlo en Java podemos utilizar una L al final de la literal y entonces esta literal se convierte

114
00:12:09,900 --> 00:12:13,080
en automático a una literal de tipo lonko.

115
00:12:13,410 --> 00:12:20,120
Así que una cosa es el valor de la variable el tipo de la variable y otra cosa es el tipo de la literal.

116
00:12:20,220 --> 00:12:25,020
Debemos de tener cuidado con ambas cuestiones cuando estamos trabajando con Java ya que no solamente

117
00:12:25,020 --> 00:12:29,700
es el tipo de dato sino también el valor de la literal que estamos utilizando.

118
00:12:29,700 --> 00:12:35,770
Debemos estar seguros que el valor de la literal corresponda con el valor que necesitamos.

119
00:12:35,850 --> 00:12:39,830
Podemos utilizar una L mayúscula o una L minúscula.

120
00:12:39,930 --> 00:12:45,720
Sin embargo esto puede ser riesgoso a utilizar una L minúscula ya que podemos observar que parece que

121
00:12:45,720 --> 00:12:52,190
es el número uno y esto podría provocar mucha confusión para la gente que inicia con Java.

122
00:12:52,380 --> 00:12:57,760
Pensaríamos que es un número que termina con el número de uno pero no es así.

123
00:12:57,810 --> 00:13:02,520
Esto es una L indicando que es una literal de tipo lonko.

124
00:13:02,580 --> 00:13:08,910
Por ello lo más recomendable es utilizar la L mayúscula aquí nos faltó imprimir el valor de esta variable

125
00:13:08,910 --> 00:13:18,890
ponemos ese Addy tabulador e imprimimos el valor de la variable lonko guardamos y ejecutamos y entonces

126
00:13:18,890 --> 00:13:26,090
podemos observar que ya podemos asignar el valor máximo de la variable esta literal a nuestra variable

127
00:13:26,180 --> 00:13:27,290
de tipo log.

128
00:13:27,380 --> 00:13:33,140
Podemos observar que ya no se muestra la L ya que la l únicamente fue para indicar que el valor de la

129
00:13:33,140 --> 00:13:34,620
literal es de tipo longe.

130
00:13:34,820 --> 00:13:41,000
Pero aquí obviamente ya no se va a observar la l únicamente se va a mostrar el número y si ponemos L

131
00:13:41,000 --> 00:13:42,170
minúscula.

132
00:13:42,170 --> 00:13:51,600
De igual manera aunque parece que este es un número incluyendo un 1 al final si ejecutamos podemos observar

133
00:13:51,600 --> 00:13:55,710
que realmente no era un 1 sino una L minúscula.

134
00:13:55,710 --> 00:14:01,120
Por lo tanto en este punto ya no se muestra ninguna l al final bien.

135
00:14:01,140 --> 00:14:07,470
Ahora si nos queremos pasar de este valor ponemos el valor por ejemplo de 8.

136
00:14:07,470 --> 00:14:14,490
Al final nos muestran que el valor es demasiado largo para este tipo entero aunque realmente es una

137
00:14:14,490 --> 00:14:18,630
literal de tipo Nong ya tampoco soporta este valor.

138
00:14:18,630 --> 00:14:23,670
Más adelante vamos a ver otros tipos pero en este caso ya tendríamos que convertirlo por ejemplo a un

139
00:14:23,670 --> 00:14:33,920
tipo flat poniendo una F o tendríamos que convertir esta literal a un tipo doble poniendo una de Sin

140
00:14:33,920 --> 00:14:39,030
embargo también del lado izquierdo tendríamos que cambiar el tipo para que pudiera asignar este valor.

141
00:14:39,380 --> 00:14:44,840
Pero esto lo vamos a ver más adelante cuando veamos los tipos flotantes de momento este valor es el

142
00:14:44,840 --> 00:14:50,630
máximo que podemos trabajar cuando manejamos tipos enteros.

143
00:14:50,770 --> 00:14:57,810
Y por último vamos a mencionar lo siguiente del manejo de tipos pero utilizando la variable var si definimos

144
00:14:57,810 --> 00:15:08,730
una variable por ejemplo var número y le asignamos el valor de 10 la pregunta sería de qué tipo es esta

145
00:15:08,730 --> 00:15:10,530
variable que hemos declarado.

146
00:15:10,970 --> 00:15:16,010
Y si mandamos a imprimir esta variable guardamos

147
00:15:18,990 --> 00:15:21,690
y podemos ejecutar sin ningún problema este valor.

148
00:15:22,600 --> 00:15:29,820
Si esta variable fuera de tipo bait entonces el valor máximo que podríamos asignar es el valor de 127.

149
00:15:30,190 --> 00:15:31,030
Vamos a aprobar

150
00:15:33,870 --> 00:15:40,410
soporta el valor 127 sin ningún problema y si nos pasamos del valor máximo del UIT-T entonces podemos

151
00:15:40,410 --> 00:15:42,540
asignar el valor de 128.

152
00:15:42,540 --> 00:15:49,650
Esto quiere decir que esta variable no es de tipo bait ya que soporta un valor mayor a su valor máximo.

153
00:15:49,710 --> 00:15:59,460
Entonces de qué tipo de esta variable vamos a continuar ponemos el valor máximo de tipo short y lo aumentamos

154
00:15:59,460 --> 00:16:03,750
en 1 y podemos ver que también lo podemos asignar sin ningún problema.

155
00:16:03,810 --> 00:16:09,090
Por lo tanto esto quiere decir que esta variable tampoco es de tipo Llort ya que pudimos superar el

156
00:16:09,090 --> 00:16:11,010
valor máximo del tipo Llort.

157
00:16:11,340 --> 00:16:18,890
Ahora vamos a asignar el valor máximo del tipo int lo podemos asignar sin problema pero si pasamos el

158
00:16:18,890 --> 00:16:25,580
valor máximo entonces quiere decir que esta variable es de tipo lonko ya que no pudimos superar el valor

159
00:16:25,580 --> 00:16:28,070
máximo del tipo entero.

160
00:16:28,070 --> 00:16:34,460
Por lo tanto quiere decir que esta variable por default si le asignamos un valor de tipo número por

161
00:16:34,480 --> 00:16:36,520
default va a ser de tipo entero.

162
00:16:36,620 --> 00:16:42,230
Sin embargo también la podremos convertir a tipo longe simplemente convirtiendo la literal a un tipo

163
00:16:42,230 --> 00:16:49,610
long y por lo tanto detecta que necesitamos del lado izquierdo una variable que soporte este tipo lounge

164
00:16:51,310 --> 00:16:56,880
y nuestra variable en este momento se convierte de tipo entero a un tipo lounge ya que así lo hemos

165
00:16:56,880 --> 00:17:04,080
establecido necesitamos una variable tal que soporte un valor de tipo longe así que con esto podemos

166
00:17:04,080 --> 00:17:12,000
observar que dependiendo del tipo que necesitemos declaramos la literal y en automático var va a definir

167
00:17:12,030 --> 00:17:18,180
el tipo que necesitamos para nuestra literal así que es una de las ventajas también utilizar var ya

168
00:17:18,180 --> 00:17:20,980
no tenemos que preocuparnos tanto por nuestro tipo de dato.

169
00:17:21,000 --> 00:17:27,240
Sin embargo en este caso no podemos utilizar ni short ni bait únicamente vamos a poder utilizar los

170
00:17:27,240 --> 00:17:33,790
tipos int y Long cuando estamos trabajando con tipos enteros vamos a poner los dos ejemplos para que

171
00:17:33,790 --> 00:17:35,080
los tengan en su código

172
00:17:42,190 --> 00:17:51,230
ponemos número int ponemos el valor máximo y en dado caso que necesitemos ya una variable de tipo long

173
00:17:53,480 --> 00:17:57,450
simplemente al poner el valor máximo ya lo hemos superado.

174
00:17:57,500 --> 00:18:03,140
Por lo tanto necesitaríamos una variable de tipo longe imprimimos el valor de nuestras variables

175
00:18:05,880 --> 00:18:14,770
número int y número log para que tengan las referencias guardamos cambios y ejecutamos

176
00:18:18,360 --> 00:18:23,610
así que tenemos la variable que es de tipo entero y en este caso ya nos hemos pasado de rango por lo

177
00:18:23,610 --> 00:18:29,580
tanto necesitamos una variable de tipo log y podemos llevar en automático var le asigna el tipo que

178
00:18:29,580 --> 00:18:35,410
necesitamos a nuestra variable de tipo entero o de tipo long respectivamente.

179
00:18:35,460 --> 00:18:38,370
Eso es todo por esta elección y nos vemos en el siguiente vídeo.

180
00:18:38,370 --> 00:18:39,000
Saludos.
