1
00:00:00,500 --> 00:00:07,040
Vale, hay veces que nuestros datos no se adaptan a un número entero, obviamente, ¿no?

2
00:00:07,339 --> 00:00:10,599
El precio de algo, 3,7.

3
00:00:11,000 --> 00:00:13,320
Pues con un número entero no puedo guardar el precio de algo.

4
00:00:13,460 --> 00:00:14,539
Y así como tantas cosas.

5
00:00:15,060 --> 00:00:16,980
Las medidas de una casa.

6
00:00:17,079 --> 00:00:21,179
Una casa no mide 3 por 4, sino mide 3,7 por 4,8.

7
00:00:21,320 --> 00:00:25,379
Entonces necesitamos variables decimales en todos los lenguajes de programación, también en el nuestro.

8
00:00:26,379 --> 00:00:27,780
Vale, todos sabéis lo que es un número decimal.

9
00:00:27,780 --> 00:00:30,000
Obviamente tiene parte entera, parte decimal.

10
00:00:30,500 --> 00:00:48,560
Y para guardar ese tipo de números nosotros tenemos dos tipos primitivos que los incluimos en la lista ya, el primer día que son float y double, ¿vale? Única diferencia entre ellos, la precisión, la cantidad de precisión que dan para las cifras decimales, ¿vale?

11
00:00:48,560 --> 00:00:51,079
dabel da doble precisión

12
00:00:51,079 --> 00:00:52,399
float simple precisión

13
00:00:52,399 --> 00:00:54,619
que se llama, esos detalles numéricos matemáticos

14
00:00:54,619 --> 00:00:55,700
tampoco nos importan mucho

15
00:00:55,700 --> 00:00:58,460
solo nos importan que si declaramos

16
00:00:58,460 --> 00:01:00,420
un número decimal dabel

17
00:01:00,420 --> 00:01:02,780
pues ya está, lo declaramos con el

18
00:01:02,780 --> 00:01:07,120
con su nombre de tipo primitivo

19
00:01:07,120 --> 00:01:08,560
y ya está

20
00:01:08,560 --> 00:01:10,319
y ahora yo cuando le asigno un valor

21
00:01:10,319 --> 00:01:15,340
le asigno un valor

22
00:01:15,340 --> 00:01:17,780
que si quiero puede tener decimales

23
00:01:17,780 --> 00:01:19,260
si quiero

24
00:01:19,260 --> 00:01:20,680
yo puedo hacer esto

25
00:01:20,680 --> 00:01:23,879
Y como veis lo ha cogido perfectamente

26
00:01:23,879 --> 00:01:24,680
Y no hay ningún problema

27
00:01:24,680 --> 00:01:30,439
Y si ahora lo muestro

28
00:01:30,439 --> 00:01:32,099
En un decimal, vamos a poner aquí

29
00:01:32,099 --> 00:01:34,359
Un

30
00:01:34,359 --> 00:01:36,040
System.app para que la consola

31
00:01:36,040 --> 00:01:37,680
Sabe donde llegamos a

32
00:01:37,680 --> 00:01:40,180
Pruebas

33
00:01:40,180 --> 00:01:42,579
Con decimales

34
00:01:42,579 --> 00:01:43,480
Vale

35
00:01:43,480 --> 00:01:46,439
A ver, para ejecutar este código

36
00:01:46,439 --> 00:01:47,859
Voy a quitar este errorcito

37
00:01:47,859 --> 00:01:49,500
Cuando pusimos el ejemplo de byte

38
00:01:49,500 --> 00:01:53,680
Vale, pues si ejecutamos

39
00:01:53,680 --> 00:01:57,700
este código, esto de aquí

40
00:01:57,700 --> 00:02:07,819
vale, él me lo ha mostrado

41
00:02:07,819 --> 00:02:09,699
¿y qué ha ocurrido?

42
00:02:10,740 --> 00:02:11,180
silencio

43
00:02:11,180 --> 00:02:13,520
yo le he puesto 8, pero como

44
00:02:13,520 --> 00:02:14,840
él lo tiene que guardar en un decimal

45
00:02:14,840 --> 00:02:17,460
aquí es como si hiciera una promoción automática

46
00:02:17,460 --> 00:02:19,099
rápidamente, le pone el punto 0

47
00:02:19,099 --> 00:02:21,379
le pone el punto 0 porque lo guarda en decimal

48
00:02:21,379 --> 00:02:23,599
y este número es decimal a todos los

49
00:02:23,599 --> 00:02:24,819
efectos, ¿vale?

50
00:02:26,840 --> 00:02:27,240
entonces

51
00:02:27,240 --> 00:02:30,020
si yo quiero ponerle ya los decimales

52
00:02:30,020 --> 00:02:31,560
pues se los pongo

53
00:02:31,560 --> 00:02:34,300
pero separados con el punto

54
00:02:34,300 --> 00:02:35,879
no con la coma, ¿vale?

55
00:02:36,199 --> 00:02:38,439
por ejemplo 7.9

56
00:02:38,439 --> 00:02:40,340
pues ya está, la variable

57
00:02:40,340 --> 00:02:43,060
double me coge el 7.9

58
00:02:43,060 --> 00:02:44,699
entonces el separador

59
00:02:44,699 --> 00:02:45,879
de la parte anterior a la decimal

60
00:02:45,879 --> 00:02:48,199
es el punto, no es la coma

61
00:02:48,199 --> 00:02:49,319
¿vale?

62
00:02:50,400 --> 00:02:52,340
vale, pues ya está y uno ya

63
00:02:52,340 --> 00:02:54,300
puede sumar números decimales

64
00:02:54,300 --> 00:02:55,479
entre sí, lo que sea

65
00:02:55,479 --> 00:02:57,979
que quiere incrementar en 1

66
00:02:57,979 --> 00:03:01,879
el contenido de este numerito decimal

67
00:03:01,879 --> 00:03:05,330
bueno pues

68
00:03:05,330 --> 00:03:07,830
por ejemplo con esto lo he incrementado

69
00:03:07,830 --> 00:03:09,669
en 1, aquí estoy

70
00:03:09,669 --> 00:03:11,090
haciendo una suma

71
00:03:11,090 --> 00:03:12,370
estoy sumando

72
00:03:12,370 --> 00:03:16,250
el número decimal este que es 7.9

73
00:03:16,250 --> 00:03:17,509
le estoy sumando 1

74
00:03:17,509 --> 00:03:19,750
aquí la máquina virtual ve

75
00:03:19,750 --> 00:03:21,449
que está sumando un double

76
00:03:21,449 --> 00:03:23,849
un entero para guardar en un double

77
00:03:23,849 --> 00:03:24,969
pues este 1

78
00:03:24,969 --> 00:03:27,490
le hace también la promoción automática

79
00:03:27,490 --> 00:03:29,469
y le pone el punto cero

80
00:03:29,469 --> 00:03:31,449
él automáticamente por dentro, le pone el punto cero

81
00:03:31,449 --> 00:03:32,250
¿vale?

82
00:03:33,009 --> 00:03:35,430
es decir, este operador está mezclando en realidad

83
00:03:35,430 --> 00:03:36,610
un entero con un double

84
00:03:36,610 --> 00:03:39,389
pero este entero le pone el punto cero detrás

85
00:03:39,389 --> 00:03:40,810
porque no afecta

86
00:03:40,810 --> 00:03:43,930
¿vale? entonces con números decimales

87
00:03:43,930 --> 00:03:45,469
podemos hacer

88
00:03:45,469 --> 00:03:47,810
sumas, restas, multiplicaciones y divisiones

89
00:03:47,810 --> 00:03:49,610
igual que con los enteros

