1
00:00:00,820 --> 00:00:02,819
¿A quién nos habíamos quedado?

2
00:00:04,620 --> 00:00:09,720
Entonces, ¿esto es así inamovible para los restos de los restos?

3
00:00:10,500 --> 00:00:16,359
Y si yo tengo un código ya larguísimo que en algún momento necesito decir,

4
00:00:16,359 --> 00:00:21,859
a ver, es que yo no puedo declarar, no puedo cambiar la declaración de las variables, no puedo.

5
00:00:22,480 --> 00:00:25,320
Esto está hecho en otro sitio, en otra clase, en otra parte.

6
00:00:26,059 --> 00:00:29,219
Ya veremos cómo se programan las cosas en diferentes clases.

7
00:00:29,219 --> 00:00:31,300
es que no puedo cambiar la declaración

8
00:00:31,300 --> 00:00:33,259
de tipos, no puedo irme aquí

9
00:00:33,259 --> 00:00:35,200
esta parte del código yo no la he hecho

10
00:00:35,200 --> 00:00:36,840
no puedo cambiar esto

11
00:00:36,840 --> 00:00:39,119
estoy condenada a no poder sacar el precio con IVA

12
00:00:39,119 --> 00:00:41,439
no poder hacer mi programa y que me expulse

13
00:00:41,439 --> 00:00:43,520
¿qué hago?

14
00:00:43,799 --> 00:00:45,219
si no puedo tocar esto

15
00:00:45,219 --> 00:00:47,159
y me han pedido

16
00:00:47,159 --> 00:00:48,920
que saque el precio con IVA, ¿qué hago?

17
00:00:50,679 --> 00:00:51,119
bueno

18
00:00:51,119 --> 00:00:53,020
pues hay una cosa que se puede hacer

19
00:00:53,020 --> 00:00:55,439
que es fea horrible del mundo mundial

20
00:00:55,439 --> 00:00:57,100
que es el

21
00:00:57,100 --> 00:00:57,619
castigo

22
00:00:57,619 --> 00:01:00,899
fea horrible del mundo mundial

23
00:01:00,899 --> 00:01:02,259
en general

24
00:01:02,259 --> 00:01:04,939
en contextos

25
00:01:04,939 --> 00:01:06,439
que ya veremos más adelante

26
00:01:06,439 --> 00:01:09,219
hay que hacerla por un tema de clases genéricas

27
00:01:09,219 --> 00:01:10,159
de para ti y de para tan

28
00:01:10,159 --> 00:01:11,359
pero

29
00:01:11,359 --> 00:01:15,420
no es una herramienta

30
00:01:15,420 --> 00:01:16,359
que podamos usar

31
00:01:16,359 --> 00:01:18,739
para solucionar problemas de compilación

32
00:01:18,739 --> 00:01:21,340
porque lo que solemos generar son problemas más gordos

33
00:01:21,340 --> 00:01:22,939
y ya en tiempo de ejecución

34
00:01:22,939 --> 00:01:23,659
que es lo que no queremos

35
00:01:23,659 --> 00:01:27,379
pero como pega aquí, pues vamos a mencionarlo aquí

36
00:01:27,379 --> 00:01:29,099
que es el casting

37
00:01:29,099 --> 00:01:31,120
el casting es una forma

38
00:01:31,120 --> 00:01:32,180
de decirle a Java

39
00:01:32,180 --> 00:01:35,400
ya sé que los tipos no son compatibles

40
00:01:35,400 --> 00:01:36,719
ya sé que a lo mejor

41
00:01:36,719 --> 00:01:38,140
te tienes que cargar información

42
00:01:38,140 --> 00:01:41,019
me da igual, cámbiame este double

43
00:01:41,019 --> 00:01:42,840
a float, aunque te comas

44
00:01:42,840 --> 00:01:44,739
la mitad de los decimales, me da igual

45
00:01:44,739 --> 00:01:46,859
porque yo tengo que guardar el precio

46
00:01:46,859 --> 00:01:48,200
con IVA en un float, sí o sí

47
00:01:48,200 --> 00:01:49,599
porque esto no lo puedo tocar

48
00:01:49,599 --> 00:01:52,099
y esto te va a dar en double, sí o sí

49
00:01:52,099 --> 00:01:53,760
porque es que esto no lo puedo tocar

50
00:01:53,760 --> 00:01:56,760
entonces lo siento, cambia ese

51
00:01:56,760 --> 00:01:58,379
de double a float

52
00:01:58,379 --> 00:02:01,000
para lo cual puede que pierdas

53
00:02:01,000 --> 00:02:02,700
un montón de cifras decimales

54
00:02:02,700 --> 00:02:04,799
pero pagaré ese precio

55
00:02:04,799 --> 00:02:06,579
eso es el casting

56
00:02:06,579 --> 00:02:08,500
convertir a lo bestia

57
00:02:08,500 --> 00:02:09,819
un tipo en otro

58
00:02:09,819 --> 00:02:11,939
¿qué sale de esa conversión?

59
00:02:13,039 --> 00:02:14,860
vete a saber, algo absolutamente

60
00:02:14,860 --> 00:02:16,539
raro, a ver

61
00:02:16,539 --> 00:02:17,979
de la conversión

62
00:02:17,979 --> 00:02:20,659
de un double a un float

63
00:02:20,659 --> 00:02:22,699
no sale nada tan raro

64
00:02:22,699 --> 00:02:24,580
sale un numerito con unas cuantas

65
00:02:24,580 --> 00:02:25,740
decimales que hemos quitado

66
00:02:25,740 --> 00:02:27,360
No es tan terrible

67
00:02:27,360 --> 00:02:30,240
Hemos perdido cifras decimales

68
00:02:30,240 --> 00:02:32,180
Tampoco seguramente no se vaya a la vida

69
00:02:32,180 --> 00:02:34,080
En que ese precio con IVA haya perdido

70
00:02:34,080 --> 00:02:35,360
Unas cuantas cifras decimales

71
00:02:35,360 --> 00:02:37,539
Pero en muchos otros contextos

72
00:02:37,539 --> 00:02:39,620
El casting se carga el programa

73
00:02:39,620 --> 00:02:42,400
¿Vale? Yo tengo un objeto alumno

74
00:02:42,400 --> 00:02:44,740
Y tengo que meterlo en un objeto mesa

75
00:02:44,740 --> 00:02:47,460
Pues es que lo siento

76
00:02:47,460 --> 00:02:49,479
Casting de alumno a mesa

77
00:02:49,479 --> 00:02:51,240
Vete a saber lo que te sale de ahí

78
00:02:51,240 --> 00:02:52,819
¿Vale? El tele dice yo te lo hago

79
00:02:52,819 --> 00:02:54,620
Yo te convierto el alumno en una mesa

80
00:02:54,620 --> 00:02:55,520
¿Te lo va a hacer?

81
00:02:55,740 --> 00:03:00,259
Se acaban los problemas de compilación, pero a saber qué sale de ahí, ¿vale?

82
00:03:00,800 --> 00:03:03,639
Bueno, pues ¿cómo se usa esta herramienta de casting?

83
00:03:04,919 --> 00:03:11,759
Simplemente, delante de lo que queramos convertir, que en este caso es todo esto,

84
00:03:12,520 --> 00:03:17,319
quiero pasarlo a float, todo esto que es double, quiero pasarlo a float,

85
00:03:17,319 --> 00:03:20,159
Delante de lo que queramos convertir

86
00:03:20,159 --> 00:03:22,120
Ponemos

87
00:03:22,120 --> 00:03:26,419
Paréntesis

88
00:03:26,419 --> 00:03:28,699
Y dentro de los paréntesis

89
00:03:28,699 --> 00:03:31,520
El tipo al que queremos convertirlo

90
00:03:31,520 --> 00:03:33,379
¿A dónde quiero llevar yo esto?

91
00:03:33,719 --> 00:03:34,300
A Float

92
00:03:34,300 --> 00:03:36,000
Pues a la

93
00:03:36,000 --> 00:03:38,219
A Float a lo bestia

94
00:03:38,219 --> 00:03:41,900
Cuidado, aquí me sigue saliendo rojo

95
00:03:41,900 --> 00:03:44,259
Porque el casting aplica

96
00:03:44,259 --> 00:03:46,219
A justo lo que tengas pegadito

97
00:03:46,219 --> 00:03:47,879
Cuidado, yo quiero que aplique

98
00:03:47,879 --> 00:03:48,780
Si yo lo dejo así

99
00:03:48,780 --> 00:03:51,180
el casting me aplicaría

100
00:03:51,180 --> 00:03:52,280
solo a precio 1

101
00:03:52,280 --> 00:03:54,879
este seguiría siendo double, con lo cual

102
00:03:54,879 --> 00:03:56,020
float más double, double

103
00:03:56,020 --> 00:03:58,280
entonces en este ejemplito concreto

104
00:03:58,280 --> 00:04:00,099
yo quiero que me aplique a todo

105
00:04:00,099 --> 00:04:02,300
paréntesis ahí

106
00:04:02,300 --> 00:04:03,780
ahí sí que me hacen falta

107
00:04:03,780 --> 00:04:07,000
entonces, este es un

108
00:04:07,000 --> 00:04:08,639
pedazo de casting que me he cascado

109
00:04:08,639 --> 00:04:10,740
para que todo esto

110
00:04:10,740 --> 00:04:13,039
todo, que es un double con un montón

111
00:04:13,039 --> 00:04:14,960
de decimales, le mande

112
00:04:14,960 --> 00:04:15,719
los decimales

113
00:04:15,719 --> 00:04:18,579
sobrantes a la izquierda

114
00:04:18,579 --> 00:04:19,420
a la basura

