1
00:00:00,330 --> 00:00:05,580
Continuamos con los primitivos, vamos a crear una nueva clase para dejar el mundo como está y tener

2
00:00:05,620 --> 00:00:11,730
algún respaldo, aunque también podrían seleccionar todo acá y lo pueden quitar y pueden escribe código

3
00:00:11,790 --> 00:00:12,870
nuevo de esta clase.

4
00:00:12,930 --> 00:00:19,110
Pero creo que también es más simple crear una nueva clase New Class de IAVA y le damos un nombre, por

5
00:00:19,110 --> 00:00:20,760
ejemplo, primitivos.

6
00:00:22,380 --> 00:00:27,230
Antes creamos el main pero súper simple con Main y TAF.

7
00:00:27,440 --> 00:00:28,320
Hoy lo tenemos bien.

8
00:00:28,410 --> 00:00:32,000
Ya he hablado sobre los primitivos y no solo objetos, no son instancia, instancias.

9
00:00:32,100 --> 00:00:34,770
Es un tipo de dato que representa un valor.

10
00:00:34,860 --> 00:00:40,650
Recuerden que en Java hay dos tipos o dos categorías de tipo dato los primitivos solamente valor y los

11
00:00:40,650 --> 00:00:44,790
de referencia, que son los objetos y los objetos son una instancia de una clase.

12
00:00:45,120 --> 00:00:48,420
Después vamos a ver esos detalles, pero vámonos a los primitivos.

13
00:00:48,510 --> 00:00:53,700
Vamos a partir con los numéricos, pero básicamente con los enteros, porque tenemos lo numérico decimal,

14
00:00:53,730 --> 00:00:58,840
tipo flotante, los float y los doble de precisión simple y precisión doble.

15
00:00:58,950 --> 00:01:06,180
Y tenemos los enteros, que son los bits, los chord, el hint que es integer pero primitivo int y el

16
00:01:06,180 --> 00:01:11,660
lonko, que es como un super entero, un super intuyes, pero en Java se le conoce y se escribe como

17
00:01:11,680 --> 00:01:12,540
lonko tal cual.

18
00:01:12,750 --> 00:01:19,080
Así que partimos con eso y después vemos en las siguientes clase los demás primitivos ãrtico en el bit

19
00:01:20,240 --> 00:01:29,940
lo vamos a llamar número bait igual un valor por ejemplo 7 y más abajo lo vamos a imprimir Zogby Bien,

20
00:01:30,110 --> 00:01:31,710
hasta momento ningún problema.

21
00:01:31,830 --> 00:01:34,170
Acá le damos el valor en la literal 7.

22
00:01:34,260 --> 00:01:39,630
Los bit representan un solo bit, el cual se puede almacenar en 8 bits.

23
00:01:39,690 --> 00:01:43,680
Por lo tanto, un bit equivale a 8 bits de almacenamiento.

24
00:01:43,800 --> 00:01:46,140
Es el entero más pequeño que hay en Java.

25
00:01:46,260 --> 00:01:52,380
También tenemos los chord, el internet y el loncco con mayor capacidad, pero vámonos al bit un poco

26
00:01:52,380 --> 00:01:53,030
más en detalle.

27
00:01:53,160 --> 00:01:57,060
Vamos a imprimir primero este número lo vamos a correr con clic derecho.

28
00:01:57,150 --> 00:01:57,630
Ran.

29
00:01:59,090 --> 00:02:00,200
Número 7 Perfecto.

30
00:02:00,320 --> 00:02:00,890
Funciona bien.

31
00:02:01,010 --> 00:02:02,900
Qué pasa si colocamos 128?

32
00:02:03,800 --> 00:02:04,650
Muestra un error.

33
00:02:05,300 --> 00:02:13,160
Dice que el tipo es un PEIT, pero el valor que se proveyó o que se asignó en la literal es del tipo

34
00:02:13,250 --> 00:02:18,770
integer, porque es mayor que 127 y el pide como máximo valor.

35
00:02:18,830 --> 00:02:21,290
Soporta 127 positivo?

36
00:02:21,380 --> 00:02:25,260
Bueno, entre menos 128 y 127 positivos.