90
00:03:49,610 --> 00:03:52,150
aquí lo único que la división

91
00:03:52,150 --> 00:03:53,689
ahora ya no tendrá

92
00:03:53,689 --> 00:03:55,750
significado de cociente, sino

93
00:03:55,750 --> 00:03:57,909
la división con decimales, ¿vale?

94
00:03:57,949 --> 00:03:59,550
Por ejemplo, si nos hacemos aquí un

95
00:03:59,550 --> 00:04:00,990
num decimal

96
00:04:00,990 --> 00:04:08,490
2 igual a

97
00:04:08,490 --> 00:04:17,199
igual a 5.9

98
00:04:17,199 --> 00:04:18,699
por ejemplo, ¿vale?

99
00:04:18,740 --> 00:04:20,560
Y no lo he declarado, con lo cual

100
00:04:20,560 --> 00:04:21,300
muy mal.

101
00:04:22,560 --> 00:04:23,819
Vale, pues entonces

102
00:04:23,819 --> 00:04:26,420
yo ahora puedo pues hacer esto

103
00:04:26,420 --> 00:04:27,360
tranquilamente

104
00:04:27,360 --> 00:04:39,620
y si hacéis el system out para

105
00:04:39,620 --> 00:04:41,319
ver el resultado, pues habrá sumado

106
00:04:41,319 --> 00:04:43,779
8 con 9

107
00:04:43,779 --> 00:04:45,620
porque 7 con 9 al sumarle 1

108
00:04:45,620 --> 00:04:47,259
se habrá quedado en 8 con 9

109
00:04:47,259 --> 00:04:49,800
habrá sumado 8 con 9

110
00:04:49,800 --> 00:04:51,660
a 5 con 9 y el resultado que dé

111
00:04:51,660 --> 00:04:53,360
pues habrá dado

112
00:04:53,360 --> 00:04:55,620
14 con algo, supongo, 14 con 8

113
00:04:55,620 --> 00:04:57,620
lo que sea, para no hacer

114
00:04:57,620 --> 00:04:58,579
el system todo el rato

115
00:04:58,579 --> 00:05:00,980
vale, entonces

116
00:05:00,980 --> 00:05:03,860
el operador suma y resta

117
00:05:03,860 --> 00:05:05,720
y multiplicación

118
00:05:05,720 --> 00:05:07,819
con números decimales, pues sabemos cómo funciona

119
00:05:07,819 --> 00:05:09,439
porque estamos multiplicando

120
00:05:09,439 --> 00:05:11,939
sumando y restando

121
00:05:11,939 --> 00:05:13,920
números decimales en la calculadora todo el rato

122
00:05:13,920 --> 00:05:16,300
la división

123
00:05:16,300 --> 00:05:18,160
la división en este caso

124
00:05:18,160 --> 00:05:19,720
no es el cociente entero

125
00:05:19,720 --> 00:05:21,079
como era en el caso de números enteros

126
00:05:21,079 --> 00:05:24,220
recordad que aquí, cuando hacíamos esta división

127
00:05:24,220 --> 00:05:25,860
esta división era

128
00:05:25,860 --> 00:05:26,980
entre números enteros

129
00:05:26,980 --> 00:05:28,839
el 7

130
00:05:28,839 --> 00:05:31,319
entre el n, el que fuera

131
00:05:31,319 --> 00:05:33,160
o aquí, se ve más claro

132
00:05:33,160 --> 00:05:35,879
aquí el operador división, este de aquí

133
00:05:35,879 --> 00:05:37,839
dividía el número entero 7

134
00:05:37,839 --> 00:05:38,879
entre el número entero 3

135
00:05:38,879 --> 00:05:41,300
entonces aquí el operador significa

136
00:05:41,300 --> 00:05:42,180
cociente

137
00:05:42,180 --> 00:05:45,920
luego cuando lo mostrábamos ponía 2

138
00:05:45,920 --> 00:05:48,220
porque el cociente de 73 es 2

139
00:05:48,220 --> 00:05:50,019
el resto se ignora

140
00:05:50,019 --> 00:05:50,680
y todo eso

141
00:05:50,680 --> 00:05:52,319
¿qué queremos el resto?

142
00:05:52,980 --> 00:05:53,939
pues tenemos este operador

143
00:05:53,939 --> 00:05:58,040
¿qué ocurre cuando

144
00:05:58,040 --> 00:05:59,560
utilizamos el operador

145
00:05:59,560 --> 00:06:01,699
de división entre números decimales?

146
00:06:01,920 --> 00:06:03,160
que ahí no es cociente

147
00:06:03,160 --> 00:06:04,199
ahí es la división decimal

148
00:06:04,199 --> 00:06:05,339
y ya está

149
00:06:05,339 --> 00:06:08,500
por ejemplo si ahora vamos a guardar

150
00:06:08,500 --> 00:06:11,240
en numDecimal vamos a guardar la división

151
00:06:11,240 --> 00:06:13,240
de sí mismo, de lo que él tiene

152
00:06:13,240 --> 00:06:16,399
dividido entre numDecimal2

153
00:06:16,399 --> 00:06:18,660
¿vale?

154
00:06:19,379 --> 00:06:21,139
entonces cogerá lo que tenga numDecimal

155
00:06:21,139 --> 00:06:22,660
que va a ser 8,9

156
00:06:22,660 --> 00:06:24,879
porque es este más lo que le hemos sumado, 8,9

157
00:06:24,879 --> 00:06:28,100
lo dividirá entre lo que contenga esto

158
00:06:28,100 --> 00:06:28,920
que es 5,9

159
00:06:28,920 --> 00:06:31,199
hará la división con decimales, lo que le dé

160
00:06:31,199 --> 00:06:32,879
y lo guardará en double

161
00:06:32,879 --> 00:06:34,560
luego

162
00:06:34,560 --> 00:06:37,740
este es un operador que hace una cosa

163
00:06:37,740 --> 00:06:39,720
o hace otra en función

164
00:06:39,720 --> 00:06:41,899
de los operandos que tenga

165
00:06:41,899 --> 00:06:43,839
a los lados. Y eso le pasa

166
00:06:43,839 --> 00:06:44,699
a otros operadores.

167
00:06:45,899 --> 00:06:47,939
¿A la suma, la resta y la multiplicación?

168
00:06:48,000 --> 00:06:49,819
No. Perdón, la suma sí, porque

169
00:06:49,819 --> 00:06:51,759
ya dijimos ayer, aunque volveremos a ello,

170
00:06:52,360 --> 00:06:53,800
que la suma, si tienes

171
00:06:53,800 --> 00:06:55,879
dos cadenas, recordáis que acabamos

172
00:06:55,879 --> 00:06:58,000
ayer así, si la suma

173
00:06:58,000 --> 00:06:59,740
tienes a los lados dos

174
00:06:59,740 --> 00:07:01,860
cadenas entre comillas, la suma

175
00:07:01,860 --> 00:07:03,560
interpreta que lo que tiene que hacer es concatenar.

176
00:07:04,459 --> 00:07:05,879
Pero si lo que tiene son números,

177
00:07:05,879 --> 00:07:08,240
entonces interpretar lo que tienes que hacer es sumar

178
00:07:08,240 --> 00:07:11,160
entonces la suma también es un operador

179
00:07:11,160 --> 00:07:12,620
bipolar

180
00:07:12,620 --> 00:07:14,860
que puede hacer

181
00:07:14,860 --> 00:07:15,660
lo que

182
00:07:15,660 --> 00:07:18,360
una cosa puede hacer otra

183
00:07:18,360 --> 00:07:20,379
es polimórfico como lo queréis llamar

184
00:07:20,379 --> 00:07:21,959
en función de los operandos