115
00:04:19,420 --> 00:04:20,959
y lo meta en un flowback

116
00:04:20,959 --> 00:04:22,980
y ahora ya el compilador dice

117
00:04:22,980 --> 00:04:25,439
ya está, te lo puedo hacer

118
00:04:25,439 --> 00:04:27,740
pero claro, el compilador se queda

119
00:04:27,740 --> 00:04:28,839
a los castings le encanta

120
00:04:28,839 --> 00:04:31,560
porque él dice, uy ya está

121
00:04:31,560 --> 00:04:32,560
me salto la regla

122
00:04:32,560 --> 00:04:35,199
de compatibilidad de tipos

123
00:04:35,199 --> 00:04:37,220
pero a costa de perder información

124
00:04:37,220 --> 00:04:38,899
¿vale?

125
00:04:41,740 --> 00:04:43,660
entonces el casting se pone delante

126
00:04:43,660 --> 00:04:44,240
de un valor

127
00:04:44,240 --> 00:04:46,540
un valor que puede haber venido

128
00:04:46,540 --> 00:04:48,180
de una expresión, de donde sea

129
00:04:48,180 --> 00:04:49,360
se pone delante de un valor

130
00:04:49,360 --> 00:04:51,600
y lo que hace es todo ese valor

131
00:04:51,600 --> 00:04:54,100
cambia su almacenamiento interno

132
00:04:54,100 --> 00:04:55,959
lo transforma para que ahora ya se almacene

133
00:04:55,959 --> 00:04:56,579
como ese tipo

134
00:04:56,579 --> 00:04:59,800
entonces esto que estaba almacenado como dabel

135
00:04:59,800 --> 00:05:02,620
lo transformará para que se almacene

136
00:05:02,620 --> 00:05:03,199
como floa

137
00:05:03,199 --> 00:05:05,639
en este caso no es grave, repito

138
00:05:05,639 --> 00:05:08,040
porque va a implicar solo quitar cifras de formal

139
00:05:08,040 --> 00:05:10,300
pero es que yo podría

140
00:05:10,300 --> 00:05:11,660
hacer el casting entre tipos

141
00:05:11,660 --> 00:05:12,779
que tienen aquel uno o el otro

142
00:05:12,779 --> 00:05:15,300
y la máquina virtual

143
00:05:15,300 --> 00:05:16,759
sobrevive como puede

144
00:05:16,759 --> 00:05:19,560
pero claro, lo que sale de ahí

145
00:05:19,560 --> 00:05:20,339
puede ser muy raro

146
00:05:20,339 --> 00:05:23,339
el compilador se queda tranquilo porque ya dice

147
00:05:23,339 --> 00:05:25,879
ah vale, lo has convertido en tipo compatible

148
00:05:25,879 --> 00:05:27,980
muy bien, yo me callo

149
00:05:27,980 --> 00:05:29,699
pero esa conversión

150
00:05:29,699 --> 00:05:31,420
puede haber

151
00:05:31,420 --> 00:05:33,459
resultado en cualquier valor extra

152
00:05:33,459 --> 00:05:35,060
¿vale?

153
00:05:36,459 --> 00:05:37,579
bueno, pues el casting

154
00:05:37,579 --> 00:05:39,139
entonces, lógicamente con cuidado

155
00:05:39,139 --> 00:05:41,620
cuando uno tiene un montón de errores de compilación

156
00:05:41,620 --> 00:05:43,459
el compilador tan majo él

157
00:05:43,459 --> 00:05:45,600
una de las soluciones que te da siempre es

158
00:05:45,600 --> 00:05:47,699
haz un cast, claro con un cast

159
00:05:47,699 --> 00:05:49,100
el compilador se quita el problema

160
00:05:49,100 --> 00:05:50,980
pero nunca es la solución

161
00:05:50,980 --> 00:05:53,560
la solución será que a lo mejor tú has diseñado

162
00:05:53,560 --> 00:05:55,620
mal tu ejercicio, has elegido

163
00:05:55,620 --> 00:05:58,040
mal los tipos de datos, has elegido mal las operaciones

164
00:05:58,040 --> 00:05:59,420
y eso nunca te lo va

165
00:05:59,420 --> 00:06:01,379
a detectar el compilador, jamás

166
00:06:01,379 --> 00:06:04,160
¿vale?

167
00:06:11,079 --> 00:06:12,300
si ha funcionado

168
00:06:12,300 --> 00:06:14,379
es porque precio 1 es flow también

169
00:06:14,379 --> 00:06:18,629
entonces como ya era float

170
00:06:18,629 --> 00:06:20,670
esto no es un double

171
00:06:20,670 --> 00:06:22,829
si ya es float

172
00:06:22,829 --> 00:06:23,790
pues float a float

173
00:06:23,790 --> 00:06:24,370
¿vale?

174
00:06:26,839 --> 00:06:27,319
¿veis?

175
00:06:27,379 --> 00:06:27,740
por ejemplo

176
00:06:27,740 --> 00:06:29,680
cuando yo no lo tenía puesto el casting

177
00:06:29,680 --> 00:06:30,740
y me daba el error

178
00:06:30,740 --> 00:06:33,819
cuando yo lo tenía así

179
00:06:33,819 --> 00:06:37,620
y me daba el error

180
00:06:37,620 --> 00:06:40,660
yo pongo aquí la manita

181
00:06:40,660 --> 00:06:41,579
y me dice

182
00:06:41,579 --> 00:06:43,639
lo siento

183
00:06:43,639 --> 00:06:44,740
el tipo no encaja

184
00:06:44,740 --> 00:06:46,439
no puedo convertir de double a float

185
00:06:46,439 --> 00:06:48,740
y si yo soy un programador desastroso

186
00:06:48,740 --> 00:06:56,160
desastroso, hago clic ahí porque ahí el compilador me hace sugerencias, la mayoría de las cuales

187
00:06:56,160 --> 00:07:04,120
debo desechar, lógicamente, porque él no entiende del sentido de mi programa, él solamente

188
00:07:04,120 --> 00:07:11,319
entiende de reglas sintácticas, ¿vale? Entonces, yo voy a pasar por una puerta que me llega

189
00:07:11,319 --> 00:07:20,100
hasta aquí. El compilador me dice, no te dejo pasar. ¿Qué sugerencia me ofrece? Que

190
00:07:20,100 --> 00:07:25,800
me corte la cabeza. Pues yo sigo al compilador tranquilamente y digo, estupendo, me voy a

191
00:07:25,800 --> 00:07:32,240
cortar la cabeza y voy a caer estupendamente. Pero hombre, normalmente no es esa la solución

192
00:07:32,240 --> 00:07:37,680
que queremos adoptar. A lo mejor será, jolines, es que he elegido la puerta que no es, es

193
00:07:37,680 --> 00:07:40,519
que yo tenía que haber llevado mi programa por aquí, que es donde está la puerta buena.

194
00:07:41,319 --> 00:07:46,300
eso nunca me lo va a decir el compilador eso yo que he diseñado el programa entiendo los

195
00:07:46,300 --> 00:07:50,740
requisitos soy la que me doy cuenta de que es que esa estructura está mal planteada desde

196
00:07:50,740 --> 00:07:56,019
principio a fin vale si yo sigo al compilador pues me corto la cabeza paso por la puerta y

197
00:07:56,019 --> 00:08:03,839
mi programa lógicamente no tiene el resultado que yo espero vale entonces si yo pulso aquí

198
00:08:03,839 --> 00:08:07,120
no solamente deposito la mano sin pulsar

199
00:08:07,120 --> 00:08:08,759
sino además pulso

200
00:08:08,759 --> 00:08:11,360
él me ofrece

201
00:08:11,360 --> 00:08:12,199
soluciones

202
00:08:12,199 --> 00:08:15,879
y una de ellas es

203
00:08:15,879 --> 00:08:17,379
hazle un cast

204
00:08:17,379 --> 00:08:19,779
ala, magnífico, si yo le hago un cast

205
00:08:19,779 --> 00:08:20,939
solucionado

206
00:08:20,939 --> 00:08:22,139
hazle un cast

207
00:08:22,139 --> 00:08:26,519
hago aquí mi doble clic

208
00:08:26,519 --> 00:08:29,500
y ala, él ya me ha hecho

209
00:08:29,500 --> 00:08:31,379
justo lo que yo habría escrito antes, un cast

210
00:08:31,379 --> 00:08:34,000
el error de compilación ha desaparecido

211
00:08:34,000 --> 00:08:37,080
Pero he perdido cifras decimales

212
00:08:37,080 --> 00:08:38,899
¿Me importa?

213
00:08:39,100 --> 00:08:40,519
¿No me importa? Pues no lo sé

214
00:08:40,519 --> 00:08:41,840
Habrá que ver el contexto

215
00:08:41,840 --> 00:08:43,600
Esta puede ser una solución horrible

216
00:08:43,600 --> 00:08:45,419
¿Vale?

217
00:08:47,480 --> 00:08:48,919
También me ofrecía otra

218
00:08:48,919 --> 00:08:51,870
En este caso

219
00:08:51,870 --> 00:08:53,169
Que son cosas sencillas

220
00:08:53,169 --> 00:08:54,950
Pues hombre, no dice tantas burradas

221
00:08:54,950 --> 00:08:56,190
Pero en general las dice

222
00:08:56,190 --> 00:08:57,850
También me ofrecía

223
00:08:57,850 --> 00:09:00,509
Cambia el tipo de precio con IVA a DABEL

224
00:09:00,509 --> 00:09:03,009
Ah, vale, venga

225
00:09:03,009 --> 00:09:03,889
Lo cambia a DABEL

226
00:09:03,889 --> 00:09:04,970
Pues vale, ya está