37
00:02:25,460 --> 00:02:30,020
Ese es el rango que podemos utilizar un bit y se puede almacenar en 8 bits.

38
00:02:30,200 --> 00:02:32,750
Ahora, si colocamos 127 no hay ningún problema.

39
00:02:33,020 --> 00:02:35,570
Es el máximo valor que tiene un bit.

40
00:02:36,120 --> 00:02:37,280
Y cómo lo podríamos saber?

41
00:02:37,400 --> 00:02:40,700
A través de la clase BIT, la clase BIT que maneja contante.

42
00:02:40,780 --> 00:02:44,250
Esta constante no entrega información sobre el tipo dato bit.

43
00:02:44,480 --> 00:02:49,820
En este caso, por ejemplo, el tamaño máximo, la cantidad de bits que se puede almacenar.

44
00:02:49,910 --> 00:02:55,820
Esta información también contiene la constante bits que nos muestra la cantidad de picq que corresponde,

45
00:02:56,000 --> 00:03:03,730
en este caso bit uno solo, y también el valor máximo y el valor mínimo que soporta con su hobby o consulten

46
00:03:03,730 --> 00:03:04,280
ralea.

47
00:03:04,490 --> 00:03:07,070
Vamos a tener un streeck tipo bit

48
00:03:10,560 --> 00:03:11,230
tipo pi.

49
00:03:11,240 --> 00:03:16,280
Corresponde envite a uno, pero acá lo vamos a imprimir, lo vamos a mostrar.

50
00:03:17,210 --> 00:03:18,710
BIT comienza con mayúscula.

51
00:03:18,800 --> 00:03:20,540
En este caso la clase BIT llega.

52
00:03:20,560 --> 00:03:23,540
Tenemos la constante comenzando mayúscula bits.

53
00:03:24,290 --> 00:03:30,740
Acá nos muestra la cantidad de bits que corresponde este tipo, el tipo bit, porque también por ejemplo

54
00:03:30,740 --> 00:03:35,840
el chord y el integer y el log también tiene bits, pero son mayores.

55
00:03:36,350 --> 00:03:38,030
En el caso BIT es uno solo.

56
00:03:38,120 --> 00:03:44,330
En el caso del chord bueno, pues vamos a ver, pero es dos y así vamos a copiar esto tal cual y lo

57
00:03:44,330 --> 00:03:52,870
vamos a pegar por abajo y el tipo va y corresponde en bits ahora distinto a el tamaño, el tamaño en

58
00:03:52,880 --> 00:03:54,440
que se puede almacenar por acá.

59
00:03:54,590 --> 00:03:56,960
6 Porque lo tenemos en mayúscula.

60
00:03:57,470 --> 00:03:57,950
6.

61
00:03:58,790 --> 00:03:59,690
Corresponde a 8.

62
00:04:00,530 --> 00:04:02,300
Vamos a levantar o ejecutar?

63
00:04:03,780 --> 00:04:05,110
Perfecto tipo corresponde.

64
00:04:05,390 --> 00:04:06,810
Empate a uno.

65
00:04:07,120 --> 00:04:12,580
Afectó el espacio y el tiempo y corresponde en bits a 8.

66
00:04:12,760 --> 00:04:15,900
Agreguemos el máximo y el mínimo, por ejemplo,

67
00:04:21,160 --> 00:04:22,330
valor máximo de un bit.

68
00:04:22,850 --> 00:04:29,880
Lo concatenados con Max valio 127 a cada una referencia.

69
00:04:30,390 --> 00:04:31,200
Vamos a copiar.

70
00:04:34,200 --> 00:04:42,980
Y el valor mínimo min value menos 128 levantamos.

71
00:04:44,380 --> 00:04:52,810
Perfecto, entonces corresponde a un bit corresponde en bits a 8 bits y el valor máximo 77 y el mínimo

72
00:04:52,900 --> 00:04:53,830
128.

73
00:04:55,270 --> 00:05:05,880
Bueno, veamos el siguiente número que sería un chord número chord, igual un valor Ezzor tiene mucha