185
00:07:21,959 --> 00:07:24,060
la resta no

186
00:07:24,060 --> 00:07:26,560
la resta siempre trabaja

187
00:07:26,560 --> 00:07:27,759
con números

188
00:07:27,759 --> 00:07:30,019
y lo que hace es restar

189
00:07:30,019 --> 00:07:32,160
me da igual que sean decimales que sean enteros

190
00:07:32,160 --> 00:07:34,459
pues la división es como la suma

191
00:07:34,459 --> 00:07:36,620
otro operador polimórfico,

192
00:07:37,259 --> 00:07:38,399
si lo que tiene alrededor

193
00:07:38,399 --> 00:07:40,160
son enteros,

194
00:07:40,399 --> 00:07:41,180
te hace el cociente.

195
00:07:42,180 --> 00:07:44,240
Si lo que tiene alrededor son decimales,

196
00:07:44,779 --> 00:07:46,199
te hace la división con decimales.

197
00:07:46,300 --> 00:07:48,180
Ni cociente ni nada. De hecho,

198
00:07:48,279 --> 00:07:52,800
si mostramos aquí num decimal,

199
00:07:54,339 --> 00:07:56,639
pues la última línea que nos va a mostrar este código

200
00:07:56,639 --> 00:07:58,620
efectivamente

201
00:07:58,620 --> 00:08:00,379
es eso, esa división.

202
00:08:01,220 --> 00:08:01,699
¿Vale?

203
00:08:02,600 --> 00:08:04,319
Es la división decimal de eso.

204
00:08:04,759 --> 00:08:09,300
Que a uno le parece feo

205
00:08:09,300 --> 00:08:11,100
que lo muestre con tantos decimales

206
00:08:11,100 --> 00:08:13,420
él te muestra el número como es

207
00:08:13,420 --> 00:08:14,839
te muestra el número como tal

208
00:08:14,839 --> 00:08:17,360
que es este número, ahora hay otra cosa

209
00:08:17,360 --> 00:08:19,240
es que cuando tú lo miras

210
00:08:19,240 --> 00:08:21,399
físicamente, pero solo para verlo desde fuera

211
00:08:21,399 --> 00:08:23,600
quieras redondearlo, truncarlo

212
00:08:23,600 --> 00:08:25,639
porque el cliente de tu aplicación

213
00:08:25,639 --> 00:08:27,220
quiere el precio, no quiere el precio

214
00:08:27,220 --> 00:08:29,319
con 2000 decimales, a lo mejor ahí te han

215
00:08:29,319 --> 00:08:30,800
pedido, se me va a ir

216
00:08:30,800 --> 00:08:32,700
la batería ya

217
00:08:32,700 --> 00:08:50,159
vale, entonces a lo mejor

218
00:08:50,159 --> 00:08:51,360
ahí te han pedido una aplicación

219
00:08:51,360 --> 00:08:55,080
oye, yo necesito en mi caja de mi tienda

220
00:08:55,080 --> 00:08:58,200
meter un precio y un descuento en el producto que han cogido

221
00:08:58,200 --> 00:09:00,240
y que me muestre rápidamente lo que le tengo que cobrar al tío

222
00:09:00,240 --> 00:09:02,179
bueno, no te preocupes, yo te hago un programa

223
00:09:02,179 --> 00:09:04,379
tú metes el precio y el descuento

224
00:09:04,379 --> 00:09:07,299
y rápidamente vas a ver lo que le tienes que cobrar

225
00:09:07,299 --> 00:09:08,179
al tío que tienes delante

226
00:09:08,179 --> 00:09:09,879
vale, si le hacemos un programa

227
00:09:09,879 --> 00:09:11,460
con lo que nosotros sabemos hasta ahora

228
00:09:11,460 --> 00:09:12,820
hacemos la división y la mostramos

229
00:09:12,820 --> 00:09:15,960
el tío que te ha pedido el programa y lo está ejecutando

230
00:09:15,960 --> 00:09:19,059
pues efectivamente va a ver esto

231
00:09:19,059 --> 00:09:22,259
y a lo mejor te dice

232
00:09:22,259 --> 00:09:25,740
Hijo, hombre, la verdad, yo lo que quiero es que tú me muestres el precio

233
00:09:25,740 --> 00:09:29,659
con dos cifras decimales, truncado, 2,5, o lo que sea,

234
00:09:29,720 --> 00:09:31,559
no me lo muestres así para que yo tenga que hacer el esfuerzo

235
00:09:31,559 --> 00:09:32,539
de quitar la parte decimal.

236
00:09:33,220 --> 00:09:37,840
Vale, eso es simplemente una cuestión de dar formato a la salida, nada más.

237
00:09:37,919 --> 00:09:40,039
Porque el número es el que es, y ahí no hay tu tía.

238
00:09:40,679 --> 00:09:42,980
Y el número que está guardado aquí,

239
00:09:45,159 --> 00:09:49,419
el número este en un decimal es ese,

240
00:09:49,419 --> 00:09:52,360
y tiene esas cifras decimales

241
00:09:52,360 --> 00:09:54,019
y ese es el número que está en memoria RAM

242
00:09:54,019 --> 00:09:56,240
otro aspecto ya es

243
00:09:56,240 --> 00:09:58,700
si yo lo quiero mostrar en la consola

244
00:09:58,700 --> 00:10:00,600
cambiando el formato y truncando

245
00:10:00,600 --> 00:10:02,259
¿vale? entonces

246
00:10:02,259 --> 00:10:04,340
para eso, a esta

247
00:10:04,340 --> 00:10:06,500
sentencia de aquí, se le pueden

248
00:10:06,500 --> 00:10:08,480
pasar cositas que no vamos a ver ahora

249
00:10:08,480 --> 00:10:10,379
porque no vamos a meter estos rollos

250
00:10:10,379 --> 00:10:11,659
que se pueden buscar en cualquier lado

251
00:10:11,659 --> 00:10:14,379
se le pueden pasar cositas para que

252
00:10:14,379 --> 00:10:16,460
te lo muestre, a la hora de mostrarte en consola

253
00:10:16,460 --> 00:10:17,440
te lo muestre truncado

254
00:10:17,440 --> 00:10:19,000
pero eso ya son detalles

255
00:10:19,000 --> 00:10:20,980
que si uno quiere investigar

256
00:10:20,980 --> 00:10:23,700
oye, mostrar en consola con formato

257
00:10:23,700 --> 00:10:24,919
pues se va

258
00:10:24,919 --> 00:10:27,600
¿cómo se muestra en consola con formato?

259
00:10:28,080 --> 00:10:29,740
pues se dice, ah, pues pones por ciento F

260
00:10:29,740 --> 00:10:31,720
o pones no sé qué, el F patatín patatán

261
00:10:31,720 --> 00:10:33,740
y ya está, esa es la típica cosa

262
00:10:33,740 --> 00:10:35,779
que uno le puede preguntar a CharGPT

263
00:10:35,779 --> 00:10:37,620
¿vale? pero porque

264
00:10:37,620 --> 00:10:39,759
sabe exactamente qué es lo que quiere

265
00:10:39,759 --> 00:10:42,019
y qué es lo que hay de fondo

266
00:10:42,019 --> 00:10:42,740
y qué hay de fondo

267
00:10:42,740 --> 00:10:45,340
yo tengo una variable, y esta variable

268
00:10:45,340 --> 00:10:47,440
tiene ese valor, y lo tiene

269
00:10:47,440 --> 00:10:49,000
y es inamovible, tiene ese valor

270
00:10:49,000 --> 00:10:51,279
mi problema no es otro, mi problema no es

271
00:10:51,279 --> 00:10:53,039
mostrarlo en una pantalla para un tío