227
00:09:04,970 --> 00:09:08,110
Vale, esto sí, pero a lo mejor yo no puedo hacerlo

228
00:09:08,110 --> 00:09:12,100
Bueno

229
00:09:12,100 --> 00:09:16,379
¿Todo claro?

230
00:09:17,860 --> 00:09:19,659
Matices, sí, dale, la, la, la, la

231
00:09:19,659 --> 00:09:23,639
Sí, todo, todísimo

232
00:09:23,639 --> 00:09:28,259
Venga, pues vamos a los char, que son más divertidos

233
00:09:28,259 --> 00:09:32,059
Son mucho más divertidos

234
00:09:32,059 --> 00:09:35,559
Venga, ¿dónde nos vamos?

235
00:09:36,000 --> 00:09:37,279
Pues aquí mismo, ala

236
00:09:37,279 --> 00:09:39,580
Char

237
00:09:39,580 --> 00:09:42,500
esto es más divertido

238
00:09:42,500 --> 00:09:48,519
¿qué es una variable de tipo char?

239
00:09:48,899 --> 00:09:50,659
lo sabemos de ayer

240
00:09:50,659 --> 00:09:54,759
una variable que vale para guardar

241
00:09:54,759 --> 00:09:56,659
un único carácter

242
00:09:56,659 --> 00:09:57,779
muy bien

243
00:09:57,779 --> 00:09:59,460
he abierto los números

244
00:09:59,460 --> 00:10:00,639
pero mal

245
00:10:00,639 --> 00:10:02,039
vale

246
00:10:02,039 --> 00:10:04,240
y de los boolean

247
00:10:04,240 --> 00:10:06,960
por ejemplo esta

248
00:10:06,960 --> 00:10:08,039
ala

249
00:10:08,039 --> 00:10:10,820
tengo declarada mi variable char

250
00:10:10,820 --> 00:10:13,659
que vale para guardar un único carácter

251
00:10:13,659 --> 00:10:15,620
muy bien, solo uno

252
00:10:15,620 --> 00:10:19,080
vale, también dijimos ayer

253
00:10:19,080 --> 00:10:25,340
¿cómo le asigno yo un carácter a una variable char?

254
00:10:26,019 --> 00:10:29,080
pues Java interpreta que un carácter

255
00:10:29,080 --> 00:10:33,580
es algo que está entre comillas sencillas de estas

256
00:10:33,580 --> 00:10:34,519
¿vale?

257
00:10:36,919 --> 00:10:38,580
esto es un char

258
00:10:38,580 --> 00:10:45,320
eso no es el número 8

259
00:10:45,320 --> 00:10:47,700
no es el número 8

260
00:10:47,700 --> 00:10:49,820
es el carácter 8

261
00:10:49,820 --> 00:10:52,519
yo con eso no puedo operar

262
00:10:52,519 --> 00:10:53,960
no puedo hacer sumas, restas

263
00:10:53,960 --> 00:10:55,279
no, es el carácter 8

264
00:10:55,279 --> 00:10:58,220
tal y como aparece en mi editor de texto

265
00:10:58,220 --> 00:11:00,700
igual que la C es el carácter C

266
00:11:00,700 --> 00:11:02,200
tal y como aparece en mi editor de texto

267
00:11:02,200 --> 00:11:04,460
es otra cosa, es el carácter 8

268
00:11:04,460 --> 00:11:06,139
¿vale?

269
00:11:07,460 --> 00:11:10,480
y ahora la siguiente pregunta natural sería

270
00:11:10,480 --> 00:11:27,480
¿Y cuántos caracteres puedo representar? Pues un montón, en particular, luego más, pero ahora primero empezamos en particular, todos los que están en la famosa tabla ASTI.

271
00:11:27,480 --> 00:11:44,210
que es la tabla

272
00:11:44,210 --> 00:11:44,730
ASTI

273
00:11:44,730 --> 00:11:47,330
la tabla ASTI

274
00:11:47,330 --> 00:11:49,409
muchos ya os suena

275
00:11:49,409 --> 00:11:51,789
es

276
00:11:51,789 --> 00:11:54,629
una forma

277
00:11:54,629 --> 00:11:56,250
que todas

278
00:11:56,250 --> 00:11:57,669
las máquinas han adoptado

279
00:11:57,669 --> 00:12:00,509
para codificar caracteres

280
00:12:00,509 --> 00:12:01,669
¿vale?

281
00:12:02,169 --> 00:12:02,990
y usa

282
00:12:02,990 --> 00:12:05,730
127 bits

283
00:12:05,730 --> 00:12:07,210
usa

284
00:12:07,210 --> 00:12:10,110
7 bits

285
00:12:10,110 --> 00:12:12,809
como 7 no se puede impartir, en realidad se usa un byte

286
00:12:12,809 --> 00:12:14,669
pero bueno, de esos bytes se usan 7 bits

287
00:12:14,669 --> 00:12:17,009
127 es por los caracteres

288
00:12:17,009 --> 00:12:18,590
que se pueden representar

289
00:12:18,590 --> 00:12:19,450
vale, lo doy

290
00:12:19,450 --> 00:12:24,529
entonces

291
00:12:24,529 --> 00:12:27,950
el convenio de codificación ASCII

292
00:12:27,950 --> 00:12:29,110
asume

293
00:12:29,110 --> 00:12:31,629
pues que tú tienes un byte

294
00:12:31,629 --> 00:12:33,289
aquí y

295
00:12:33,289 --> 00:12:34,789
los caracteres

296
00:12:34,789 --> 00:12:37,370
representas caracteres

297
00:12:37,370 --> 00:12:39,789
mediante las combinaciones

298
00:12:39,789 --> 00:12:41,250
de estos 7 bits de aquí

299
00:12:41,250 --> 00:12:45,110
luego tienes para 127 caracteres distintos

300
00:12:45,110 --> 00:12:46,830
que ya son un montón de caracteres

301
00:12:46,830 --> 00:12:49,330
ya son un montón

302
00:12:49,330 --> 00:12:53,669
bueno, pues la tabla ASCII

303
00:12:53,669 --> 00:12:56,789
a cada carácter imprimible

304
00:12:56,789 --> 00:12:58,830
en un blog de notas, un editor, donde sea

305
00:12:58,830 --> 00:13:00,470
cada carácter imprimible

306
00:13:00,470 --> 00:13:03,429
le asocia una combinación de estos

307
00:13:03,429 --> 00:13:06,470
y todas las máquinas siguen ese convenio

308
00:13:06,470 --> 00:13:07,990
entonces la C

309
00:13:07,990 --> 00:13:10,169
en mi editor de texto

310
00:13:10,169 --> 00:13:13,110
está representado con una combinación

311
00:13:13,110 --> 00:13:15,029
binaria que es exactamente

312
00:13:15,029 --> 00:13:16,309
la misma que usa

313
00:13:16,309 --> 00:13:18,710
cualquier otro editor de texto

314
00:13:18,710 --> 00:13:21,269
me da igual cambiar del blog de notas

315
00:13:21,269 --> 00:13:23,169
al WordPad, cambiar el editor

316
00:13:23,169 --> 00:13:24,190
de texto del Eclipse

317
00:13:24,190 --> 00:13:27,289
no los procesadores, olvidados del Word

318
00:13:27,289 --> 00:13:29,370
y de todo eso

319
00:13:29,370 --> 00:13:31,009
el Docs, todo eso

320
00:13:31,009 --> 00:13:33,269
esos son procesadores de texto, es distinto

321
00:13:33,269 --> 00:13:35,009
ellos no guardan

322
00:13:35,009 --> 00:13:36,909
los caracteres según la

323
00:13:36,909 --> 00:13:39,090
codificación ASCII, lo guardan

324
00:13:39,090 --> 00:13:41,509
con sus propios códigos internos

325
00:13:41,509 --> 00:13:43,149
para poder representar

326
00:13:43,149 --> 00:13:44,190
colores, etc.

327
00:13:45,850 --> 00:13:47,169
Pero nosotros en programación

328
00:13:47,169 --> 00:13:48,509
no nos importan los colores de texto.

329
00:13:49,169 --> 00:13:51,309
Nosotros en programación hablamos con texto puro y duro.

330
00:13:52,250 --> 00:13:52,929
Bueno, pues entonces

331
00:13:52,929 --> 00:13:54,450
la codificación ASCII

332
00:13:54,450 --> 00:13:57,070
fija una combinación

333
00:13:57,070 --> 00:13:59,149
de 7 bits para cada

334
00:13:59,149 --> 00:14:00,330
carácter posible.

335
00:14:02,549 --> 00:14:04,750
Y esa la usan todos los editores

336
00:14:04,750 --> 00:14:06,649
de texto, todos. Por eso cuando

337
00:14:06,649 --> 00:14:08,210
yo escribo en mi blog de notas

338
00:14:08,210 --> 00:14:10,649
un poema y ahora ese poema

339
00:14:10,649 --> 00:14:12,769
lo abre Pepito en otro

340
00:14:12,769 --> 00:14:14,549
editor de texto distinto, el Notepad

341
00:14:14,549 --> 00:14:16,889
que tiene él, pues ve mi poema tal cual

342
00:14:16,889 --> 00:14:18,549
porque ambos han seguido

343
00:14:18,549 --> 00:14:20,389
la misma forma de codificar

344
00:14:20,389 --> 00:14:21,870
los caracteres, la misma

345
00:14:21,870 --> 00:14:24,990
si cada ordenador usara para codificar

346
00:14:24,990 --> 00:14:26,470
caracteres una forma distinta

347
00:14:26,470 --> 00:14:28,750
lo que yo escribo en mi blog de notas

348
00:14:28,750 --> 00:14:29,990
lo abre

349
00:14:29,990 --> 00:14:32,549
Juanito en su Notepad