74
00:05:05,880 --> 00:05:06,490
más capacidad.

75
00:05:06,600 --> 00:05:08,880
Son dos bit y 16 bits.

76
00:05:08,970 --> 00:05:10,510
Por ejemplo, unos 30 mil.

77
00:05:11,760 --> 00:05:12,780
Lo soporte perfecto.

78
00:05:13,050 --> 00:05:16,920
Pero bueno, ahí lo vamos a ver si colocamos, por ejemplo, 38.

79
00:05:17,370 --> 00:05:18,230
Vamos a tener problemas.

80
00:05:18,330 --> 00:05:19,560
Ya se pasa el límite.

81
00:05:19,740 --> 00:05:20,860
Vamos a ver los detalles.

82
00:05:21,060 --> 00:05:26,100
Entonces vamos a imprimir esta variable con Zogby y vamos a copiar esto.

83
00:05:27,220 --> 00:05:31,500
Y lo vamos a modificar para números chord, lo copiamos, lo pegamos acá.

84
00:05:32,240 --> 00:05:33,230
Entonces el tipo es Chord.

85
00:05:35,640 --> 00:05:37,980
Corresponden a la cacería.

86
00:05:38,240 --> 00:05:38,660
Jarto.

87
00:05:55,800 --> 00:05:57,640
Ven y levantamos.

88
00:06:00,210 --> 00:06:09,500
Número 30000 El tipo hecho corresponde en bayt a 2 y en Pitts a 16 el valor máximo 32 1007 67.

89
00:06:09,780 --> 00:06:15,840
Es decir, mucho más que el bit y el mínimo menos 32 7 68 negativo.

90
00:06:16,010 --> 00:06:17,880
Entonces ahí podemos trabajar con su rango.

91
00:06:18,000 --> 00:06:22,280
Manejar nuestros números según la cantidad y el valor del entero.

92
00:06:22,410 --> 00:06:24,720
Vamos a copiar el 30 de 2007.

93
00:06:24,720 --> 00:06:25,500
67.

94
00:06:25,710 --> 00:06:29,060
Vamos a copiar y lo pegamos acá bien porque es el máximo.

95
00:06:29,160 --> 00:06:34,380
Pero por ejemplo, si nos pasamos en un solo valor vamos a tener un error y está perfecto.

96
00:06:34,560 --> 00:06:35,220
Y el error?

97
00:06:35,340 --> 00:06:36,480
Bueno, es lo mismo.

98
00:06:37,140 --> 00:06:42,060
El tipo requerido es un chord, pero se provee un entero en la literal.

99
00:06:42,150 --> 00:06:44,430
Por lo tanto, se está como truncando.

100
00:06:44,610 --> 00:06:45,630
Hay pérdida de información.

101
00:06:45,720 --> 00:06:50,670
Estamos tratando de guardar un valor entero que es mucho más grande en un valor más pequeño, con menos

102
00:06:50,670 --> 00:06:52,650
capacidad de almacenamiento, que es un chord.

103
00:06:52,710 --> 00:06:59,940
Por lo tanto, al convertir un tipo numérico mayor a un tipo numérico menor, como es en el caso del

104
00:07:00,030 --> 00:07:04,950
entero o el integer, con un chord va a haber pérdida de datos, se va a truncar.

105
00:07:05,010 --> 00:07:09,120
Por eso es importante manejar bien este tipo de datos para no tener pérdida en los números.

106
00:07:09,240 --> 00:07:15,210
Muy importante lo vamos a dejar acá en 7, que es el máximo, y vamos a ir al entero.

107
00:07:15,630 --> 00:07:22,320
Entonces hint esto importante porque hay una diferencia entre el primitivo y la clase que corresponde,

108
00:07:22,380 --> 00:07:25,950
porque tenemos primitivo, pero también tenemos la clase que envuelve al primitivo.

109
00:07:26,100 --> 00:07:29,940
Acá tenemos la clase Bit, que se mayúscula, y el primitivo Bayt.

110
00:07:30,510 --> 00:07:34,470
Acá tenemos la clase Chord, quienes se mayuscula y acá tenemos el primitivo Schott.