272
00:10:53,039 --> 00:10:55,539
que lo ve, pues le sea fácil

273
00:10:55,539 --> 00:10:57,519
visualizar lo que

274
00:10:57,519 --> 00:10:58,879
contiene ese numerito y redondearlo

275
00:10:58,879 --> 00:11:01,539
mi problema no es mostrarlo en pantalla, pues entonces ya busco

276
00:11:01,539 --> 00:11:03,320
en chat GPT, mostrar

277
00:11:03,320 --> 00:11:05,080
por consola en Java

278
00:11:05,080 --> 00:11:07,220
un double con la parte decimal

279
00:11:07,220 --> 00:11:09,320
truncada, pues hemos apotado

280
00:11:09,320 --> 00:11:11,519
el problema, queremos eso, pues chat GPT

281
00:11:11,519 --> 00:11:13,179
como eso ya es muy sencillo, es

282
00:11:13,179 --> 00:11:15,159
mirarse a la web y decir, ah pues pones aquí un no sé qué

283
00:11:15,159 --> 00:11:17,179
lo trunca. Pues es probable

284
00:11:17,179 --> 00:11:19,120
que acierte. ¿Vale? Entonces

285
00:11:19,120 --> 00:11:21,200
ese problema, pues sí, lo puede resolver el chargePT.

286
00:11:21,379 --> 00:11:22,720
Pero claro, uno sabe

287
00:11:22,720 --> 00:11:24,399
qué es lo que está haciendo.

288
00:11:25,279 --> 00:11:27,059
Claro, entonces, ¿qué sería un ejemplo de no saber?

289
00:11:27,860 --> 00:11:29,519
Pues que vosotros pensarais

290
00:11:29,519 --> 00:11:30,879
que por poner eso así,

291
00:11:31,620 --> 00:11:33,419
el número decimal es el que se queda truncado.

292
00:11:33,919 --> 00:11:35,279
No, esta variable no se queda truncada,

293
00:11:35,360 --> 00:11:37,120
esta variable es la que es, y está en memoria RAM

294
00:11:37,120 --> 00:11:39,120
con ese valor. Estamos hablando

295
00:11:39,120 --> 00:11:40,879
de que la consola me lo muestre

296
00:11:40,879 --> 00:11:42,620
más bonito. Nada más.

297
00:11:43,299 --> 00:11:44,899
¿Vale? Bueno, pues si uno

298
00:11:44,899 --> 00:11:46,320
quiere mostrar las cosas más bonitas

299
00:11:46,320 --> 00:11:49,039
se va a buscar, yo recomiendo

300
00:11:49,039 --> 00:11:50,840
que no porque no quiero que nos liemos ahora

301
00:11:50,840 --> 00:11:52,659
con esto, vale

302
00:11:52,659 --> 00:11:55,120
pues se va a buscar que cositas puede poner aquí

303
00:11:55,120 --> 00:11:56,879
para que le quede la parte decimal

304
00:11:56,879 --> 00:11:58,919
en dos cifras en vez de en varias

305
00:11:58,919 --> 00:12:00,600
lo digo porque hay veces

306
00:12:00,600 --> 00:12:03,039
por si uno a lo mejor se ve un tutorial de Java o no sé que de Java

307
00:12:03,039 --> 00:12:04,980
pues muchas veces los vídeos de Java

308
00:12:04,980 --> 00:12:07,279
o los tutoriales son como muy en plan chorizo

309
00:12:07,279 --> 00:12:08,720
para hacer esto, para hacer esto, para hacer esto

310
00:12:08,720 --> 00:12:10,700
y de repente llegas para mostrar por consola esto

311
00:12:10,700 --> 00:12:12,500
y te sueltan aquí un chorizo para mostrarlo con decimales

312
00:12:12,500 --> 00:12:14,500
y ves ahí un chorizo de cosas y dices

313
00:12:14,500 --> 00:12:16,080
esto para qué lo quiero y qué me interesa

314
00:12:16,080 --> 00:12:18,600
y te pueden llevar incluso a confusión

315
00:12:18,600 --> 00:12:19,580
sobre lo que estás haciendo

316
00:12:19,580 --> 00:12:22,580
entonces nosotros no nos vamos a meter

317
00:12:22,580 --> 00:12:24,659
en mostrarlo más bonito, porque nos da igual

318
00:12:24,659 --> 00:12:26,539
vale, pues entonces

319
00:12:26,539 --> 00:12:28,440
lo que sí que nos interesaba era

320
00:12:28,440 --> 00:12:31,120
tener claro

321
00:12:31,120 --> 00:12:32,940
que el operador este de división

322
00:12:32,940 --> 00:12:34,639
opera de forma distinta

323
00:12:34,639 --> 00:12:36,279
si mezcla números enteros o decimales

324
00:12:36,279 --> 00:12:38,019
entonces ahora le podríais decir

325
00:12:38,019 --> 00:12:40,820
y si yo pongo un entero aquí

326
00:12:40,820 --> 00:12:42,039
y un decimal aquí

327
00:12:42,039 --> 00:12:43,279
¿quién gana?

328
00:12:44,500 --> 00:12:46,159
¿El cociente o el decimal?

329
00:12:46,919 --> 00:12:50,399
Y no solo quién gana, sino ¿puedo?

330
00:12:50,919 --> 00:12:54,100
¿Me permite el compilador mezclar aquí un número?

331
00:12:54,720 --> 00:12:55,460
Vamos a verlo.

332
00:12:56,059 --> 00:12:57,279
Desde luego con la suma sí.

333
00:12:57,980 --> 00:13:00,220
Por ejemplo, si yo sumo, vamos a hacer ahora.

334
00:13:02,100 --> 00:13:06,019
Vamos a poner aquí para que luego cuando lo ejecutemos.

335
00:13:07,179 --> 00:13:08,759
Pruebas mezclando.

336
00:13:08,759 --> 00:13:12,100
Ah, no, era un sí, se lo quería poner.

337
00:13:12,100 --> 00:13:19,029
Pruebas mezclando

338
00:13:19,029 --> 00:13:20,850
Decimales

339
00:13:20,850 --> 00:13:23,090
Y enteros

340
00:13:23,090 --> 00:13:25,389
Enteros

341
00:13:25,389 --> 00:13:26,970
Vale

342
00:13:26,970 --> 00:13:30,500
Vale

343
00:13:30,500 --> 00:13:32,159
La suma está clara que lo permite

344
00:13:32,159 --> 00:13:32,740
Por ejemplo

345
00:13:32,740 --> 00:13:36,080
Yo en mi numerito decimal

346
00:13:36,080 --> 00:13:36,759
Num decimal

347
00:13:36,759 --> 00:13:41,259
Voy a declararme otra variable

348
00:13:41,259 --> 00:13:42,700
Número entero

349
00:13:42,700 --> 00:13:45,179
Y le voy a asignar el 9

350
00:13:45,179 --> 00:13:48,080
Vale, tengo mi número entero 9

351
00:13:48,080 --> 00:14:06,629
Y ahora a mi variable número decimal le voy a asignar el resultado de sumar numDecimal1 más numEntero, ¿vale?

352
00:14:06,789 --> 00:14:12,149
numDecimal1 lo he debido escribir mal porque, ah, es que no existe, era 2, vale.

353
00:14:14,269 --> 00:14:21,210
Yo he hecho una suma en la cual estoy sumando un double y un int, no hay ningún problema.

354
00:14:22,590 --> 00:14:24,730
la máquina virtual dice, no pasa nada. ¿Por qué?

355
00:14:24,789 --> 00:14:25,450
¿Qué es lo que ha hecho?