350
00:14:32,549 --> 00:14:34,090
y no...

351
00:14:34,090 --> 00:14:35,210
no entendería más nada

352
00:14:35,210 --> 00:14:58,360
Bueno, pues esta codificación, ¿cuál es? Pues la tenemos en la famosa tabla ASTI, ¿vale? La famosa tabla ASTI que rápidamente la podéis localizar en internet porque hay millones de páginas que te muestran la tabla ASTI, que sería una cosa como esto, ¿vale?

353
00:14:58,360 --> 00:15:06,049
Las dos primeras columnas

354
00:15:06,049 --> 00:15:07,830
Olvidaros del hasti extendido

355
00:15:07,830 --> 00:15:10,169
Las dos primeras columnas

356
00:15:10,169 --> 00:15:11,649
Como veis

357
00:15:11,649 --> 00:15:13,610
Llegamos hasta 126 sol

358
00:15:13,610 --> 00:15:15,929
Son los caracteres

359
00:15:15,929 --> 00:15:17,429
Más habituales

360
00:15:17,429 --> 00:15:19,730
Los únicos que podemos imprimir

361
00:15:19,730 --> 00:15:21,129
Pero eso ahora lo vemos después

362
00:15:21,129 --> 00:15:23,710
¿Vale? Son los más habituales

363
00:15:23,710 --> 00:15:24,830
Todos estos que están aquí

364
00:15:24,830 --> 00:15:28,190
Que son caracteres especiales

365
00:15:28,190 --> 00:15:28,909
Los de control

366
00:15:28,909 --> 00:15:32,049
Pues nueva página, tabulador

367
00:15:32,049 --> 00:15:32,990
Nueva línea

368
00:15:32,990 --> 00:15:37,450
son caracteres de control, no son cosas que se vean con los ojos, ¿vale?

369
00:15:37,450 --> 00:15:40,330
El tabulador no lo vemos, el salto de línea no lo vemos,

370
00:15:41,049 --> 00:15:43,450
pero aunque no lo veamos está ahí codificado, lógicamente,

371
00:15:43,549 --> 00:15:46,409
porque el salto de línea tiene un efecto y el tabulador tiene un efecto,

372
00:15:46,549 --> 00:15:49,450
aunque físicamente no se vea, ¿vale?

373
00:15:49,529 --> 00:15:55,490
Pues los de control serían estos primeros de aquí, estos de aquí.

374
00:15:56,490 --> 00:16:02,669
Y luego tenemos los 32 primeros, ¿vale? Serían los de control.

375
00:16:02,990 --> 00:16:21,070
Y luego tenemos ya los que vemos con los ojos, los que se llaman imprimibles, que son estos de aquí, que veis aquí en negrita. Las mayúsculas, las minúsculas, los números, ¿vale? Veis que faltan un montón, pero bueno, eso ya lo solucionamos después.

376
00:16:21,070 --> 00:16:23,370
veis que no está la ñ por ejemplo

377
00:16:23,370 --> 00:16:26,350
hay muchos que no están

378
00:16:26,350 --> 00:16:27,450
los de otros alfabetos

379
00:16:27,450 --> 00:16:30,169
pero esta es la tabla ASTI de toda la vida

380
00:16:30,169 --> 00:16:32,070
entonces

381
00:16:32,070 --> 00:16:35,070
¿qué vemos en esta tabla?

382
00:16:36,009 --> 00:16:37,149
vemos en esta tabla

383
00:16:37,149 --> 00:16:38,429
que cada carácter

384
00:16:38,429 --> 00:16:41,450
tiene asociado

385
00:16:41,450 --> 00:16:42,250
un numerito

386
00:16:42,250 --> 00:16:44,309
¿veis?

387
00:16:45,610 --> 00:16:47,190
ese numerito ¿qué es?

388
00:16:47,330 --> 00:16:48,389
es precisamente

389
00:16:48,389 --> 00:16:50,470
su representación binaria

390
00:16:50,470 --> 00:17:19,710
¿Cómo se representa la A mayúscula internamente? Pues se representa internamente con el 65, que el 65 pues lo que sea en binario, será 32 más 16, ¿cuánto es? 48, pues no me cabe uno más, 64 más 1.

391
00:17:20,470 --> 00:17:24,589
64 es

392
00:17:24,589 --> 00:17:27,049
2 elevado a cuánto

393
00:17:27,049 --> 00:17:29,630
2 elevado a 4 es 32

394
00:17:29,630 --> 00:17:31,690
2 elevado a 5 es 64

395
00:17:31,690 --> 00:17:33,390
entonces sería

396
00:17:33,390 --> 00:17:35,930
un 1 aquí

397
00:17:35,930 --> 00:17:37,230
del primer dígito

398
00:17:37,230 --> 00:17:40,029
0, 1, 2, 3

399
00:17:40,029 --> 00:17:41,069
y 4

400
00:17:41,069 --> 00:17:42,569
y todo eso ceros

401
00:17:42,569 --> 00:17:51,430
y todo lo demás ceros

402
00:17:51,430 --> 00:17:53,589
1, 2, 3, 4

403
00:17:53,589 --> 00:17:54,990
5, 6, 7 y 8

404
00:17:54,990 --> 00:17:57,690
Bueno, eso, si no me he equivocado

405
00:17:57,690 --> 00:18:00,230
Es 65 en binario

406
00:18:00,230 --> 00:18:01,170
¿Vale?

407
00:18:06,690 --> 00:18:08,910
Pues así es como internamente

408
00:18:08,910 --> 00:18:10,130
Se representaría

409
00:18:10,130 --> 00:18:11,750
La A mayúscula

410
00:18:11,750 --> 00:18:13,569
No os da igual

411
00:18:13,569 --> 00:18:15,130
La representación binaria no os da lo mismo

412
00:18:15,130 --> 00:18:17,430
Me da igual si me he equivocado

413
00:18:17,430 --> 00:18:19,470
El 1 va más a la izquierda

414
00:18:19,470 --> 00:18:21,009
Me da lo mismo

415
00:18:21,009 --> 00:18:23,230
Es que de hecho creo que me he equivocado

416
00:18:23,230 --> 00:18:24,309
Porque esto es

417
00:18:24,309 --> 00:18:26,549
claro, es más a la izquierda

418
00:18:26,549 --> 00:18:27,490
es que este es pequeñísimo

419
00:18:27,490 --> 00:18:30,549
vale, este sería

420
00:18:30,549 --> 00:18:32,589
vale, es que ya lo veía yo

421
00:18:32,589 --> 00:18:33,930
el 1 muy pequeñito

422
00:18:33,930 --> 00:18:36,269
vale, pues esta es la expresión binaria

423
00:18:36,269 --> 00:18:38,769
que nos da un poco igual

424
00:18:38,769 --> 00:18:40,130
saber pasar a binario

425
00:18:40,130 --> 00:18:42,650
no nos importa nada, es cultura general de informática

426
00:18:42,650 --> 00:18:44,390
que aprendéis en sistemas, no nos importa

427
00:18:44,390 --> 00:18:46,710
vale, pero simplemente saber

428
00:18:46,710 --> 00:18:48,630
que este numerito

429
00:18:48,630 --> 00:18:50,849
de aquí representa

430
00:18:50,849 --> 00:18:52,970
si lo pasamos a binario

431
00:18:52,970 --> 00:18:54,609
cómo se codifica dentro de la máquina.

432
00:18:57,859 --> 00:19:01,619
Pero representa además algo mucho más útil para nosotros,

433
00:19:02,400 --> 00:19:08,819
que es que para Java los char y los int son intercambiables.

434
00:19:08,819 --> 00:19:13,240
Es decir, para Java el carácter A mayúscula, este,

435
00:19:14,900 --> 00:19:18,799
lo puedo escribir tanto como A mayúscula entre comillas simples,

436
00:19:19,559 --> 00:19:20,940
como con el 65.

437
00:19:20,940 --> 00:19:24,200
es decir, el numerito entero

438
00:19:24,200 --> 00:19:25,660
que está en la tabla

439
00:19:25,660 --> 00:19:27,779
y el carácter al que acompaña

440
00:19:27,779 --> 00:19:30,099
son perfectamente intercambiables

441
00:19:30,099 --> 00:19:34,059
y eso nos da unas posibilidades enormes

442
00:19:34,059 --> 00:19:37,440
para trabajar con textos

443
00:19:37,440 --> 00:19:38,539
¿vale? ahora lo vemos

444
00:19:38,539 --> 00:19:43,559
¿vale? luego quedémonos

445
00:19:43,559 --> 00:19:45,140
primero con esto

446
00:19:45,140 --> 00:19:47,960
que en la tabla ASCII hay una correspondencia

447
00:19:47,960 --> 00:19:49,359
única, universal

448
00:19:49,359 --> 00:19:52,380
entre carácter y un número

449
00:19:52,380 --> 00:19:53,960
que es su representación binaria

450
00:19:53,960 --> 00:19:55,220
común para todos

451
00:19:55,220 --> 00:19:58,299
y ahora nosotros cuando programamos

452
00:19:58,299 --> 00:20:00,480
en un lenguaje de programación, en concreto en Java

453
00:20:00,480 --> 00:20:02,839
me da igual referirme

454
00:20:02,839 --> 00:20:04,779
a un carácter como el carácter en sí

455
00:20:04,779 --> 00:20:06,700
con copias simples que como con el número

456
00:20:06,700 --> 00:20:08,359
que acompaña, me da igual

457
00:20:08,359 --> 00:20:10,319
a Java le da lo mismo

458
00:20:10,319 --> 00:20:19,660
vamos a verlo

459
00:20:19,660 --> 00:20:22,279
a ver, esto, estamos aquí