111
00:07:34,590 --> 00:07:38,510
Pero en el caso el entero, el primitivo se llama Hint no integer.

112
00:07:39,060 --> 00:07:40,650
Pero la clase se llama Integer.

113
00:07:40,710 --> 00:07:44,430
Pero al final representa un entero de 32 bits.

114
00:07:46,260 --> 00:07:54,620
Entonces número inte perfecto y le vamos a colocar el valor máximo que soporta el chord más 1 32 1007

115
00:07:54,630 --> 00:07:56,910
68 se fijan a cada error.

116
00:07:57,100 --> 00:08:02,570
Colocamos 8 tal error, pero acá no, porque el entero tiene mayor capacidad de almacenamiento, que

117
00:08:02,580 --> 00:08:05,610
es justamente 32 bits, mucho más.

118
00:08:05,640 --> 00:08:09,030
Por lo tanto, lo soporte perfecto y puede todavía mucho más.

119
00:08:09,150 --> 00:08:12,780
Más de 2000 millones vamos a imprimir.

120
00:08:13,620 --> 00:08:17,370
Iba más a copiar esto de acá copiamos.

121
00:08:18,870 --> 00:08:20,520
Pegamos y modificamos.

122
00:08:20,990 --> 00:08:22,660
Bueno, esto es Canova del Chord.

123
00:08:25,340 --> 00:08:34,650
Entonces el tipo INT o integer le vamos a llamar int de enterro primitivo corresponden Págs a ella.

124
00:08:38,370 --> 00:08:39,060
Integer.

125
00:08:51,330 --> 00:08:55,070
Bien guardados se guarda de forma automática, así que vamos a levantar.

126
00:08:57,490 --> 00:09:06,130
Entonces número entero 32 1168, el tipo INT corresponde en PEIT a 4, pero en Pitts a 32 se fijan el

127
00:09:06,130 --> 00:09:12,520
doble capacidad que el chord, por ejemplo máximo bueno, un número bastante grande y muy similar,

128
00:09:12,550 --> 00:09:13,570
pero negativo.

129
00:09:14,440 --> 00:09:21,940
Por ejemplo, vamos a copiar el máximo y lo pegamos acá, pero también si nos pasamos en 1, colocamos

130
00:09:22,000 --> 00:09:22,570
un 8.

131
00:09:22,720 --> 00:09:23,110
Error?

132
00:09:23,200 --> 00:09:30,010
Claro, se trunca porque estamos pasando ya un número mucho más grande que un entero de 32 bits en un

133
00:09:30,010 --> 00:09:30,560
tipo, intuyes.

134
00:09:30,640 --> 00:09:36,190
Por lo tanto, se está truncando ya y tenemos que usar un tipo lonko, un tipo mayor que va a soportar

135
00:09:36,250 --> 00:09:38,500
hasta 64 bits.

136
00:09:38,830 --> 00:09:47,370
Básicamente está hablando de un super entero, un super ya bajamos loncco número loncco.

137
00:09:47,710 --> 00:09:52,600
Recuerden que el log es como un super integer o un integer en 64 bits.

138
00:09:52,750 --> 00:09:55,890
Integer 64 como también se conocen en otro lenguaje.

139
00:09:56,120 --> 00:10:01,960
Bueno, acabo de colocar 7 para que nos dé el error y vamos a copiar el número máximo acá.

140
00:10:02,790 --> 00:10:07,890
Este es el máximo, lo dejamos acá el máximo entero del intuya.

141
00:10:08,020 --> 00:10:10,330
Pero qué pasa si colocamos 8 acá?

142
00:10:11,140 --> 00:10:11,860
También marca error.

143
00:10:11,990 --> 00:10:14,340
Bueno, por qué si es del tipo loncco?

144
00:10:14,540 --> 00:10:20,380
Bueno, acá tengo que diferenciar entre el valor que asignamos, que corresponde a la literal, que

145
00:10:20,380 --> 00:10:23,120
por defecto siempre la literal es del tipo integer.

146
00:10:23,230 --> 00:10:26,470
Se eligen y dice que el integer number es demasiado largo.