356
00:14:26,190 --> 00:14:28,690
Al número entero lo promociona poniéndole

357
00:14:28,690 --> 00:14:29,450
el punto cero.

358
00:14:30,450 --> 00:14:32,190
Hace la suma y lo guarda aquí.

359
00:14:38,690 --> 00:14:39,929
No. Vamos a verlo ahora.

360
00:14:40,110 --> 00:14:42,129
Está claro que esto funciona porque le pone

361
00:14:42,129 --> 00:14:44,149
el número entero. Cuidado, eso no significa

362
00:14:44,149 --> 00:14:45,830
que la variable num entero

363
00:14:45,830 --> 00:14:47,889
haya cambiado a double. No.

364
00:14:47,889 --> 00:14:49,809
La variable num entero sigue siendo

365
00:14:49,809 --> 00:14:51,730
una variable int. Una variable int

366
00:14:51,730 --> 00:14:53,509
en la que yo solamente puedo poner int.

367
00:14:54,409 --> 00:14:55,409
No es que

368
00:14:55,409 --> 00:14:57,429
el operador más haya decidido

369
00:14:57,429 --> 00:14:59,350
promocionar número entero a dabble

370
00:14:59,350 --> 00:15:00,629
y ahora yo pueda hacer esto

371
00:15:00,629 --> 00:15:03,429
no, numentero

372
00:15:03,429 --> 00:15:05,330
sigue siendo una variable entera y en ella

373
00:15:05,330 --> 00:15:06,870
solo caben números enteros

374
00:15:06,870 --> 00:15:09,049
pero, vale

375
00:15:09,049 --> 00:15:11,250
y nume, bueno

376
00:15:11,250 --> 00:15:15,429
que no he puesto el

377
00:15:15,429 --> 00:15:18,549
nombre, ahí

378
00:15:18,549 --> 00:15:20,250
perdón, vale

379
00:15:20,250 --> 00:15:22,889
vale

380
00:15:22,889 --> 00:15:25,090
entonces, numen, un segundito

381
00:15:25,090 --> 00:15:27,110
termino esta, numentero

382
00:15:27,110 --> 00:15:28,850
no lo ha cambiado a dabble

383
00:15:28,850 --> 00:15:31,110
NUM entero sigue siendo entero

384
00:15:31,110 --> 00:15:32,090
y solamente puede recibir enteros

385
00:15:32,090 --> 00:15:35,190
Simplemente lo que ha ocurrido es que para hacer la operación

386
00:15:35,190 --> 00:15:37,090
el valor que tenía NUM entero

387
00:15:37,090 --> 00:15:38,750
el valor lo ha cogido

388
00:15:38,750 --> 00:15:41,509
a ese valor una vez que lo ha sacado de la caja

389
00:15:41,509 --> 00:15:42,690
una vez sacado de la caja

390
00:15:42,690 --> 00:15:44,149
que la caja sigue siendo para enteros

391
00:15:44,149 --> 00:15:46,529
el valor le ha puesto el punto cero

392
00:15:46,529 --> 00:15:49,409
y ahora ya ha hecho la suma con NUM decimal 2

393
00:15:49,409 --> 00:15:51,509
y ya con la suma con decimales

394
00:15:51,509 --> 00:15:52,610
lo guarda en NUM decimal

395
00:15:52,610 --> 00:15:53,730
¿Vale? Hasta ahí claro

396
00:15:53,730 --> 00:15:55,450
¿Pero qué ocurre?

397
00:15:57,789 --> 00:15:58,230
Ahora

398
00:15:58,230 --> 00:16:08,129
Ahora, si intentamos hacer esta misma suma, pero esta misma suma, ¿qué va a funcionar así?

399
00:16:08,570 --> 00:16:11,649
Este voy, cojo el valor y le pongo el punto cero.

400
00:16:12,110 --> 00:16:15,029
Lo sumo en un decimal 2, que será 7.9, lo que sea.

401
00:16:15,769 --> 00:16:19,470
Y ahora voy a guardarlo en este otro.

402
00:16:21,149 --> 00:16:21,950
Aquí no me deja.

403
00:16:22,470 --> 00:16:22,970
¿Por qué?

404
00:16:22,970 --> 00:16:27,850
Porque aquí este numerito me ha dado con decimales, porque es dabel.

405
00:16:27,850 --> 00:16:29,409
Este le ha puesto el punto cero

406
00:16:29,409 --> 00:16:32,210
Este tendrá el decimal que sea

407
00:16:32,210 --> 00:16:33,529
Punto no sé cuántos

408
00:16:33,529 --> 00:16:36,049
La suma tendrá los decimales que sean

409
00:16:36,049 --> 00:16:37,409
Y ahora el copiador dice

410
00:16:37,409 --> 00:16:39,370
¿Eh? ¿Decimal en entero?

411
00:16:39,789 --> 00:16:42,909
No, porque tendría que truncar la parte

412
00:16:42,909 --> 00:16:44,509
Y no se puede quitar información

413
00:16:44,509 --> 00:16:45,529
Sí, pero

414
00:16:45,529 --> 00:16:47,509
Lo vemos un poquito más adelante

415
00:16:47,509 --> 00:16:50,610
¿Vale? Pero él no te lo hace automáticamente

416
00:16:50,610 --> 00:16:52,309
Porque te está quitando información

417
00:16:52,309 --> 00:16:53,629
Te está quitando la parte decimal

418
00:16:53,629 --> 00:16:55,789
Y hombre, no te va a quitar información así por las buenas

419
00:16:55,789 --> 00:16:57,289
Él automáticamente no te lo puede hacer

420
00:16:57,289 --> 00:17:17,009
Tú puedes forzarlo, puedes forzar a quitar la parte decimal, pero lo aparcamos ahora mismo, ¿vale? Entonces es lo mismo que ocurre si yo en mi num entero quisiera guardar en un decimal 2 hacia palo seco, decimal, ¿me diría lo mismo?

421
00:17:17,009 --> 00:17:20,289
me diría, eh, oye

422
00:17:20,289 --> 00:17:22,390
este tiene

423
00:17:22,390 --> 00:17:23,990
aunque sea punto cero, me da igual

424
00:17:23,990 --> 00:17:26,230
aunque sea punto cero, pero ese tiene sus decimales

425
00:17:26,230 --> 00:17:27,650
aunque sea el punto cero, te dice, no

426
00:17:27,650 --> 00:17:30,029
yo no voy a truncar la parte decimal

427
00:17:30,029 --> 00:17:31,630
para que la metas aquí, aunque

428
00:17:31,630 --> 00:17:34,009
en este caso en particular pudiera ser

429
00:17:34,009 --> 00:17:36,250
punto cero, me da igual, no la voy a truncar

430
00:17:36,250 --> 00:17:37,130
no puedes hacerlo

431
00:17:37,130 --> 00:17:39,890
pero al revés, claro que puedes

432
00:17:39,890 --> 00:17:41,849
por ejemplo esto

433
00:17:41,849 --> 00:17:43,730
sí que lo podríamos hacer

434
00:17:43,730 --> 00:17:49,019
esto sí nos deja

435
00:17:49,019 --> 00:17:51,460
porque esta parte no quita

436
00:17:51,460 --> 00:17:53,039
información, él dice

437
00:17:53,039 --> 00:17:55,500
cojo el valor que hay en un

438
00:17:55,500 --> 00:17:57,180
entero de la caja, lo cojo

439
00:17:57,180 --> 00:17:58,740
que será 7, el que sea

440
00:17:58,740 --> 00:18:01,200
una vez que tengo el valor ya metido aquí

441
00:18:01,200 --> 00:18:03,519
fuera de la variable, le pongo el punto