460
00:20:22,279 --> 00:20:25,880
vale, yo aquí he puesto el char 8

461
00:20:25,880 --> 00:20:27,940
de hecho yo ahora lo imprimo

462
00:20:27,940 --> 00:20:30,400
carácter

463
00:20:30,400 --> 00:20:35,940
me va a salir después

464
00:20:35,940 --> 00:20:45,700
de precio con IVA y me sale el carácter. Para no confundirlo, haber elegido un número

465
00:20:45,700 --> 00:20:57,359
ya es liarla, voy a elegir el K. El carácter K minúscula. Yo ejecuto esto y aquí me sale

466
00:20:57,359 --> 00:21:08,910
el carácter K minúscula. Vale, perfectamente. Ahora yo a carácter le voy a asignar, por

467
00:21:08,910 --> 00:21:18,890
ejemplo, 69. Anda, pues también se lo ha tragado. Y esto no es un carácter entre comillas

468
00:21:18,890 --> 00:21:24,470
simples, ¿vale? Que yo he dicho que en Java los caracteres se expresan como el carácter

469
00:21:24,470 --> 00:21:32,809
que yo quiera, entre comillas simples. Pues aquí a un char le da un número entero. Y

470
00:21:32,809 --> 00:21:44,049
Y eso está tranquilo, porque, por lo que he dicho antes, para Java, el carácter en sí y el número al que acompaña son perfectamente intercambiables.

471
00:21:46,569 --> 00:21:55,710
Entonces, yo ahora aquí imprimo otra vez carácter y a ver qué me sale.

472
00:21:58,559 --> 00:22:00,240
¿Me sale la E mayúscula?

473
00:22:01,940 --> 00:22:05,960
Va a ser que la E mayúscula es la que está colocada en el 69.

474
00:22:06,460 --> 00:22:16,190
Va a ser, vamos a ver, pues efectivamente, la E mayúscula estaba colocada aquí.

475
00:22:31,319 --> 00:22:38,039
Entonces, desde el momento en que yo puedo trabajar con caracteres como los números a los que acompañan,

476
00:22:39,099 --> 00:22:44,960
pues se me abre una posibilidad bastante chuli, que es operar con caracteres.

477
00:22:45,680 --> 00:22:51,240
Si cada carácter tiene asociado un número, pues yo podría hacer sumas, ¿no?

478
00:22:51,240 --> 00:22:52,400
Porque tiene asociado un número.

479
00:22:53,740 --> 00:22:55,460
Pues sí, podría hacer sumas.

480
00:22:56,920 --> 00:23:13,490
Por ejemplo, voy a hacer ahora, carácter 2, voy a declarar un carácter 2, char carácter 2, ¿vale?

481
00:23:14,390 --> 00:23:18,660
Igual a h.

482
00:23:20,079 --> 00:23:20,720
Vale.

483
00:23:20,720 --> 00:23:26,589
y ahora a carácter

484
00:23:26,589 --> 00:23:28,670
la variable de arriba

485
00:23:28,670 --> 00:23:29,630
le voy a asignar

486
00:23:29,630 --> 00:23:32,329
el carácter 2

487
00:23:32,329 --> 00:23:35,940
más

488
00:23:35,940 --> 00:23:37,839
10

489
00:23:37,839 --> 00:23:40,339
¿vale?

490
00:23:42,829 --> 00:23:43,549
entonces

491
00:23:43,549 --> 00:23:45,809
me sale un error de compilación

492
00:23:45,809 --> 00:23:47,910
¿vale? entonces

493
00:23:47,910 --> 00:23:49,349
primera cosa, ya que hemos quedado

494
00:23:49,349 --> 00:23:52,210
no acabamos de decir que

495
00:23:52,210 --> 00:23:54,390
los char tienen un número

496
00:23:54,390 --> 00:23:55,069
asociado

497
00:23:55,069 --> 00:23:58,130
entonces puedo sumarlos

498
00:23:58,130 --> 00:23:59,410
multiplicarlos

499
00:23:59,410 --> 00:24:01,970
perdón, multiplicarlos

500
00:24:01,970 --> 00:24:03,490
bueno, podría, pero para qué quiero hacer eso

501
00:24:03,490 --> 00:24:05,630
normalmente yo quiero para bajar

502
00:24:05,630 --> 00:24:08,049
puedo sumarlos, restarlos

503
00:24:08,049 --> 00:24:10,369
aquí no he podido sumarle

504
00:24:10,369 --> 00:24:11,349
a una cosa

505
00:24:11,349 --> 00:24:13,470
claro, pero porque aquí

506
00:24:13,470 --> 00:24:15,170
aquí estoy mezclando tipos

507
00:24:15,170 --> 00:24:18,150
estoy mezclando tipos, cuidado

508
00:24:18,150 --> 00:24:20,130
estoy mezclando tipos

509
00:24:20,130 --> 00:24:21,930
aquí no estoy sumando char

510
00:24:21,930 --> 00:24:22,630
entre sí

511
00:24:22,630 --> 00:24:24,329
¿por qué?

512
00:24:24,430 --> 00:24:26,690
que he dicho yo antes al principio de la clase

513
00:24:26,690 --> 00:24:28,569
que cuando a Java

514
00:24:28,569 --> 00:24:30,910
tú le sueltas un número, así plantado

515
00:24:30,910 --> 00:24:32,589
para hacer algo con él, le suelto el 10

516
00:24:32,589 --> 00:24:34,650
él automáticamente

517
00:24:34,650 --> 00:24:36,369
interpreta

518
00:24:36,369 --> 00:24:38,789
que esto es un int

519
00:24:38,789 --> 00:24:40,589
y te lo guarda

520
00:24:40,589 --> 00:24:42,109
en 32 bits

521
00:24:42,109 --> 00:24:44,150
como si fuera un numerito el 10

522
00:24:44,150 --> 00:24:45,589
¿vale?

523
00:24:46,210 --> 00:24:48,049
entonces por eso no me deja

524
00:24:48,049 --> 00:24:49,690
porque me dice, estás mezclando

525
00:24:49,690 --> 00:24:52,269
un int con un char

526
00:24:52,269 --> 00:24:54,329
bueno, no, perdón, esto lo acabo de decir

527
00:24:54,329 --> 00:24:55,490
no está bien

528
00:24:55,490 --> 00:24:58,589
o sea, si me deja hacer la suma

529
00:24:58,589 --> 00:25:00,250
a carácter le puede sumar

530
00:25:00,250 --> 00:25:02,930
el 10, porque carácter tiene un número

531
00:25:02,930 --> 00:25:04,710
carácter dentro

532
00:25:04,710 --> 00:25:06,490
tiene un número, vamos a ver qué numerito tiene

533
00:25:06,490 --> 00:25:08,750
vamos a ver

534
00:25:08,750 --> 00:25:10,109
la h minúscula

535
00:25:10,109 --> 00:25:11,730
qué numerito tiene

536
00:25:11,730 --> 00:25:14,369
la h minúscula tiene el 104

537
00:25:14,369 --> 00:25:17,940
vamos a ponerlo aquí

538
00:25:17,940 --> 00:25:20,000
¿vale?

539
00:25:21,380 --> 00:25:21,900
entonces

540
00:25:21,900 --> 00:25:44,960
Esta operación, en realidad, él internamente sí la puede hacer. Estará sumando el 104, este que me habéis dicho, estará sumando el 104, lo estará sumando con el 10, esto sí, y le habrá salido 114.

541
00:25:44,960 --> 00:25:48,380
La suma sí que puede hacerla

542
00:25:48,380 --> 00:25:49,920
Porque hemos dicho que un char

543
00:25:49,920 --> 00:25:52,740
Es tanto el propio char

544
00:25:52,740 --> 00:25:53,839
Como el número que representa

545
00:25:53,839 --> 00:25:55,700
¿Dónde ha llegado el problema?

546
00:25:55,960 --> 00:25:59,000
Que al mezclar char con int

547
00:25:59,000 --> 00:26:02,500
Al igual que al mezclar

548
00:26:02,500 --> 00:26:04,019
Float con dabble

549
00:26:04,019 --> 00:26:05,440
Convertía en dabble

550
00:26:05,440 --> 00:26:07,640
Al mezclar int con long

551
00:26:07,640 --> 00:26:08,880
Convertía en long

552
00:26:08,880 --> 00:26:10,240
Los ejemplos que hemos visto

553
00:26:10,240 --> 00:26:12,500
Pues al mezclar char con int

554
00:26:12,500 --> 00:26:14,240
Lo convierte al tipo más grande

555
00:26:14,240 --> 00:26:16,180
char es más pequeñito

556
00:26:16,180 --> 00:26:18,539
int en 32, lo convierte a int

557
00:26:18,539 --> 00:26:20,880
entonces al mezclar char con int

558
00:26:20,880 --> 00:26:21,839
esto

559
00:26:21,839 --> 00:26:24,640
lo interpreta como

560
00:26:24,640 --> 00:26:25,619
numerito int

561
00:26:25,619 --> 00:26:28,960
y ahora ya sí que llega la incompatibilidad

562
00:26:28,960 --> 00:26:30,500
de tipos, me dice

563
00:26:30,500 --> 00:26:32,740
oye, no puedo asignar int

564
00:26:32,740 --> 00:26:34,720
a char, porque carácter

565
00:26:34,720 --> 00:26:35,160
es char

566
00:26:35,160 --> 00:26:47,819
vale, hasta aquí vale

567
00:26:47,819 --> 00:26:48,880
¿por qué sale este error?

568
00:26:50,599 --> 00:26:51,839
porque esto es un poco

569
00:26:51,839 --> 00:26:53,700
rollo, hasta que uno lo maneja