147
00:10:27,310 --> 00:10:33,370
Por lo tanto, no se puede asignar acá porque la literal y literal es un entero.

148
00:10:33,490 --> 00:10:39,940
Y acá tenemos el tipo de dato que si bien soporta o soportaría entero, acá tenemos que indicar que

149
00:10:40,070 --> 00:10:43,260
la literal ya no es enteros, sino tiene que ser del tipo lonko.

150
00:10:43,380 --> 00:10:47,560
Y para hacer esa diferencia tenemos que especificar después del último número.

151
00:10:47,650 --> 00:10:50,290
Una letra L puede ser mayúscula o minúscula.

152
00:10:50,440 --> 00:10:54,790
Por ejemplo, en mayúscula siempre se recomienda utilizar la L mayúscula.

153
00:10:55,060 --> 00:11:00,730
Si colocamos la ele minúscula a simple vista, se podría confundir con un número 1, entonces siempre

154
00:11:00,730 --> 00:11:07,590
con mayúsculas y así evitar el conflicto o malentendido visual con mayúscula.

155
00:11:07,590 --> 00:11:09,760
Y queda mejor entonces colocar la L.

156
00:11:09,880 --> 00:11:16,240
Lo que hacemos convertir la literal por defecto entero, la convertimos a un tipo lonko y como ya es

157
00:11:16,240 --> 00:11:22,570
del tipo, se puede asignar a esta variable que del tipo lonko, incluso a colocar más caracteres,

158
00:11:22,690 --> 00:11:24,100
pero también va a tener un límite.

159
00:11:24,550 --> 00:11:25,270
Vamos a imprimir

160
00:11:27,770 --> 00:11:30,040
perfecto y vamos a copiar esto de acá.

161
00:11:31,950 --> 00:11:33,850
Lo pegábamos entonces el tipo lonko.

162
00:11:37,310 --> 00:11:43,260
Que corresponde también a la clase lonko, iniciando mayúscula los bits acá también.

163
00:11:56,160 --> 00:11:56,910
Ejecutamos.

164
00:11:58,480 --> 00:12:07,220
Ahora tenemos el look corresponde en Pitts a 8 bits 64 y acá tenemos el máximo máximo positivo y el

165
00:12:07,220 --> 00:12:08,150
mínimo negativo.

166
00:12:08,240 --> 00:12:11,810
Vamos a copiar el máximo positivo y lo pegamos acá.

167
00:12:11,990 --> 00:12:18,170
Pero recuerden lo de reemplazar, pero recuerde que siempre debe llevar la letra L, ya que la literal

168
00:12:18,230 --> 00:12:22,640
por defecto es entero y necesitamos convertir la literal a un look perfecto.

169
00:12:22,730 --> 00:12:24,530
Qué pasa si lo pasamos en un número?

170
00:12:25,430 --> 00:12:31,660
Bueno, hasta ahí llega ya cuando su número mucho más grande necesitamos otro tipo datos de tipo flotante

171
00:12:31,750 --> 00:12:37,630
que manejen decimales, por ejemplo, como el float y el doble, entonces en ese caso tendremos que

172
00:12:37,630 --> 00:12:42,850
convertir el tipo o utilizar el tipo doble o float para que soporte.

173
00:12:42,910 --> 00:12:45,010
Pero eso lo vemos después en la siguiente clase.

174
00:12:45,400 --> 00:12:49,870
De todas formas, para adelantar un poco float acá.

175
00:12:50,070 --> 00:12:56,540
Bueno, obviamente en vez de L porque ya no es un lonko, tenemos que usar F de float, ya que si recuerdan

176
00:12:56,770 --> 00:13:01,810
float son para tipos decimales de precisión simple, el doble es de mayor precisión.

177
00:13:01,890 --> 00:13:04,690
Pero bueno, un tema que vemos después en la próxima clase.

178
00:13:04,810 --> 00:13:10,000
Por ahora lo dejamos el log como estaba y con el valor máximo que sería 7.

179
00:13:10,480 --> 00:13:12,120
Guardamos y está molesto.

180
00:13:13,250 --> 00:13:14,900
Ahora qué pasa con Bahr?