442
00:18:03,519 --> 00:18:05,579
0 y ahora ya con ese

443
00:18:05,579 --> 00:18:06,579
punto 0 va aquí

444
00:18:06,579 --> 00:18:09,279
luego a un double se le puede asignar un

445
00:18:09,279 --> 00:18:10,720
int pero al revés no

446
00:18:10,720 --> 00:18:12,980
y tiene todo el sentido porque al revés

447
00:18:12,980 --> 00:18:14,960
perdemos información y el programa no puede

448
00:18:14,960 --> 00:18:17,119
tirar información de la basura ahí sacándose

449
00:18:17,119 --> 00:18:17,660
de la manga

450
00:18:17,660 --> 00:18:19,079
¿Vale?

451
00:18:19,779 --> 00:18:20,519
Entonces esto

452
00:18:20,519 --> 00:18:24,380
Un int cabe en un double

453
00:18:24,380 --> 00:18:26,339
Ampliando la parte decimal a punto cero

454
00:18:26,339 --> 00:18:28,799
Y un double no cabe en un int porque tienes que quitar

455
00:18:28,799 --> 00:18:29,660
¿Vale?

456
00:18:30,940 --> 00:18:32,299
Vale, pues entonces

457
00:18:32,299 --> 00:18:34,480
Esto

458
00:18:34,480 --> 00:18:36,619
Igual que, es lo mismo que cuando decíamos

459
00:18:36,619 --> 00:18:37,900
Que un int cabe en un long

460
00:18:37,900 --> 00:18:40,859
Y decíamos, a un long le puedes asignar un int

461
00:18:40,859 --> 00:18:42,480
Y él hace una cosa que llamábamos

462
00:18:42,480 --> 00:18:43,700
Promoción automática

463
00:18:43,700 --> 00:18:46,660
Pues esto es lo mismo, también se llama promoción automática

464
00:18:46,660 --> 00:18:48,380
un int cabe en un double

465
00:18:48,380 --> 00:18:50,279
y la máquina virtual lo promociona

466
00:18:50,279 --> 00:18:51,980
automáticamente a double poniendo el punto cero

467
00:18:51,980 --> 00:18:53,019
y ya está, no pasa nada

468
00:18:53,019 --> 00:18:56,819
¿y qué pasa con los float?

469
00:18:58,259 --> 00:18:59,039
los float

470
00:18:59,039 --> 00:19:00,380
funcionan igual en realidad

471
00:19:00,380 --> 00:19:02,140
lo único es que ahora

472
00:19:02,140 --> 00:19:03,839
el float es un número decimal

473
00:19:03,839 --> 00:19:08,500
que admite menos cifras decimales

474
00:19:08,500 --> 00:19:09,859
entonces

475
00:19:09,859 --> 00:19:13,859
aproximadamente

476
00:19:13,859 --> 00:19:16,319
¿ahora hacemos una prueba con la consola? yo creo que sí

477
00:19:16,319 --> 00:19:18,460
creo que sí, pero no estoy segura

478
00:19:18,480 --> 00:19:21,339
vale, yo tengo un número float este de aquí

479
00:19:21,339 --> 00:19:22,920
entonces

480
00:19:22,920 --> 00:19:25,140
admite menos precisión en decimales

481
00:19:25,140 --> 00:19:27,420
lo único

482
00:19:27,420 --> 00:19:28,819
a tener en cuenta es

483
00:19:28,819 --> 00:19:30,119
cuando

484
00:19:30,119 --> 00:19:32,660
le asignáis un valor

485
00:19:32,660 --> 00:19:35,180
le asignáis un valor

486
00:19:35,180 --> 00:19:37,500
para que la máquina

487
00:19:37,500 --> 00:19:38,559
virtual lo entienda

488
00:19:38,559 --> 00:19:41,000
aquí no es

489
00:19:41,000 --> 00:19:43,579
el punto sin más para la parte decimal

490
00:19:43,579 --> 00:19:45,440
como veis me lo he puesto en rojo

491
00:19:45,440 --> 00:19:47,220
porque si vosotros ponéis

492
00:19:47,220 --> 00:19:48,640
8.9

493
00:19:48,640 --> 00:19:50,440
para la máquina virtual

494
00:19:50,440 --> 00:19:53,140
8.9 lo coge y lo interpreta

495
00:19:53,140 --> 00:19:54,279
como un número double

496
00:19:54,279 --> 00:19:57,140
y lo guarda temporalmente en 34 bits

497
00:19:57,140 --> 00:19:58,859
es como cuando hacíamos

498
00:19:58,859 --> 00:20:01,019
¿os acordáis? cuando yo decía

499
00:20:01,019 --> 00:20:04,859
por ejemplo

500
00:20:04,859 --> 00:20:06,380
esto

501
00:20:06,380 --> 00:20:12,339
si, eso es lo que iba a decir ahora

502
00:20:12,339 --> 00:20:13,880
sois muy listillos

503
00:20:13,880 --> 00:20:16,059
un momento, ahora lo digo

504
00:20:16,059 --> 00:20:18,319
esto es como yo decía

505
00:20:18,319 --> 00:20:21,380
si la máquina virtual ve ahí un 7

506
00:20:21,380 --> 00:20:23,619
un 7 sin más

507
00:20:23,619 --> 00:20:25,380
temporalmente

508
00:20:26,500 --> 00:20:27,599
lo almacena como int

509
00:20:27,599 --> 00:20:29,099
y luego ya

510
00:20:29,099 --> 00:20:31,079
hace con él lo que haya que hacer

511
00:20:31,079 --> 00:20:32,460
si yo quiero

512
00:20:32,460 --> 00:20:38,960
¿vale? por ejemplo

513
00:20:38,960 --> 00:20:44,170
esto era, ¿vale?

514
00:20:45,089 --> 00:20:46,750
él, yo veo este numerito

515
00:20:46,750 --> 00:20:48,309
temporalmente él lo

516
00:20:48,309 --> 00:20:50,730
interpreta como int, lo interpreta como int

517
00:20:50,730 --> 00:20:52,730
con lo cual, cuidado, esto no cabe

518
00:20:52,730 --> 00:20:54,670
en int, entonces te lo ponía en rojo

519
00:20:54,670 --> 00:20:56,769
¿Qué teníamos que hacer para que

520
00:20:56,769 --> 00:20:58,250
Él cogiera este número

521
00:20:58,250 --> 00:21:00,869
Y temporalmente lo pusiera en una caja de 64?

522
00:21:01,490 --> 00:21:02,329
Pues le poníamos la L

523
00:21:02,329 --> 00:21:02,750
¿Vale?

524
00:21:04,470 --> 00:21:05,609
Minúscula o mayúscula

525
00:21:05,609 --> 00:21:08,269
Yo la he puesto mayúscula

526
00:21:08,269 --> 00:21:10,730
La puse mayúscula, pero bueno, minúscula también nos valdría

527
00:21:10,730 --> 00:21:11,930
Pues esto es igual

528
00:21:11,930 --> 00:21:14,829
Si vosotros ponéis 8.9

529
00:21:14,829 --> 00:21:17,170
Él empieza a codificar eso

530
00:21:17,170 --> 00:21:18,549
Y lo codifica como dable

531
00:21:18,549 --> 00:21:21,009
Con lo cual, a la hora de

532
00:21:21,009 --> 00:21:22,650
Ese número que acaba de codificar

533
00:21:22,650 --> 00:21:24,609
Llevarlo a este, te dice el compilador

534
00:21:24,609 --> 00:21:26,970
Uy, un DAB en un float no cabe

535
00:21:26,970 --> 00:21:28,990
Entonces

536
00:21:28,990 --> 00:21:31,230
¿Qué hay que hacer para que lo codifique