570
00:26:53,700 --> 00:26:55,119
completamente es un poco rollo

571
00:26:55,119 --> 00:26:57,380
sin embargo

572
00:26:57,380 --> 00:26:59,819
si le hubiéramos sumado a carácter

573
00:26:59,819 --> 00:27:01,440
2 en lugar de sumarle 10

574
00:27:01,440 --> 00:27:03,779
le hubiéramos sumado esto

575
00:27:03,779 --> 00:27:05,380
por ejemplo, vale

576
00:27:05,380 --> 00:27:07,240
carácter 2

577
00:27:07,240 --> 00:27:09,519
ah bueno, no, no, es que perdón

578
00:27:09,519 --> 00:27:11,619
da igual, porque la suma siempre la

579
00:27:11,619 --> 00:27:13,619
vale, en cuanto él se encuentra

580
00:27:13,619 --> 00:27:14,519
una suma

581
00:27:14,519 --> 00:27:17,579
vale, el operador

582
00:27:17,579 --> 00:27:19,480
suma siempre

583
00:27:19,480 --> 00:27:21,539
siempre implica que el

584
00:27:21,539 --> 00:27:23,680
resultado va a ser, lo va a guardar como número

585
00:27:23,680 --> 00:27:25,759
siempre, o sea el operador

586
00:27:25,759 --> 00:27:27,019
suma siempre

587
00:27:27,019 --> 00:27:29,680
lo interpreta como

588
00:27:29,680 --> 00:27:31,700
número, lo va a guardar como número

589
00:27:31,700 --> 00:27:33,519
¿vale? entonces

590
00:27:33,519 --> 00:27:35,079
¿para qué nos sirve sumar char?

591
00:27:35,720 --> 00:27:37,400
porque nosotros intuimos

592
00:27:37,400 --> 00:27:39,059
que nos debería servir para esto

593
00:27:39,059 --> 00:27:41,559
yo tengo el numerito de

594
00:27:41,559 --> 00:27:43,920
le sumo

595
00:27:43,920 --> 00:27:44,319
dos

596
00:27:44,319 --> 00:27:47,440
y me debería salir el f, intuimos

597
00:27:47,440 --> 00:27:49,380
que para eso sirve sumar a los char

598
00:27:49,380 --> 00:27:50,700
tiene toda la pinta

599
00:27:50,700 --> 00:27:54,000
tengo la D, le sumo 2 y voy a la F

600
00:27:54,000 --> 00:27:57,779
tengo la D, le sumo 10 y voy a la N

601
00:27:57,779 --> 00:28:00,160
tiene la pinta de que me serviría para eso

602
00:28:00,160 --> 00:28:01,980
pero jolines

603
00:28:01,980 --> 00:28:04,880
si no me está dejando el compilador

604
00:28:04,880 --> 00:28:07,140
porque se empeña, se empeña

605
00:28:07,140 --> 00:28:10,079
en cada vez que yo sumo

606
00:28:10,079 --> 00:28:11,940
char entre sí o char con int

607
00:28:11,940 --> 00:28:14,759
convertirlo a char, a int, perdón

608
00:28:14,759 --> 00:28:16,400
jolín

609
00:28:16,400 --> 00:28:18,680
¿de qué me sirve?

610
00:28:18,680 --> 00:28:21,640
bueno, pues es que aquí

611
00:28:21,640 --> 00:28:23,519
y aquí en este contexto

612
00:28:23,519 --> 00:28:25,779
sí que es uno en los cuales

613
00:28:25,779 --> 00:28:27,640
tenemos que usar el casting

614
00:28:27,640 --> 00:28:29,480
aquí sí, ¿vale?

615
00:28:30,099 --> 00:28:31,920
yo tengo mi char, carácter 2

616
00:28:31,920 --> 00:28:33,740
que sé que internamente es 104

617
00:28:33,740 --> 00:28:35,819
le sumo 2

618
00:28:35,819 --> 00:28:37,539
perfectamente puedo sumarlo

619
00:28:37,539 --> 00:28:39,319
104 más 2, 106

620
00:28:39,319 --> 00:28:41,319
me lo deja guardado como int

621
00:28:41,319 --> 00:28:43,700
pero yo ese 106 no quiero

622
00:28:43,700 --> 00:28:46,119
su versión int, de ese 106

623
00:28:46,119 --> 00:28:47,420
quiero su versión char

624
00:28:47,420 --> 00:28:50,420
quiero su versión char que es

625
00:28:50,420 --> 00:28:52,240
esta

626
00:28:52,240 --> 00:28:57,210
esta es su versión char

627
00:28:57,210 --> 00:28:58,730
de 106, vale

628
00:28:58,730 --> 00:29:01,069
entonces, para cambiar

629
00:29:01,069 --> 00:29:02,630
de la versión int

630
00:29:02,630 --> 00:29:04,670
a la versión char

631
00:29:04,670 --> 00:29:06,750
porque yo estoy trabajando con char

632
00:29:06,750 --> 00:29:08,849
y se me han pasado a int

633
00:29:08,849 --> 00:29:10,269
al hacer operaciones

634
00:29:10,269 --> 00:29:12,710
que al hacer operaciones te pasan a int

635
00:29:12,710 --> 00:29:15,049
ahí, en ese contexto

636
00:29:15,049 --> 00:29:16,509
es uno de los cuales sí

637
00:29:16,509 --> 00:29:18,789
podemos poner nuestro

638
00:29:18,789 --> 00:29:19,450
casting

639
00:29:19,450 --> 00:29:21,450
¿Vale?

640
00:29:22,170 --> 00:29:23,849
Repito, tengo el carácter 2

641
00:29:23,849 --> 00:29:24,730
Mi H

642
00:29:24,730 --> 00:29:26,750
O 104, es lo mismo

643
00:29:26,750 --> 00:29:28,450
Le sumo 2

644
00:29:28,450 --> 00:29:30,950
Que lo puedo hacer porque

645
00:29:30,950 --> 00:29:32,750
H es 104 en el fondo

646
00:29:32,750 --> 00:29:34,549
Le sumo 2, 106

647
00:29:34,549 --> 00:29:36,710
Me lo guarda como número

648
00:29:36,710 --> 00:29:39,250
No, perdona, como número

649
00:29:39,250 --> 00:29:41,450
No lo quiero, lo quiero en su versión

650
00:29:41,450 --> 00:29:43,589
Char, pues no pasa nada

651
00:29:43,589 --> 00:29:45,009
Le haces un casting

652
00:29:45,009 --> 00:29:47,839
¿Vale?

653
00:29:49,000 --> 00:29:50,420
Le haces un casting

654
00:29:50,420 --> 00:29:53,059
y en este caso tan feliz

655
00:29:53,059 --> 00:29:55,619
este es un caso controlado

656
00:29:55,619 --> 00:30:11,839
vamos a comprobar

657
00:30:11,839 --> 00:30:13,240
que efectivamente

658
00:30:13,240 --> 00:30:15,660
me imprime

659
00:30:15,660 --> 00:30:17,940
104 más 2

660
00:30:17,940 --> 00:30:19,259
que es 106

661
00:30:19,259 --> 00:30:22,140
y 106 es

662
00:30:22,140 --> 00:30:23,119
hemos dicho

663
00:30:23,119 --> 00:30:26,240
J

664
00:30:26,240 --> 00:30:29,779
vamos a comprobar que

665
00:30:29,779 --> 00:30:31,680
nos imprime J

666
00:30:31,680 --> 00:30:33,299
que es la versión char

667
00:30:33,299 --> 00:31:13,059
de 106, ¿vale? Aquí la tenemos, la J, la versión char de 106. Recopilamos hasta aquí, los char, las variables de tipo char

668
00:31:13,059 --> 00:31:24,109
sirven para guardar un único carácter. ¿Ese carácter cómo lo expreso? Pues lo puedo expresar como el carácter

669
00:31:24,109 --> 00:31:25,670
en particular

670
00:31:25,670 --> 00:31:27,450
con comillas simples

671
00:31:27,450 --> 00:31:29,569
o como el número

672
00:31:29,569 --> 00:31:32,250
que lo representa

673
00:31:32,250 --> 00:31:33,210
en la tabla ASCII

674
00:31:33,210 --> 00:31:34,829
me da igual una cosa que otra

675
00:31:34,829 --> 00:31:38,250
me da igual asignar 104 que asignar H

676
00:31:38,250 --> 00:31:39,750
es lo mismo

677
00:31:39,750 --> 00:31:40,470
al char

678
00:31:40,470 --> 00:31:42,369
es lo mismo

679
00:31:42,369 --> 00:31:45,410
entonces

680
00:31:45,410 --> 00:31:47,450
al tener el char

681
00:31:47,450 --> 00:31:50,190
una representación interna numérica

682
00:31:50,190 --> 00:31:52,089
que es lo que tiene una representación interna numérica

683
00:31:52,089 --> 00:31:53,390
puedo

684
00:31:53,390 --> 00:31:55,910
sumar y restar char, puedo operar con ellos

685
00:31:55,910 --> 00:31:59,349
pero cuidado

686
00:31:59,349 --> 00:32:01,769
porque al sumar char

687
00:32:01,769 --> 00:32:03,569
o a sumar char con un int

688
00:32:03,569 --> 00:32:04,329
o lo que yo quiera

689
00:32:04,329 --> 00:32:07,670
el resultado de esa operación

690
00:32:07,670 --> 00:32:09,150
Java lo va a guardar como int

691
00:32:09,150 --> 00:32:11,930
entonces, ¿hay algún problema en que lo guarde

692
00:32:11,930 --> 00:32:12,410
como int?

693
00:32:13,049 --> 00:32:16,069
no, el número está ahí, el número es 106