181
00:13:16,100 --> 00:13:21,560
Recuerden que para definir una variable flexible dinámica, el tipo de datos asigna de forma automática

182
00:13:21,680 --> 00:13:24,240
de acuerdo al valor que asignemos en la literal.

183
00:13:25,820 --> 00:13:29,660
Por ejemplo, el número variable igual 127.

184
00:13:30,080 --> 00:13:30,890
Por poner un ejemplo.

185
00:13:31,250 --> 00:13:34,970
Recuerde que esta característica no se soporta en Java 8.

186
00:13:35,200 --> 00:13:38,390
Edebé J de cada 10 lleva 10 en adelante.

187
00:13:39,050 --> 00:13:39,840
Característica nueva.

188
00:13:39,950 --> 00:13:48,610
Si bien acá pasamos una literal 127, que es el máximo valor de un bit, pero por defecto se pasa en

189
00:13:48,630 --> 00:13:54,800
par cuando el numérico se asigna al tipo entero integrado y no un tipo bit.

190
00:13:55,000 --> 00:14:01,400
Y lo mismo si colocamos un tipo máximo que soporta el chord, va a seguir siendo entero.

191
00:14:01,670 --> 00:14:06,200
Esta variable va a ser del tipo integer con ese número y no un chord.

192
00:14:06,470 --> 00:14:13,070
Ahora si colocamos, por ejemplo, un integer, el valor máximo del integer también sigue siendo un

193
00:14:13,070 --> 00:14:13,460
entero.

194
00:14:13,790 --> 00:14:19,370
Por lo tanto, siempre bahr, cuando se defina un valor en la litera que sea numérica, va a ser un

195
00:14:19,370 --> 00:14:20,300
entero por defecto.

196
00:14:20,390 --> 00:14:23,990
El tipo siempre va a ser un integer, excepto que nos pasemos acá.

197
00:14:24,380 --> 00:14:29,480
Por ejemplo, si no pasamos a 8, ya no lo soporta el integer.

198
00:14:29,570 --> 00:14:31,250
El tipo entero se fija.

199
00:14:31,400 --> 00:14:36,510
Entonces tengo que indicar que es un tipo más largo con la L mayúscula a un tipo loncco y era ahora

200
00:14:36,510 --> 00:14:39,470
si ahora cambia de entero o de integer.

201
00:14:39,590 --> 00:14:45,710
El bar cambia al tipo loncco de forma automática y lo mismo sucede con el float con tipo flotante o

202
00:14:45,710 --> 00:14:46,570
doble precisión.

203
00:14:46,640 --> 00:14:53,690
Por ejemplo, si un decimal mucho más grande voy a colocar esto, pero nos pasamos en 1, por ejemplo,

204
00:14:53,900 --> 00:14:56,780
L ya no es un lonko, no lo soporta.

205
00:14:57,020 --> 00:15:03,440
Entonces tenemos que usar doble o float, por ejemplo F o C de doble doble precisión.

206
00:15:03,800 --> 00:15:09,080
Recuerden, puede ser en minúscula o mayúscula, también con F dependiendo el tipo, entonces hay cambio

207
00:15:09,700 --> 00:15:11,990
que se asigna el tipo.

208
00:15:12,050 --> 00:15:17,660
En este caso float, entonces bar y el tipo dato que se le asigna cuando el numérico va a depender siempre

209
00:15:17,750 --> 00:15:23,840
de la literal y por defecto, recuerden, siempre es integer es entera hasta que no pasemos del límite

210
00:15:23,930 --> 00:15:25,400
del límite del entero.

211
00:15:25,490 --> 00:15:27,950
En este caso este acá este valor.

212
00:15:27,980 --> 00:15:34,010
Cuando nos pasamos ya tengo que empezar a convertir al Honk y si no pasamos del log acá lo tenemos que

213
00:15:34,010 --> 00:15:38,750
convertir o utilizar una literal mayor capacidad como el float o el doble.

214
00:15:38,790 --> 00:15:38,950
Bien.

215
00:15:39,200 --> 00:15:42,470
Ahora si que si nada más nos vemos en la siguiente clase.