537
00:21:31,230 --> 00:21:32,390
Internamente como float?

538
00:21:32,970 --> 00:21:34,509
Pues efectivamente ponerle una F

539
00:21:34,509 --> 00:21:36,890
Entonces

540
00:21:36,890 --> 00:21:38,549
Si le ponemos una F

541
00:21:38,549 --> 00:21:40,930
Lo codifica internamente como float

542
00:21:40,930 --> 00:21:41,930
¿Vale?

543
00:21:42,230 --> 00:21:43,750
O sea, igual que para crear el load

544
00:21:43,750 --> 00:21:45,230
Para crear el float siempre tiene que ser

545
00:21:45,230 --> 00:21:46,569
Claro, claro

546
00:21:46,569 --> 00:21:54,640
Aquí no se ve

547
00:21:54,640 --> 00:21:56,839
No, no se llega a ser

548
00:21:56,839 --> 00:22:00,519
no llega a verse

549
00:22:00,519 --> 00:22:05,539
no, hay que mostrarlo con la consola

550
00:22:05,539 --> 00:22:06,460
para que se vea, vale

551
00:22:06,460 --> 00:22:09,859
vale, bueno, pues este es el único matiz

552
00:22:09,859 --> 00:22:11,720
en realidad, que si queréis

553
00:22:11,720 --> 00:22:13,640
que asignar un valor así

554
00:22:13,640 --> 00:22:15,759
directamente, un valor a un número

555
00:22:15,759 --> 00:22:16,099
float

556
00:22:16,099 --> 00:22:19,640
pues tenéis que ponerlo con el

557
00:22:19,640 --> 00:22:21,599
F delante, porque si no va a decir que es

558
00:22:21,599 --> 00:22:22,700
un W y no puede, vale

559
00:22:22,700 --> 00:22:25,859
ahora, para poder usar los

560
00:22:25,859 --> 00:22:28,019
números decimales como datos de entrada

561
00:22:28,019 --> 00:22:29,980
y leerlos por teclado

562
00:22:29,980 --> 00:22:33,789
bueno, antes de cerrar

563
00:22:33,789 --> 00:22:35,490
esto y empezar a teclado

564
00:22:35,490 --> 00:22:37,670
un float cabe en un double y al revés

565
00:22:37,670 --> 00:22:39,509
no, ¿vale? es lo que acabo de decir

566
00:22:39,509 --> 00:22:39,950
eso ya

567
00:22:39,950 --> 00:22:44,930
perdona, creo que tuve que cogerlo

568
00:22:44,930 --> 00:22:51,279
sabe, ¿eh?

569
00:22:51,799 --> 00:22:51,940
¿eh?

570
00:22:51,940 --> 00:22:52,339
sabe

571
00:22:52,339 --> 00:22:56,559
sabe a la música

572
00:22:56,559 --> 00:22:58,720
no es como eso que vendía

573
00:22:58,720 --> 00:23:00,539
con una federación

574
00:23:00,539 --> 00:23:02,539
¡Mierda!

575
00:23:02,539 --> 00:23:06,539
Esta generación es muy biotecnológica en España.

576
00:23:06,539 --> 00:23:09,539
Más con este, más.

577
00:23:13,539 --> 00:23:16,539
Pero de todo que esta generación es materialista.

578
00:23:16,539 --> 00:23:17,539
¿Cómo te acuerdas de ella?

579
00:23:17,539 --> 00:23:18,539
Yo también.

580
00:23:18,539 --> 00:23:19,539
Yo también.

581
00:23:19,539 --> 00:23:21,539
Pero de todo que te acuerdas de ella.

582
00:23:21,539 --> 00:23:23,539
¡Mierda!

583
00:23:30,539 --> 00:23:35,319
¡Gracias!

584
00:24:05,910 --> 00:24:19,130
vale, pues entonces

585
00:24:19,130 --> 00:24:21,089
que float cabe en un double pero al revés no

586
00:24:21,089 --> 00:24:23,009
es como lo mismo, que un int cabe en un long

587
00:24:23,009 --> 00:24:25,089
pero al revés no, bueno, esas cosas ya no hace falta

588
00:24:25,089 --> 00:24:27,109
que lo pongamos en ejemplo

589
00:24:27,109 --> 00:24:30,890
entonces con la división

590
00:24:30,890 --> 00:24:32,650
cuando uno mezcla en operadores

591
00:24:32,650 --> 00:24:35,029
hace la suma de un float y un double

592
00:24:35,029 --> 00:24:36,910
un double y un float, pues lo mismo

593
00:24:36,910 --> 00:24:39,089
el float le puede promocionar

594
00:24:39,089 --> 00:24:41,390
a double si luego el resultado va en un double

595
00:24:41,390 --> 00:24:43,230
pero si el resultado va en un float

596
00:24:43,230 --> 00:24:45,130
no, pero bueno, esas pruebas ya las podéis

597
00:24:45,130 --> 00:24:46,430
hacer vosotros, es siempre lo mismo

598
00:24:46,430 --> 00:24:48,109
como pauta general

599
00:24:48,109 --> 00:24:51,150
normalmente, pues cuando

600
00:24:51,150 --> 00:24:53,170
uno trabaja con decimales usa double siempre

601
00:24:53,170 --> 00:24:55,089
y ya está, porque es

602
00:24:55,089 --> 00:24:56,890
mucho más cómodo si tenemos que darle un valor

603
00:24:56,890 --> 00:24:58,950
directamente, no tener que andar arrastrando la F

604
00:24:58,950 --> 00:25:01,269
ni nada, y aparte tienes más precisión

605
00:25:01,269 --> 00:25:03,349
y total de 32 a 64

606
00:25:03,349 --> 00:25:07,109
tampoco es que vayas a consumir ahí una memoria bestial, ¿vale?

607
00:25:07,130 --> 00:25:08,650
Como pauta general, un double y ya está.

608
00:25:08,750 --> 00:25:09,730
Bueno, y a lo que íbamos.

609
00:25:10,430 --> 00:25:16,650
Ahora, ¿cómo leemos por teclado números double para poder hacer programas?

610
00:25:17,210 --> 00:25:21,250
En nuestra clasecita esta de leer por teclado, ¿vale?

611
00:25:21,490 --> 00:25:26,470
En esta clase de aquí ya hemos visto cómo leer números int.

612
00:25:26,890 --> 00:25:29,069
Nos hemos olvidado por ahora de los short, los byte,

613
00:25:29,069 --> 00:25:33,170
porque para nuestros primeros programas leemos enteros y ya está, int.

614
00:25:33,349 --> 00:25:35,529
¿vale? pues exactamente igual

615
00:25:35,529 --> 00:25:37,430
que este objeto lector que yo os dije

616
00:25:37,430 --> 00:25:39,349
este objeto, es un objeto

617
00:25:39,349 --> 00:25:40,950
que yo me he creado

618
00:25:40,950 --> 00:25:42,809
y al ser una variable objeto

619
00:25:42,809 --> 00:25:44,670
es capaz de hacer cosas

620
00:25:44,670 --> 00:25:46,869
a diferencia de una primitiva

621
00:25:46,869 --> 00:25:49,150
de una variable primitiva que solo tiene un valor

622
00:25:49,150 --> 00:25:51,349
no es capaz de hacer nada, pues esta es capaz

623
00:25:51,349 --> 00:25:53,269
de hacer cosas, pues puede hacer cosas, y una tras otra

624
00:25:53,269 --> 00:25:55,509
una vez tras otra, aquí ya he hecho

625
00:25:55,509 --> 00:25:57,450
una, que es

626
00:25:57,450 --> 00:25:58,690
leer un entero