694
00:32:16,069 --> 00:32:16,910
ahí está el número

695
00:32:16,910 --> 00:32:18,990
pero al guardarlo como int

696
00:32:18,990 --> 00:32:22,009
cuando yo le hago la asignación a char

697
00:32:22,009 --> 00:32:23,470
la máquina virtual me dice

698
00:32:23,470 --> 00:32:25,890
no puedo, int de 32

699
00:32:25,890 --> 00:32:27,470
no cabe en char del 16

700
00:32:27,470 --> 00:32:29,789
ahora decimos sobre la longitud de char

701
00:32:29,789 --> 00:32:31,089
no puedo, no puedo

702
00:32:31,089 --> 00:32:32,569
pero ojo

703
00:32:32,569 --> 00:32:35,430
yo quiero la interpretación char

704
00:32:35,430 --> 00:32:37,690
de 106, no quiero la int

705
00:32:37,690 --> 00:32:39,970
ningún problema

706
00:32:39,970 --> 00:32:42,049
casting

707
00:32:42,049 --> 00:32:42,910
y ahí la tenemos

708
00:32:42,910 --> 00:32:46,069
esto que era el 106

709
00:32:46,069 --> 00:32:46,589
en int

710
00:32:46,589 --> 00:32:49,509
ahora es el 106 pero en char

711
00:32:49,509 --> 00:32:53,289
Y eso en la tabla A si es el J que hemos visto

712
00:32:53,289 --> 00:33:09,279
Entonces operar con char es muy útil en realidad

713
00:33:09,279 --> 00:33:13,160
Para cosas como por ejemplo, pues lo típico

714
00:33:13,160 --> 00:33:18,019
Yo quiero pasar de mayúscula a minúscula

715
00:33:18,019 --> 00:33:22,160
Pues como tenemos la suerte de que las letras están todas en orden

716
00:33:22,160 --> 00:33:24,779
Primero las mayúsculas del alfabeto

717
00:33:24,779 --> 00:33:27,539
Aquí las minúsculas desde la A

718
00:33:27,539 --> 00:33:36,539
Pues entre las mayúsculas y las minúsculas hay una diferencia neta de 97 menos 65 que es 32, ¿verdad?

719
00:33:37,380 --> 00:33:43,539
Entonces b más 32 es b minúscula, d menos 32 es d mayúscula.

720
00:33:44,759 --> 00:33:52,460
Entonces una forma fácil de pasar de minúsculas a mayúsculas es restando o sumando 32.

721
00:33:52,460 --> 00:33:57,460
Por ejemplo, vamos a pasar carácter 2 a mayúscula.

722
00:33:58,339 --> 00:34:25,489
Pues venga, mi carácter 2 mayúscula ahora va a ser el carácter 2 antiguo menos 32, hemos dicho, ¿no?

723
00:34:26,070 --> 00:34:35,900
Y con el problema de que esto me lo convierte en int, pues no pasa nada a achar.

724
00:34:35,900 --> 00:35:03,530
Y aquí, cuidado, es la primera vez que hemos incorporado una expresión que se use la variable que va a recibir el valor dentro de la propia expresión.

725
00:35:04,269 --> 00:35:06,389
Es la primera vez que lo hemos usado.

726
00:35:06,389 --> 00:35:09,750
entonces normalmente una variable

727
00:35:09,750 --> 00:35:11,769
le asignábamos un valor

728
00:35:11,769 --> 00:35:13,690
relacionado con

729
00:35:13,690 --> 00:35:15,730
otra variable multiplicada o restada

730
00:35:15,730 --> 00:35:17,929
o lo que fuera, aquí estamos usando

731
00:35:17,929 --> 00:35:19,429
la propia variable

732
00:35:19,429 --> 00:35:21,710
a la que asignamos valor, la propia

733
00:35:21,710 --> 00:35:22,829
dentro de la expresión

734
00:35:22,829 --> 00:35:24,789
es grave, pasa algo

735
00:35:24,789 --> 00:35:27,710
lo que está ocurriendo es que

736
00:35:27,710 --> 00:35:29,789
para evaluar esta

737
00:35:29,789 --> 00:35:30,409
expresión

738
00:35:30,409 --> 00:35:34,289
primero evaluamos la expresión

739
00:35:34,289 --> 00:35:37,250
bueno, la máquina virtual de Java

740
00:35:37,250 --> 00:35:43,869
la evalúa usando el valor de carácter 2, el que sea. La evalúa y cuando ya tiene el

741
00:35:43,869 --> 00:35:51,449
resultado final, lo guarda en carácter 2, con lo cual sobrescribe, pisa el valor que

742
00:35:51,449 --> 00:35:58,150
tenía de antes. ¿Vale? No pasa nada. Es como si yo hago la expresión x igual a x

743
00:35:58,150 --> 00:36:08,050
por 2. Entonces yo tengo mi variable x, que tiene un numerito. Lo primero que hace la

744
00:36:08,050 --> 00:36:15,550
máquina virtual al encontrarse esta sentencia, lo primero, evalúa la expresión. x que tiene

745
00:36:15,550 --> 00:36:22,730
x, 7, 7 por 2, 14, muy bien, ya tengo el 14 ahí esperando para hacer algo con él. Ahora,

746
00:36:22,730 --> 00:36:23,789
¿A qué hago con el 14?

747
00:36:24,110 --> 00:36:25,070
Toca asignar.

748
00:36:25,150 --> 00:36:26,030
¿A quién se lo asigno?

749
00:36:26,110 --> 00:36:26,650
A X.

750
00:36:27,269 --> 00:36:31,289
El 7 de antes, sobrescrito, y nos quedamos con el 14.

751
00:36:32,369 --> 00:36:32,949
No pasa nada.

752
00:36:34,110 --> 00:36:40,570
Puedo usar perfectamente la variable que va a recibir el valor en la expresión.

753
00:36:41,170 --> 00:36:41,710
No pasa nada.

754
00:36:42,449 --> 00:36:45,429
Lo que pasa es que el valor original desaparece.

755
00:36:46,210 --> 00:36:46,449
Vale.

756
00:36:46,690 --> 00:36:47,869
Pues ya está, ha desaparecido.

757
00:36:47,869 --> 00:36:52,550
Yo quería que esta variable multiplicara por 2 su valor, pues no he conseguido.

758
00:36:52,550 --> 00:36:53,670
lo ha multiplicado por 2

759
00:36:53,670 --> 00:36:55,309
no pasa nada

760
00:36:55,309 --> 00:36:56,869
¿vale?

761
00:36:58,650 --> 00:37:00,429
luego siempre podéis usar

762
00:37:00,429 --> 00:37:01,869
en una expresión

763
00:37:01,869 --> 00:37:04,690
cualquier variable, aunque sea la propia

764
00:37:04,690 --> 00:37:05,550
que va a recibir el valor

765
00:37:05,550 --> 00:37:08,349
lo que pasa es que una vez evaluada la expresión

766
00:37:08,349 --> 00:37:09,969
con el valor antiguo

767
00:37:09,969 --> 00:37:12,809
cuando se haga la asignación, que es lo último

768
00:37:12,809 --> 00:37:13,449
que se hace

769
00:37:13,449 --> 00:37:15,630
la asignación es lo último que se hace

770
00:37:15,630 --> 00:37:18,730
pues cuando se haga, el valor original

771
00:37:18,730 --> 00:37:21,070
ha desaparecido, se ha visto sobre escrito

772
00:37:21,070 --> 00:37:22,190
ya está, no pasa nada

773
00:37:22,190 --> 00:37:34,900
Bueno, pues aquí estoy haciendo lo mismo, carácter 2 lo estoy usando para hacer esta operación y el resultado final lo sobrescribo en carácter 2.

774
00:37:35,320 --> 00:37:49,079
Entonces, esto debería, si hemos hecho bien lo del 32, esto debería mostrarme lo que tuviera carácter 2 en mayúscula.

775
00:37:49,079 --> 00:37:51,539
carácter 2 tiene h

776
00:37:51,539 --> 00:37:54,920
si ejecutamos esto

777
00:37:54,920 --> 00:37:58,219
vale, pues efectivamente

778
00:37:58,219 --> 00:37:59,800
me lo muestra en mayúscula

779
00:37:59,800 --> 00:38:03,940
si le pongo la x

780
00:38:03,940 --> 00:38:09,119
carácter 2 menos 32

781
00:38:09,119 --> 00:38:13,320
pues efectivamente la x mayúscula

782
00:38:14,019 --> 00:38:14,480
dime

783
00:38:14,480 --> 00:38:20,480
pero has empezado de una minúscula

784
00:38:21,360 --> 00:38:23,340
y le has restado

785
00:38:23,340 --> 00:38:24,800
a ver si le has sumado

786
00:38:24,800 --> 00:38:26,320
o has empezado desde una mayúscula

787
00:38:26,320 --> 00:38:30,519
y la has sumado, tienes que restárselo

788
00:38:30,519 --> 00:38:37,739
bueno, es que puede que te salga un número

789
00:38:37,739 --> 00:38:38,780
porque ya te ha salido

790
00:38:38,780 --> 00:38:41,559
o sea, si tú, si yo

791
00:38:41,559 --> 00:38:43,039
a

792
00:38:43,039 --> 00:38:45,739
a cualquiera, bueno

793
00:38:45,739 --> 00:38:47,480
a la E

794
00:38:47,480 --> 00:38:49,719
le resto un valor

795
00:38:49,719 --> 00:38:51,880
él se viene hacia arriba y me saldrá

796
00:38:51,880 --> 00:38:52,400
este número

797
00:38:52,400 --> 00:38:55,940
o igual es que has sumado algo y te ha salido de la tabla

798
00:38:55,940 --> 00:38:58,079
no lo sé, pero vamos, lo que te haya salido