627
00:25:58,690 --> 00:26:01,750
del teclado, entregármelo

628
00:26:01,750 --> 00:26:19,430
esto último y ya nos vamos

629
00:26:19,430 --> 00:26:22,049
pues igual que este objeto lector

630
00:26:22,049 --> 00:26:23,509
ha podido

631
00:26:23,509 --> 00:26:26,029
leer un entero con esto

632
00:26:26,029 --> 00:26:27,769
pues yo lo puedo seguir usando

633
00:26:27,769 --> 00:26:29,309
y le puedo seguir encargando cosas

634
00:26:29,309 --> 00:26:31,930
por ejemplo, ahora yo tengo aquí

635
00:26:31,930 --> 00:26:32,910
mi numerito de Abel

636
00:26:32,910 --> 00:26:38,250
y ahora me interesa a mí leer

637
00:26:38,250 --> 00:26:40,349
este número por teclado, porque lo voy a usar

638
00:26:40,349 --> 00:26:42,289
para hacer cualquier cosa

639
00:26:42,289 --> 00:26:43,470
el porcentaje o lo que sea

640
00:26:43,470 --> 00:26:46,150
bueno, pues entonces, le tengo que

641
00:26:46,150 --> 00:26:47,869
asignar el resultado

642
00:26:47,869 --> 00:26:49,529
de

643
00:26:49,529 --> 00:26:52,309
darle una orden al lector

644
00:26:52,309 --> 00:26:53,630
de leer por teclado

645
00:26:53,630 --> 00:26:57,509
y así está, es esta

646
00:26:57,509 --> 00:26:59,650
igual que esta

647
00:26:59,650 --> 00:27:02,230
lee un número entero, pues esta

648
00:27:02,230 --> 00:27:04,289
vale, vamos a

649
00:27:04,289 --> 00:27:06,369
mostrarlo aquí, lo probamos para que

650
00:27:06,369 --> 00:27:08,930
veáis una cosa por si queréis practicarlo en casa

651
00:27:08,930 --> 00:27:12,690
y lo dejamos, vale

652
00:27:12,690 --> 00:27:17,880
vale, a ver

653
00:27:17,880 --> 00:27:19,480
si

654
00:27:19,480 --> 00:27:22,220
curioseáis en los objetos

655
00:27:22,220 --> 00:27:24,720
de clase scanner, si curioseáis

656
00:27:24,720 --> 00:27:26,059
veréis que igual que tienen

657
00:27:26,059 --> 00:27:27,940
next int, next double, tienen next short

658
00:27:27,940 --> 00:27:30,640
next byte, next byte, next long

659
00:27:30,640 --> 00:27:32,579
para hacer lo mismo pero leyendo

660
00:27:32,579 --> 00:27:34,460
un número en tamaño byte

661
00:27:34,460 --> 00:27:36,539
un tamaño long, un next float

662
00:27:36,539 --> 00:27:38,279
vale, pero bueno

663
00:27:38,279 --> 00:27:40,019
con next int para leer enteros

664
00:27:40,019 --> 00:27:41,740
y next double para leer decimales

665
00:27:41,740 --> 00:27:43,799
ya podemos hacerlo todo

666
00:27:43,799 --> 00:27:46,420
bueno, pues entonces si probamos

667
00:27:46,420 --> 00:27:48,220
esto, cuidado

668
00:27:48,220 --> 00:27:50,180
porque el next double

669
00:27:50,180 --> 00:27:52,299
es lo que te hace este objeto para leer

670
00:27:52,299 --> 00:27:54,200
el numerito, pero él

671
00:27:54,200 --> 00:27:56,339
no es java, él es un

672
00:27:56,339 --> 00:27:58,420
tío que quiere que las cosas se las digas de otra

673
00:27:58,420 --> 00:28:00,400
manera, entonces vamos

674
00:28:00,400 --> 00:28:01,779
a ejecutar este código de aquí

675
00:28:01,779 --> 00:28:09,029
bueno, esto era de arriba

676
00:28:09,029 --> 00:28:11,109
que ya lo teníamos y ahora se me ha quedado aquí

677
00:28:11,109 --> 00:28:12,910
esperando el double, yo lo tengo ahí esperando el double

678
00:28:12,910 --> 00:28:15,650
le voy a poner 7.8

679
00:28:15,650 --> 00:28:17,829
pum, no le ha gustado

680
00:28:17,829 --> 00:28:19,750
7.8, vale, ¿por qué?

681
00:28:19,829 --> 00:28:21,970
porque aquí no estoy escribiendo código Java

682
00:28:21,970 --> 00:28:23,950
aquí estoy escribiendo

683
00:28:23,950 --> 00:28:25,650
información para el tío

684
00:28:25,650 --> 00:28:27,789
ese lector que está metido ahí dentro

685
00:28:27,789 --> 00:28:30,170
esperando que yo le dé un numerito

686
00:28:30,170 --> 00:28:31,430
con decimales

687
00:28:31,430 --> 00:28:33,609
para con él guardarlo en una variable

688
00:28:33,609 --> 00:28:35,609
y ese tío que está ahí dentro

689
00:28:35,609 --> 00:28:37,329
esperando que yo le dé ese número con decimales

690
00:28:37,329 --> 00:28:39,410
le gusta que se los dé con la cop

691
00:28:39,410 --> 00:28:41,589
porque es a lo que está acostumbrado, porque es un señor

692
00:28:41,589 --> 00:28:42,609
humano que está ahí metido

693
00:28:42,609 --> 00:28:44,089
Pues entonces

694
00:28:44,089 --> 00:28:47,329
Si yo vuelvo a ejecutar esto

695
00:28:47,329 --> 00:28:50,819
Y le doy el numerito

696
00:28:50,819 --> 00:28:52,099
8,8

697
00:28:52,099 --> 00:28:53,319
Este ya sí que le ha gustado

698
00:28:53,319 --> 00:28:56,079
¿Vale? Pero este 8,8

699
00:28:56,079 --> 00:28:58,259
No es código Java, yo no lo puedo meter en Java

700
00:28:58,259 --> 00:29:01,019
Y decir al numerito de Abel igual a 8,8

701
00:29:01,019 --> 00:29:02,680
En Java lo que entiende es esto

702
00:29:02,680 --> 00:29:04,539
De hecho cuando le he pedido que me lo vuelva a mostrar

703
00:29:04,539 --> 00:29:06,339
Ya me lo ha mostrado con el punto

704
00:29:06,339 --> 00:29:07,579
¿Vale?

705
00:29:09,200 --> 00:29:09,960
Esto es porque

706
00:29:09,960 --> 00:29:12,240
Esto está orientado a la interfaz con el usuario

707
00:29:12,240 --> 00:29:13,559
Y de toda la vida

708
00:29:13,559 --> 00:29:15,819
en matemáticas la coma

709
00:29:15,819 --> 00:29:17,819
de la parte decimal hasta se va a poner una coma.

710
00:29:18,579 --> 00:29:19,880
Entonces, se está viendo al usuario

711
00:29:19,880 --> 00:29:20,940
que es el que mete las cosas.

712
00:29:21,599 --> 00:29:22,920
Y el usuario es un humano

713
00:29:22,920 --> 00:29:25,400
que está acostumbrado a la coma

714
00:29:25,400 --> 00:29:27,400
para la parte decimal. Pues por eso

715
00:29:27,400 --> 00:29:29,480
el next double funciona pidiéndote

716
00:29:29,480 --> 00:29:30,539
que se lo pongas como coma.

717
00:29:32,039 --> 00:29:33,619
Venga, y ahora sí que nos callamos

718
00:29:33,619 --> 00:29:34,299
y nos vamos.