799
00:38:58,079 --> 00:38:58,960
¿qué operación has hecho?

800
00:39:03,119 --> 00:39:04,480
como carácter has puesto la B

801
00:39:04,480 --> 00:39:05,659
minúscula o mayúscula

802
00:39:05,659 --> 00:39:08,099
minúscula, vale, luego estamos en

803
00:39:08,099 --> 00:39:09,159
98

804
00:39:09,159 --> 00:39:16,230
y a 98

805
00:39:16,230 --> 00:39:17,010
le has sumado

806
00:39:17,010 --> 00:39:19,809
a la B le he sumado 10

807
00:39:19,809 --> 00:39:21,070
le has sumado 10

808
00:39:21,070 --> 00:39:23,670
bueno, pues si le sumamos 10

809
00:39:23,670 --> 00:39:25,590
te tendría que salir lo que hay en 108

810
00:39:25,590 --> 00:39:27,130
que es la L, minúscula

811
00:39:27,130 --> 00:39:29,329
pues entonces no has hecho eso

812
00:39:29,329 --> 00:39:30,929
seguro que sale un 1, a ver si es una L

813
00:39:30,929 --> 00:39:33,909
no estarás jugando el 1 con la L

814
00:39:33,909 --> 00:39:46,289
bueno, pues entonces yo os he enseñado

815
00:39:46,289 --> 00:39:47,730
esta tabla ASTI, ahí digo

816
00:39:47,730 --> 00:39:49,449
fijaos que cantidad de cosas

817
00:39:49,449 --> 00:39:52,150
podemos representar

818
00:39:52,150 --> 00:39:53,289
ya, pero si eres ruso

819
00:39:53,289 --> 00:39:56,030
pues estás fastidiado porque te faltan

820
00:39:56,030 --> 00:39:57,750
todos los caracteres, si no te digo si eres chino

821
00:39:57,750 --> 00:39:59,889
¿vale? te faltan ahí

822
00:39:59,889 --> 00:40:01,389
un montón

823
00:40:01,389 --> 00:40:03,829
de caracteres, hombre

824
00:40:03,829 --> 00:40:06,030
pues debería esto ser

825
00:40:06,030 --> 00:40:06,650
un poquito más

826
00:40:06,650 --> 00:40:09,489
pues entonces

827
00:40:09,489 --> 00:40:20,670
Aunque el ASCII es la codificación base que se originó para poder hacer compatibles unos editores de texto con otros

828
00:40:20,670 --> 00:40:23,050
Lógicamente se tuvo que ir ampliando

829
00:40:23,050 --> 00:40:27,349
¿Y cuál es la ampliación natural del ASCII?

830
00:40:28,789 --> 00:40:30,809
Pues el Unicode

831
00:40:30,809 --> 00:40:36,710
Y Unicode usa 16 bits

832
00:40:36,710 --> 00:40:48,199
Entonces, con unicode ya sí que podemos representar caracteres de, no sé si es de todos los idiomas del mundo, pero casi.

833
00:40:49,920 --> 00:40:59,420
Y tenemos la suerte de que Java internamente representa los char en 16 bits y en unicode.

834
00:41:00,000 --> 00:41:05,420
Con lo cual, en un char de Java podemos guardar cualquier carácter de unicode.

835
00:41:16,369 --> 00:41:42,429
Entonces, de hecho, vamos a experimentar un poco, porque Unicode ya es la leche, es muy amplio, tiene muchas cosas, entonces Unicode, si buscáis la página oficial de Unicode, pues te saca aquí, vamos, un montón de caracteres, de historias, de cómo se, fijaos qué cantidad de símbolos,

836
00:41:42,429 --> 00:41:44,610
vale

837
00:41:44,610 --> 00:41:48,539
de hecho

838
00:41:48,539 --> 00:41:50,500
esa es la documentación oficial

839
00:41:50,500 --> 00:41:52,659
creo, no, espérate

840
00:41:52,659 --> 00:41:54,980
esa es la página oficial de Unicode

841
00:41:54,980 --> 00:41:56,800
que te, claro

842
00:41:56,800 --> 00:41:59,099
aquí ver una tablita, sin más

843
00:41:59,099 --> 00:42:00,860
si buscáis página oficial

844
00:42:00,860 --> 00:42:02,280
de Unicode, pues os saldrá esto

845
00:42:02,280 --> 00:42:03,320
unicode.org

846
00:42:03,320 --> 00:42:06,820
aquí en una tablita no te los pueden mostrar todos

847
00:42:06,820 --> 00:42:08,599
porque es que ya son muchos, no son 127

848
00:42:08,599 --> 00:42:10,519
como así, son la leche

849
00:42:10,519 --> 00:42:12,619
entonces aquí están divididos por

850
00:42:12,619 --> 00:42:14,739
idiomas, por todo

851
00:42:14,739 --> 00:42:16,199
pues el dibes

852
00:42:16,199 --> 00:42:18,400
acuro este, yo que sé que es esto

853
00:42:18,400 --> 00:42:20,760
pero fijaos que símbolos

854
00:42:20,760 --> 00:42:21,559
tan raros tiene

855
00:42:21,559 --> 00:42:24,440
y todos estos son representables

856
00:42:24,440 --> 00:42:26,099
en unicode, vale

857
00:42:26,099 --> 00:42:29,079
uy perdón, perdón, perdón

858
00:42:29,079 --> 00:42:30,659
vale, pues lo que

859
00:42:30,659 --> 00:42:31,840
estaba yo mostrando era

860
00:42:31,840 --> 00:42:33,860
la página oficial

861
00:42:33,860 --> 00:42:35,719
unicode.org

862
00:42:35,719 --> 00:42:38,519
que una tablita única

863
00:42:38,519 --> 00:42:40,360
no te puede poner porque son la leche

864
00:42:40,360 --> 00:42:59,579
Entonces, este lo viene aquí dividido, pues eso, por idiomas y el kawi, pues no sé qué es, de Indonesia. Pues eso, fijaos qué simbolitos tiene tan monos. Todo esto es representable en un char de Java, porque el char tiene 16 bits.

865
00:42:59,579 --> 00:43:02,079
Entonces, esto de aquí

866
00:43:02,079 --> 00:43:04,159
Vamos a probar

867
00:43:04,159 --> 00:43:06,460
Esto puede que sea

868
00:43:06,460 --> 00:43:07,880
Que esté en hexadecimal

869
00:43:07,880 --> 00:43:09,980
¿Vale?

870
00:43:10,079 --> 00:43:11,659
Bueno, vamos a probar cosas, por ejemplo

871
00:43:11,659 --> 00:43:14,860
Vamos a en un char

872
00:43:14,860 --> 00:43:17,360
Le voy a llamar

873
00:43:17,360 --> 00:43:18,760
Carácter raro

874
00:43:18,760 --> 00:43:20,400
Porque es en el que vamos a hacer pruebitas

875
00:43:20,400 --> 00:43:22,380
Yo esto no lo he probado mucho

876
00:43:22,380 --> 00:43:24,579
Pero yo caracteres extraños, lógicamente, no uso

877
00:43:24,579 --> 00:43:26,639
Carácter raro

878
00:43:26,639 --> 00:43:28,860
Le vamos a dar, por ejemplo

879
00:43:28,860 --> 00:43:29,920
si yo le doy

880
00:43:29,920 --> 00:43:34,070
este

881
00:43:34,070 --> 00:43:37,789
me lo coge, llega un momento en que hay uno que ya no

882
00:43:37,789 --> 00:43:39,130
veis porque ya se sale

883
00:43:39,130 --> 00:43:41,329
de lo que cabe en 16 bits, ya se sale

884
00:43:41,329 --> 00:43:43,730
pero este me lo coge

885
00:43:43,730 --> 00:43:45,849
vamos a ver que carácter es este

886
00:43:45,849 --> 00:43:47,130
desde luego no es de la tabla ASCII

887
00:43:47,130 --> 00:43:49,769
no sabemos saber que carácter es esta cosa

888
00:43:49,769 --> 00:43:53,880
carácter raro

889
00:43:53,880 --> 00:43:58,039
entonces, carácter raro

890
00:43:58,039 --> 00:44:04,039
pues esta cosa es

891
00:44:04,039 --> 00:44:05,860
ese carácter es

892
00:44:05,860 --> 00:44:06,380
esa cosa

893
00:44:06,380 --> 00:44:11,210
Y si yo le pongo este

894
00:44:11,210 --> 00:44:12,909
Un, dos, tres, cuatro, cinco

895
00:44:12,909 --> 00:44:14,829
Este ya es muy grande, claro

896
00:44:14,829 --> 00:44:17,170
Si yo le pongo este

897
00:44:17,170 --> 00:44:18,989
Pues este, mira

898
00:44:18,989 --> 00:44:21,289
He dado con un chino, con un japonés

899
00:44:21,289 --> 00:44:22,949
Mira que guay

900
00:44:22,949 --> 00:44:24,809
Vale, pues es este

901
00:44:24,809 --> 00:44:27,150
Entonces

902
00:44:27,150 --> 00:44:29,349
Normalmente

903
00:44:29,349 --> 00:44:31,429
Los caracteres

904
00:44:31,429 --> 00:44:33,510
Como son sucesiones de bits

905
00:44:33,510 --> 00:44:36,230
Se suelen representar en hexadecimal

906
00:44:36,230 --> 00:44:37,869
¿Vale? Entonces, bueno, vamos a parar aquí

907
00:44:37,869 --> 00:44:38,530
Luego ya

908
00:44:38,530 --> 00:44:40,070
O sea, para aquí un segundo

909
00:44:40,070 --> 00:44:42,309
Antes de volvernos más locos