1
00:00:01,840 --> 00:00:12,800
Vale, pues este rollo de la asignación más o menos se ve más o menos claro.

2
00:00:13,259 --> 00:00:20,760
Luego ya iremos viendo como aquí donde yo he puesto valor, ahí pueden ir muchas cosas.

3
00:00:21,320 --> 00:00:26,219
Con tal de que puedan convertirse en un valor realmente, pues estupendo.

4
00:00:26,219 --> 00:00:28,539
y una variable

5
00:00:28,539 --> 00:00:30,120
se puede convertir en un valor

6
00:00:30,120 --> 00:00:32,299
como enseñando lo que tiene dentro

7
00:00:32,299 --> 00:00:34,219
tengo esto, para ti

8
00:00:34,219 --> 00:00:36,240
bueno, para ti yo

9
00:00:36,240 --> 00:00:38,320
conservo también, claro, te doy una copia

10
00:00:38,320 --> 00:00:40,479
vale, entonces

11
00:00:40,479 --> 00:00:42,280
ahora ya más o menos

12
00:00:42,280 --> 00:00:43,200
empezó a entender

13
00:00:43,200 --> 00:00:46,380
esto de aquí, ahora volvemos

14
00:00:46,380 --> 00:00:48,240
a lo que lo motivó, que es lo de

15
00:00:48,240 --> 00:00:50,299
que a una variable hay que

16
00:00:50,299 --> 00:00:52,179
asignarle valores del mismo tipo

17
00:00:52,179 --> 00:00:53,020
por principio

18
00:00:53,020 --> 00:00:56,100
claro, y aquí es donde vosotros me diríais

19
00:00:56,100 --> 00:00:59,320
pero vamos a ver

20
00:00:59,320 --> 00:01:03,590
edad

21
00:01:03,590 --> 00:01:05,370
es de tipo int

22
00:01:05,370 --> 00:01:07,629
porque así la hemos declarado

23
00:01:07,629 --> 00:01:10,150
edad es de tipo int

24
00:01:10,150 --> 00:01:13,909
y edad tocha está declarada

25
00:01:13,909 --> 00:01:14,530
como long

26
00:01:14,530 --> 00:01:17,590
¿cómo es que el compilador que es tan estricto

27
00:01:17,590 --> 00:01:19,989
que lleva su lista de reglas

28
00:01:19,989 --> 00:01:21,849
el valor tiene que ser del mismo

29
00:01:21,849 --> 00:01:22,790
tipo que la variable

30
00:01:22,790 --> 00:01:24,590
¿cómo es que aquí el compilador

31
00:01:24,590 --> 00:01:26,810
se ha puesto en rojo y no se ha quejado?

32
00:01:26,810 --> 00:01:29,349
porque ha hecho la promoción automática

33
00:01:29,349 --> 00:01:31,870
y eso siempre se puede hacer

34
00:01:31,870 --> 00:01:34,230
entre un número pequeñito

35
00:01:34,230 --> 00:01:35,469
que cabe en uno grande

36
00:01:35,469 --> 00:01:37,090
entonces edad es int

37
00:01:37,090 --> 00:01:39,879
int

38
00:01:39,879 --> 00:01:42,560
cabe en long

39
00:01:42,560 --> 00:01:44,739
int cabe en long

40
00:01:44,739 --> 00:01:46,200
porque es la mitad

41
00:01:46,200 --> 00:01:49,359
entonces el de este valor que había en int

42
00:01:49,359 --> 00:01:50,620
en edad

43
00:01:50,620 --> 00:01:53,140
que era el 78 o el que fuera

44
00:01:53,140 --> 00:01:55,540
hace la promoción

45
00:01:55,540 --> 00:01:56,239
automática

46
00:01:56,239 --> 00:02:08,189
y lo lleva

47
00:02:08,189 --> 00:02:09,189
a este de aquí

48
00:02:09,189 --> 00:02:14,060
porque no hay problema

49
00:02:14,060 --> 00:02:17,379
porque un int cabe en un log, entonces coge el 78

50
00:02:17,379 --> 00:02:19,080
y lo guarda aquí

51
00:02:19,080 --> 00:02:21,259
porque no hay problema, tendrá que poner muchos ceros

52
00:02:21,259 --> 00:02:23,259
en los bits a la izquierda, pero no pasa nada

53
00:02:23,259 --> 00:02:25,599
entonces el compilador

54
00:02:25,599 --> 00:02:27,659
te hace automáticamente

55
00:02:27,659 --> 00:02:28,860
la promoción automática

56
00:02:28,860 --> 00:02:33,439
y esto siempre lo va a poder

57
00:02:33,439 --> 00:02:35,340
hacer entre

58
00:02:35,340 --> 00:02:37,360
un byteusort, por ejemplo

59
00:02:37,360 --> 00:02:39,479
porque bytecaben sort, entre un byteunit

60
00:02:39,479 --> 00:02:41,180
entre un byte y un long

61
00:02:41,180 --> 00:02:42,759
no hay ningún problema

62
00:02:42,759 --> 00:02:45,879
ojo, cuidado

63
00:02:45,879 --> 00:02:47,900
¿significa esto

64
00:02:47,900 --> 00:02:50,139
que lo que ha promocionado

65
00:02:50,139 --> 00:02:52,219
es la variable edad y de repente se ha hecho así

66
00:02:52,219 --> 00:02:53,599
de grande? no

67
00:02:53,599 --> 00:02:56,860
la variable edad sigue siendo int con 32 bits

68
00:02:56,860 --> 00:02:58,300
la promoción

69
00:02:58,300 --> 00:02:59,780
se ha hecho del valor solo

70
00:02:59,780 --> 00:03:02,060
la variable edad

71
00:03:02,060 --> 00:03:04,000
ha dado su valor que es el 78

72
00:03:04,000 --> 00:03:06,000
y la máquina virtual

73
00:03:06,000 --> 00:03:08,159
ha estirado el 78

74
00:03:08,159 --> 00:03:11,099
hasta la caja edad tocha

75
00:03:11,099 --> 00:03:11,819
lo ha estirado

76
00:03:11,819 --> 00:03:15,020
pero la variable edad sigue teniendo su 32

77
00:03:15,020 --> 00:03:16,919
y este su 64

78
00:03:16,919 --> 00:03:17,759
no ha cambiado

79
00:03:17,759 --> 00:03:22,509
el inverso

80
00:03:22,509 --> 00:03:24,789
el compilador ya no te dejaría

81
00:03:24,789 --> 00:03:27,710
si hacemos la asignación al revés

82
00:03:27,710 --> 00:03:30,389
que es

83
00:03:30,389 --> 00:03:33,389
a la variable edad

84
00:03:33,389 --> 00:03:36,729
le voy a asignar

85
00:03:36,729 --> 00:03:39,330
lo que tenga dentro edad tocha

86
00:03:39,330 --> 00:03:42,389
Aquí el compilador

87
00:03:42,389 --> 00:03:43,509
Ya sí que

88
00:03:43,509 --> 00:03:45,590
Uy

89
00:03:45,590 --> 00:03:48,030
Efectivamente

90
00:03:48,030 --> 00:03:59,919
Bueno, tendría que ir por aquí

91
00:03:59,919 --> 00:04:04,419
Vale

92
00:04:04,419 --> 00:04:06,580
Aquí el compilador ya sí que se ha quejado

93
00:04:06,580 --> 00:04:08,240
Porque dice, ojo

94
00:04:08,240 --> 00:04:10,259
Era tocha

95
00:04:10,259 --> 00:04:12,080
No sé qué número tiene

96
00:04:12,080 --> 00:04:14,500
Pero podría ocurrir que tuviera un número muy tocho

97
00:04:14,500 --> 00:04:15,599
Podría ocurrir

98
00:04:15,599 --> 00:04:18,959
Y entonces no te dejo

99
00:04:18,959 --> 00:04:20,100
No te dejo

100
00:04:20,100 --> 00:04:22,720
a lo mejor ni siquiera habría problema

101
00:04:22,720 --> 00:04:24,879
porque podría darse esta situación

102
00:04:24,879 --> 00:04:27,240
podría darse la situación

103
00:04:27,240 --> 00:04:30,800
de que edad tocha

104
00:04:30,800 --> 00:04:32,939
sí, es una caja enorme

105
00:04:32,939 --> 00:04:34,980
pero a lo mejor tiene el numerito 7

106
00:04:34,980 --> 00:04:35,819
solo, ¿por qué no?

107
00:04:35,819 --> 00:04:36,759
tiene el numerito 7

108
00:04:36,759 --> 00:04:40,279
y edad es la caja más pequeñita

109
00:04:40,279 --> 00:04:43,019
entonces podría ocurrir

110
00:04:43,019 --> 00:04:46,060
que el numerito que tiene esta variable

111
00:04:46,060 --> 00:04:47,000
cupiera aquí

112
00:04:47,000 --> 00:04:48,980
pero eso el compilador no lo sabe

113
00:04:48,980 --> 00:04:50,579
el compilador aplica sus reglas

114
00:04:50,579 --> 00:04:52,920
luego ya cada ejecución

115
00:04:52,920 --> 00:04:54,060
tendrá los valores que tenga

116
00:04:54,060 --> 00:04:56,040
entonces él aplica sus reglas

117
00:04:56,040 --> 00:04:58,839
para que sean los valores que sean

118
00:04:58,839 --> 00:04:59,920
siempre funcione

119
00:04:59,920 --> 00:05:02,560
entonces él te dice, a ver, edad tocha

120
00:05:02,560 --> 00:05:04,300
sé que es una caja muy grande

121
00:05:04,300 --> 00:05:06,600
con lo cual no sé qué valor tiene

122
00:05:06,600 --> 00:05:08,560
pues dependerá de la ejecución

123
00:05:08,560 --> 00:05:10,139
el valor que te meta el usuario, lo que sea

124
00:05:10,139 --> 00:05:12,459
pero podría ocurrir perfectamente

125
00:05:12,459 --> 00:05:13,920
que el numerito no quepa aquí

126
00:05:13,920 --> 00:05:16,459
podría ocurrir, con lo cual ya

127
00:05:16,459 --> 00:05:18,660
desde el tiempo de compilación y de escritura

128
00:05:18,660 --> 00:05:20,899
de código ya desde ahí te prohíbe

129
00:05:20,899 --> 00:05:22,839
te prohíbe ya ejecutar

130
00:05:22,839 --> 00:05:24,519
eso porque se podría generar un error

131
00:05:24,519 --> 00:05:26,180
gordo que es perder la información

132
00:05:26,180 --> 00:05:27,660
si tú cortas

133
00:05:27,660 --> 00:05:29,480
perder la información

134
00:05:29,480 --> 00:05:32,779
entonces la promoción

135
00:05:32,779 --> 00:05:34,899
se hace de variables

136
00:05:34,899 --> 00:05:36,899
más pequeñas

137
00:05:36,899 --> 00:05:38,259
a otras más grandes

138
00:05:38,259 --> 00:05:39,920
porque no se pierde información

139
00:05:39,920 --> 00:05:41,920
no se pierde, lo único que tienes que hacer es

140
00:05:41,920 --> 00:05:43,759
añadir ceros a la izquierda

141
00:05:43,759 --> 00:05:46,519
lo único que hace la máquina virtual es añadir ceros a la izquierda

142
00:05:46,519 --> 00:05:48,300
pero al revés

143
00:05:48,300 --> 00:05:52,019
de una variable grande a otra más pequeña

144
00:05:52,019 --> 00:05:53,600
esa no se puede hacer

145
00:05:53,600 --> 00:05:55,379
el compilador te dice

146
00:05:55,379 --> 00:05:56,420
eso no te dejo hacerlo

147
00:05:56,420 --> 00:05:59,439
aunque podría haber ejecuciones

148
00:05:59,439 --> 00:06:00,899
en las que no pasaría nada

149
00:06:00,899 --> 00:06:02,699
si no pasaría nada si tiene 7

150
00:06:02,699 --> 00:06:04,600
pero si tiene 200.000 millones

151
00:06:04,600 --> 00:06:06,100
ahí si pasaría

152
00:06:06,100 --> 00:06:11,240
luego

153
00:06:11,240 --> 00:06:16,459
recopilando en general

154
00:06:16,459 --> 00:06:18,920
no olvidemos ya esta sentencia

155
00:06:18,920 --> 00:06:20,379
¿vale? la sentencia

156
00:06:20,379 --> 00:06:22,360
ahora ya conocemos por decirlo así

157
00:06:22,360 --> 00:06:23,839
sentencias para

158
00:06:23,839 --> 00:06:25,519
declarar una variable

159
00:06:25,519 --> 00:06:28,360
tipo de dato, nombre de variable, punto y coma

160
00:06:28,360 --> 00:06:30,519
los diferentes matices

161
00:06:30,519 --> 00:06:32,620
y cosas que se pueden incorporar y lo vamos incorporando

162
00:06:32,620 --> 00:06:33,699
son programas

163
00:06:33,699 --> 00:06:36,139
declaración de una variable, ya la sabemos

164
00:06:36,139 --> 00:06:39,079
asignar valor a una variable

165
00:06:39,079 --> 00:06:40,839
porque una variable la declaramos

166
00:06:40,839 --> 00:06:43,019
es decir, creamos espacio en memoria

167
00:06:43,019 --> 00:06:44,319
para meter datos en ella

168
00:06:44,319 --> 00:06:45,279
porque si no, ¿para qué lo hacemos?

169
00:06:45,800 --> 00:06:47,759
bueno, pues asignar valor a una variable

170
00:06:47,759 --> 00:06:49,279
es una sentencia que ya conocemos

171
00:06:49,279 --> 00:06:50,379
esta

172
00:06:50,379 --> 00:06:53,899
y ya empezamos a tener en la cabeza

173
00:06:53,899 --> 00:06:57,660
algunas cuestiones básicas sobre la asignación

174
00:06:57,660 --> 00:07:00,060
no todas, pero algunas básicas

175
00:07:00,060 --> 00:07:03,300
como que el valor por lo general

176
00:07:03,300 --> 00:07:05,899
tiene que ser del mismo tipo que el de la variable

177
00:07:05,899 --> 00:07:09,699
salvo estos matices que nos han ido surgiendo

178
00:07:09,699 --> 00:07:12,199
que si lo que yo le asigno

179
00:07:12,199 --> 00:07:15,839
es una variable de 8, 32

180
00:07:15,839 --> 00:07:17,579
y cabe en la otra

181
00:07:17,579 --> 00:07:19,720
No pasa nada, el compilador te deja

182
00:07:19,720 --> 00:07:22,139
Porque sabe que la máquina virtual lo estirará con ceros

183
00:07:22,139 --> 00:07:23,600
Si es al revés, no

184
00:07:23,600 --> 00:07:24,560
No te va a dejar

185
00:07:24,560 --> 00:07:27,879
Esos pequeños matices que hemos incorporado

186
00:07:27,879 --> 00:07:31,160
Bueno, pues

187
00:07:31,160 --> 00:07:33,439
Más o menos

188
00:07:33,439 --> 00:07:35,259
Vamos a

189
00:07:35,259 --> 00:07:37,959
Pasar al char

190
00:07:37,959 --> 00:07:39,439
¿Vale? Que teníamos

191
00:07:39,439 --> 00:07:43,660
Aquí

192
00:07:43,660 --> 00:07:47,529
Bueno, sobre números enteros

193
00:07:47,529 --> 00:07:48,810
Sobre números enteros

194
00:07:48,810 --> 00:07:51,889
Salvo las posibles operaciones con números enteros

195
00:07:51,889 --> 00:07:53,930
A lo cual tendremos que ver los operadores

196
00:07:53,930 --> 00:07:55,009
Y todo eso que no hemos visto

197
00:07:55,009 --> 00:07:57,829
Pues crear variables enteras

198
00:07:57,829 --> 00:07:59,649
Y crearlas

199
00:07:59,649 --> 00:08:01,829
Y asignarles valor correctamente

200
00:08:01,829 --> 00:08:03,870
Pues más o menos

201
00:08:03,870 --> 00:08:04,689
Sabemos

202
00:08:04,689 --> 00:08:07,709
Los de los doubles

203
00:08:07,709 --> 00:08:09,129
Todavía no los hemos tocado

204
00:08:09,129 --> 00:08:10,769
El char

205
00:08:10,769 --> 00:08:13,750
Meto el char ahora porque se relaciona

206
00:08:13,750 --> 00:08:15,350
Muy íntimamente con los enteros

207
00:08:15,350 --> 00:08:17,370
Aunque no lo parezca, se relaciona muy íntimamente

208
00:08:17,370 --> 00:08:18,329
Vale

209
00:08:18,329 --> 00:08:23,060
Venga, pues vamos al char

210
00:08:23,060 --> 00:08:29,399
¿cuándo declaramos una variable char?

211
00:08:30,420 --> 00:08:31,680
cuando yo necesito

212
00:08:31,680 --> 00:08:33,639
almacenar un carácter

213
00:08:33,639 --> 00:08:35,419
un carácter

214
00:08:35,419 --> 00:08:37,399
a, j, h, dólar

215
00:08:37,399 --> 00:08:38,879
almohadilla, un carácter

216
00:08:38,879 --> 00:08:41,539
que puede ocurrir que yo necesito almacenar un carácter

217
00:08:41,539 --> 00:08:43,720
de hecho cuando queramos almacenar

218
00:08:43,720 --> 00:08:44,700
texto, nombres

219
00:08:44,700 --> 00:08:46,960
necesitaremos mucho char

220
00:08:46,960 --> 00:08:48,179
¿vale?

221
00:08:48,179 --> 00:08:50,399
¿cuál es el carácter de la tabla?

222
00:08:51,580 --> 00:08:53,039
cualquier carácter de la tabla

223
00:08:53,039 --> 00:08:54,220
no, el 1

224
00:08:54,220 --> 00:08:55,659
también es un carácter válido

225
00:08:55,659 --> 00:08:59,580
cualquier carácter de los que están en la tabla ASCII,

226
00:08:59,720 --> 00:09:02,700
que son los caracteres que reconocen los editores de texto.

227
00:09:03,559 --> 00:09:03,820
¿Vale?

228
00:09:04,019 --> 00:09:11,559
Entonces, no, un carácter solo y de cualquiera de los de esta tabla.

229
00:09:12,340 --> 00:09:17,570
Si volvemos a nuestra tabla ASCII,

230
00:09:21,120 --> 00:09:22,740
esta es la tabla ASCII,

231
00:09:25,700 --> 00:09:28,700
esta tiene 800.000 caracteres.

232
00:09:28,700 --> 00:09:31,220
todos estos

233
00:09:31,220 --> 00:09:33,440
como veis están los números también

234
00:09:33,440 --> 00:09:35,759
son caracteres, todos estos, todos estos

235
00:09:35,759 --> 00:09:36,779
todos estos

236
00:09:36,779 --> 00:09:39,480
tropecientos mil caracteres tienen

237
00:09:39,480 --> 00:09:40,539
muchos caracteres

238
00:09:40,539 --> 00:09:42,460
entonces

239
00:09:42,460 --> 00:09:45,379
estos son los caracteres

240
00:09:45,379 --> 00:09:47,740
que los editores de texto

241
00:09:47,740 --> 00:09:49,720
reconocen, tú puedes escribir

242
00:09:49,720 --> 00:09:51,720
todos esos caracteres, tú puedes escribir todo esto

243
00:09:51,720 --> 00:09:53,639
en un editor de texto y hacerte un texto maravilloso

244
00:09:53,639 --> 00:09:55,419
con esos caracteres

245
00:09:55,419 --> 00:09:57,539
¿vale?

246
00:09:57,539 --> 00:10:14,059
Entonces, los editores de texto, cuando tú escribes texto en ellos, lo que hacen es, cada uno de los caracteres que se van encontrando, lo codifican como una secuencia de 8 bits correspondiente a este numerito que está aquí.

247
00:10:15,080 --> 00:10:21,779
Aquí no aparece como los 8 bits, sino que aparece ya ese valor binario en entero, claro, porque si no, la tabla la estudiaría muy fea.

248
00:10:21,779 --> 00:10:24,340
entonces, que tú has escrito

249
00:10:24,340 --> 00:10:26,919
hola en el blog de notas

250
00:10:26,919 --> 00:10:28,779
en el WordPad, en cualquier editor

251
00:10:28,779 --> 00:10:30,740
de texto, editor, no procesador

252
00:10:30,740 --> 00:10:32,580
el procesador es un software

253
00:10:32,580 --> 00:10:34,879
que lleva su codificación interna al margen

254
00:10:34,879 --> 00:10:36,720
que tú escribes en un

255
00:10:36,720 --> 00:10:38,700
editor de texto, cualquiera, blog de

256
00:10:38,700 --> 00:10:40,220
notas, Notepad, el que sea

257
00:10:40,220 --> 00:10:42,200
escribes hola

258
00:10:42,200 --> 00:10:44,200
¿qué estás poniendo?

259
00:10:44,360 --> 00:10:46,659
una H, entonces, él lo que hace

260
00:10:46,659 --> 00:10:48,480
es coger el 104

261
00:10:48,480 --> 00:10:50,360
pasarlo a binario

262
00:10:50,360 --> 00:10:52,299
y plantarte ahí el 104 en binario

263
00:10:52,299 --> 00:10:53,860
la O

264
00:10:53,860 --> 00:10:56,440
coge el 111, lo pasa a binario

265
00:10:56,440 --> 00:10:58,639
y te pone ahí esos 8 bits

266
00:10:58,639 --> 00:11:00,440
después, la L

267
00:11:00,440 --> 00:11:01,700
coge el 108

268
00:11:01,700 --> 00:11:04,820
lo pasa a binario y te pone ahí los 8 bits

269
00:11:04,820 --> 00:11:06,379
después, y la A

270
00:11:06,379 --> 00:11:08,799
coge el 97, lo pasa a binario y te pone los 8 bits

271
00:11:08,799 --> 00:11:10,299
pues tú tienes ya ahí tus

272
00:11:10,299 --> 00:11:11,480
4 bytes

273
00:11:11,480 --> 00:11:14,600
que son la codificación binaria

274
00:11:14,600 --> 00:11:16,940
del carácter que tú has escrito según la tabla

275
00:11:16,940 --> 00:11:18,519
así, entonces como

276
00:11:18,519 --> 00:11:20,139
todos los editores de texto

277
00:11:20,139 --> 00:11:22,899
todos se han puesto de acuerdo

278
00:11:22,899 --> 00:11:24,679
en usar esta

279
00:11:24,679 --> 00:11:26,740
codificación, la de la tabla ASCII

280
00:11:26,740 --> 00:11:28,700
todos, da igual

281
00:11:28,700 --> 00:11:30,659
que tú escribas en un blog de notas

282
00:11:30,659 --> 00:11:32,659
un texto y luego

283
00:11:32,659 --> 00:11:34,659
lo hablas en otro editor distinto

284
00:11:34,659 --> 00:11:36,980
de otro Notepad, del que sea

285
00:11:36,980 --> 00:11:38,779
porque todos los editores

286
00:11:38,779 --> 00:11:40,159
de texto se han puesto de acuerdo

287
00:11:40,159 --> 00:11:42,100
para codificar en ASCII, todos

288
00:11:42,100 --> 00:11:44,600
entonces, si yo he escrito hola en el blog de notas

289
00:11:44,600 --> 00:11:46,960
y lo abro en el WordPad, seguirá siendo hola

290
00:11:46,960 --> 00:11:49,000
¿vale? no hay ningún problema

291
00:11:49,000 --> 00:11:51,580
hay batices de codificaciones

292
00:11:51,580 --> 00:11:53,639
de algunas cosas como los saltos de línea

293
00:11:53,639 --> 00:11:55,500
que alguno usa dos caracteres en vez de uno

294
00:11:55,500 --> 00:11:56,799
pero es un pequeño detalle

295
00:11:56,799 --> 00:12:02,179
todos los editores de texto usan la misma tabla

296
00:12:02,179 --> 00:12:04,059
porque si no un texto escrito en uno

297
00:12:04,059 --> 00:12:05,179
en otro no se podría

298
00:12:05,179 --> 00:12:16,220
pero hombre puede haber

299
00:12:16,220 --> 00:12:18,139
alguno pero en general que viste mucho

300
00:12:18,139 --> 00:12:19,740
no lo sé

301
00:12:19,740 --> 00:12:22,200
no debería, vamos, no lo sé

302
00:12:22,200 --> 00:12:23,960
no sé a qué situación te refieres

303
00:12:23,960 --> 00:12:30,059
es que es la manera

304
00:12:30,059 --> 00:12:31,980
de alguna manera de poder compartir texto

305
00:12:31,980 --> 00:12:33,980
fácilmente, porque si solamente

306
00:12:33,980 --> 00:12:35,960
pudiéramos escribir en procesadores de texto

307
00:12:35,960 --> 00:12:38,279
lo que yo escribo en Word solo me lo puede

308
00:12:38,279 --> 00:12:40,179
leer el Word y los que conozcan

309
00:12:40,179 --> 00:12:40,860
ese lenguaje

310
00:12:40,860 --> 00:12:43,960
pero lo que yo escribo en un editor de texto

311
00:12:43,960 --> 00:12:45,539
cualquiera que tenga

312
00:12:45,539 --> 00:12:48,120
un editor de texto del fabricante

313
00:12:48,120 --> 00:12:50,019
que sea, lo va a interpretar porque está entendiendo

314
00:12:50,019 --> 00:12:50,840
esta tabla, ¿vale?

315
00:12:51,539 --> 00:12:53,980
Bueno, pues puede ser que nosotros en nuestros

316
00:12:53,980 --> 00:12:56,440
programas necesitemos guardar

317
00:12:56,440 --> 00:12:58,100
alguno de estos caracteres.

318
00:12:58,860 --> 00:12:59,980
Hombre, un carácter

319
00:12:59,980 --> 00:13:01,960
solo sirve para poco, pero

320
00:13:01,960 --> 00:13:03,799
es que es lo único que me permite Java

321
00:13:03,799 --> 00:13:06,200
en sus tipos de datos, esos 8 que yo mencioné.

322
00:13:06,960 --> 00:13:08,019
¿Qué quiere un nombre?

323
00:13:08,460 --> 00:13:10,000
Pues tendremos que ver cómo

324
00:13:10,000 --> 00:13:11,600
poner muchos de esos char en fila.

325
00:13:12,139 --> 00:13:13,899
Pero eso es otra cosa que

326
00:13:13,899 --> 00:13:14,980
veremos ahora un poquito después.

327
00:13:16,679 --> 00:13:17,899
Vale, pues entonces

328
00:13:17,899 --> 00:13:22,240
La variable char es para guardar cualquiera de estos caracteres.

329
00:13:24,659 --> 00:13:29,519
Bueno, pues entonces yo declaro la variable char y ahora vamos a asignarle un valor.

330
00:13:30,460 --> 00:13:33,000
¿Cómo le asigno yo un valor a una variable char?

331
00:13:33,600 --> 00:13:38,100
Pues para indicar que es un carácter lo tengo que poner entre comillas simples.

332
00:13:38,940 --> 00:13:40,460
La simple de toda la vida.

333
00:13:42,200 --> 00:13:43,820
¿La encontraré o no la encontraré?

334
00:13:43,940 --> 00:13:44,559
Ahí, coño.

335
00:13:45,320 --> 00:13:45,519
Ahí.

336
00:13:46,100 --> 00:13:47,600
Vale, la simple de toda la vida.

337
00:13:48,279 --> 00:13:48,759
H.

338
00:13:49,720 --> 00:13:50,799
¡Hala! Ya está.

339
00:13:51,700 --> 00:13:57,340
Ya he asignado el carácter H a la variable char C.

340
00:13:57,980 --> 00:14:04,929
Entonces, importante las comillas simples.

341
00:14:06,269 --> 00:14:09,090
Porque es la forma que tiene Java de entender.

342
00:14:09,350 --> 00:14:10,730
Ah, esto es un carácter.

343
00:14:12,779 --> 00:14:13,860
Esto es un carácter.

344
00:14:18,750 --> 00:14:22,409
Yo lo tengo arriba, debajo de la interrogación que sube.

345
00:14:23,350 --> 00:14:24,389
De la interrogación que cierra.

346
00:14:24,389 --> 00:14:25,590
¿Cuál es la interrogación?

347
00:14:25,590 --> 00:14:33,110
donde está el teclado numérico

348
00:14:33,110 --> 00:14:35,450
debajo de la interrogación

349
00:14:35,450 --> 00:14:37,269
que cierra, suele estar la comilla

350
00:14:37,269 --> 00:14:38,929
simple, por lo menos en mi teclado, no lo sé

351
00:14:38,929 --> 00:14:40,870
¿no la tienes ahí?

352
00:14:41,769 --> 00:14:42,570
pues no sé

353
00:14:42,570 --> 00:14:44,970
vale

354
00:14:44,970 --> 00:14:50,440
vale, entonces

355
00:14:50,440 --> 00:15:01,600
cuidado porque

356
00:15:01,600 --> 00:15:03,139
aquí tendemos a lo mejor

357
00:15:03,139 --> 00:15:05,620
a creer que cualquier cosa que suene a texto

358
00:15:05,620 --> 00:15:06,720
son comillas dobles

359
00:15:06,720 --> 00:15:21,519
Y no, las comillas dobles no valen. Las comillas dobles son otra cosa. Las comillas dobles indican un texto completo con muchos caracteres. Y un texto completo con muchos caracteres se guarda en otros sitios, nunca en un char.

360
00:15:21,519 --> 00:15:30,460
En un char, cuidado, las dobles comillas no son un char.

361
00:15:31,440 --> 00:15:38,000
Las dobles comillas sirven para envolver un texto, de uno, dos, tres, cuatro, pero un texto.

362
00:15:38,600 --> 00:15:40,059
Y una cantidad indefinida de caraceres.

363
00:15:40,600 --> 00:15:42,799
Y un texto nunca puede caer en un char.

364
00:15:43,039 --> 00:15:45,759
Un texto cabe en otros sitios que todavía no hemos visto.

365
00:15:46,220 --> 00:15:46,919
Pero en un char no.

366
00:15:47,919 --> 00:15:49,639
Luego no podemos poner comillas dobles.

367
00:15:49,639 --> 00:15:51,860
tenemos que poner comillas simples

368
00:15:51,860 --> 00:15:59,549
¿no? entonces esto por ejemplo

369
00:15:59,549 --> 00:16:01,269
sería

370
00:16:01,269 --> 00:16:03,169
el carácter 1

371
00:16:03,169 --> 00:16:05,429
el carácter

372
00:16:05,429 --> 00:16:05,889
1

373
00:16:05,889 --> 00:16:07,509
¿vale?

374
00:16:09,129 --> 00:16:10,789
no el numerito 1

375
00:16:10,789 --> 00:16:13,190
el carácter

376
00:16:13,190 --> 00:16:13,529
dime

377
00:16:13,529 --> 00:16:17,070
no, no es que tenga

378
00:16:17,070 --> 00:16:18,850
ha puesto el ejemplo de que le asigno el char h

379
00:16:18,850 --> 00:16:21,110
ha le asignado el 1, o sea son asignaciones distintas

380
00:16:21,110 --> 00:16:22,690
con una estoy pisando la anterior

381
00:16:22,690 --> 00:16:25,110
estoy haciendo diferentes ejemplos de asignaciones

382
00:16:25,110 --> 00:16:26,889
pues aquí le meto el carácter h

383
00:16:26,889 --> 00:16:29,090
ahora le meto el 1 con lo cual

384
00:16:29,090 --> 00:16:30,409
el h anterior lo he pisado

385
00:16:30,409 --> 00:16:33,230
y se queda el 1, cada asignación que hago

386
00:16:33,230 --> 00:16:35,289
recordad que elimina el valor

387
00:16:35,289 --> 00:16:36,690
que tenía de antes la variable

388
00:16:36,690 --> 00:16:38,049
y ahora se queda con el nuevo

389
00:16:38,049 --> 00:16:42,649
claro, la h ya ha desaparecido

390
00:16:42,649 --> 00:16:43,830
vale

391
00:16:43,830 --> 00:16:47,049
entonces vamos a recordar

392
00:16:47,049 --> 00:16:49,190
nuestra sentencia esta de mostrar

393
00:16:49,190 --> 00:16:51,090
por consola, vamos a recordarla

394
00:16:51,090 --> 00:17:04,119
vale, porque aquí está claro

395
00:17:04,119 --> 00:17:04,940
vale

396
00:17:04,940 --> 00:17:09,200
aquí no

397
00:17:09,200 --> 00:17:12,460
vale, voy a ejecutar este programa

398
00:17:12,460 --> 00:17:14,640
me saldrá primero lo que hicimos el otro día

399
00:17:14,640 --> 00:17:15,339
de mostrar

400
00:17:15,339 --> 00:17:18,160
el mayor y menor enteros

401
00:17:18,160 --> 00:17:20,599
y el mayor y el menor long, pero bueno, lo ignoro

402
00:17:20,599 --> 00:17:22,839
y luego ya me va a mostrar

403
00:17:22,839 --> 00:17:24,819
la C, a ver que me muestra

404
00:17:24,819 --> 00:17:27,799
recordad que al

405
00:17:27,799 --> 00:17:29,039
system.out.println

406
00:17:29,039 --> 00:17:33,460
y si no, pues lo sacamos ahora

407
00:17:33,460 --> 00:17:35,619
el System.out.println sirve para mostrar

408
00:17:35,619 --> 00:17:37,039
por consola lo que yo le dé.

409
00:17:38,460 --> 00:17:39,819
En el primer programa

410
00:17:39,819 --> 00:17:40,839
ese de Hola Mundo,

411
00:17:42,079 --> 00:17:43,619
pues lo usamos pasándole un

412
00:17:43,619 --> 00:17:45,380
texto entre comillas dobles. Entonces,

413
00:17:45,460 --> 00:17:47,460
mostraba ese texto. Pero yo

414
00:17:47,460 --> 00:17:48,819
al System.out.println

415
00:17:48,819 --> 00:17:51,160
le puedo pasar también

416
00:17:51,160 --> 00:17:55,130
una variable. O sea,

417
00:17:55,210 --> 00:17:58,920
aquí, si el System.out

418
00:17:58,920 --> 00:18:00,819
ve un texto, hola, lo que

419
00:18:00,819 --> 00:18:02,599
sea, ve cualquier cosa entre comillas,

420
00:18:02,740 --> 00:18:04,799
ve algo entre comillas, pues entonces

421
00:18:04,799 --> 00:18:06,519
él te muestra eso literal.

422
00:18:06,660 --> 00:18:25,390
Lo que hay aquí entre comillas, literal, te lo muestro. Pero aquí en este caso no le hemos pasado un texto entre comillas, ¿vale? Aquí en este caso le hemos pasado algo que no está entrecomillado.

423
00:18:25,390 --> 00:18:28,089
entonces exactamente igual que

424
00:18:28,089 --> 00:18:29,910
cuando hacíamos una asignación

425
00:18:29,910 --> 00:18:32,710
edad 1 igual a edad 2

426
00:18:32,710 --> 00:18:33,349
por ejemplo

427
00:18:33,349 --> 00:18:35,369
y él decía, a ver

428
00:18:35,369 --> 00:18:38,170
voy a buscar qué cajita

429
00:18:38,170 --> 00:18:40,009
se llama de esta manera

430
00:18:40,009 --> 00:18:42,349
para coger su valor y asignarlo

431
00:18:42,349 --> 00:18:44,589
aquí, pues el system.out.println

432
00:18:44,589 --> 00:18:45,789
funciona exactamente igual

433
00:18:45,789 --> 00:18:50,170
dirá, oye, no me has pasado

434
00:18:50,170 --> 00:18:51,930
un texto literal entre comillas

435
00:18:51,930 --> 00:18:53,910
me has pasado un identificador, algo

436
00:18:53,910 --> 00:18:56,710
voy a buscar la variable que se llame así

437
00:18:56,710 --> 00:18:57,589
voy a buscarla

438
00:18:57,589 --> 00:19:00,569
y voy a coger lo que tenga dentro

439
00:19:00,569 --> 00:19:02,630
para mostrarlo por consola

440
00:19:02,630 --> 00:19:05,150
voy a coger lo que tenga dentro para mostrarlo por consola

441
00:19:05,150 --> 00:19:06,670
bueno, pues cogerá

442
00:19:06,670 --> 00:19:08,650
ah, me has pasado el identificador C

443
00:19:08,650 --> 00:19:10,490
tendrá que haber alguna variable

444
00:19:10,490 --> 00:19:13,410
que se llame C

445
00:19:13,410 --> 00:19:14,930
pues mira para arriba

446
00:19:14,930 --> 00:19:16,130
y dice, ah, sí, sí, sí que lo hay

447
00:19:16,130 --> 00:19:18,430
hay una variable que se llama C

448
00:19:18,430 --> 00:19:20,470
pues voy a coger su valor

449
00:19:20,470 --> 00:19:22,750
que en este caso sería

450
00:19:22,750 --> 00:19:24,609
la h y voy a mostrarlo

451
00:19:24,609 --> 00:19:26,990
esto es lo que haría el system.println

452
00:19:26,990 --> 00:19:30,849
busca la variable que se llame

453
00:19:30,849 --> 00:19:31,230
así

454
00:19:31,230 --> 00:19:34,329
mira lo que tiene dentro

455
00:19:34,329 --> 00:19:37,009
para mostrarlo

456
00:19:37,009 --> 00:19:38,089
pues si

457
00:19:38,089 --> 00:19:40,289
ejecutamos esto

458
00:19:40,289 --> 00:19:48,160
vale, si ejecutamos

459
00:19:48,160 --> 00:19:50,400
esto, efectivamente

460
00:19:50,400 --> 00:19:53,940
después del rollo

461
00:19:53,940 --> 00:19:55,480
este que había de antes

462
00:19:55,480 --> 00:19:57,700
me ha mostrado la h

463
00:19:57,700 --> 00:19:59,880
¿vale? me ha mostrado la h

464
00:19:59,880 --> 00:20:01,119
muy bien

465
00:20:01,119 --> 00:20:17,349
y aquí si yo ejecuto

466
00:20:17,349 --> 00:20:18,950
esto pues me mostraría

467
00:20:18,950 --> 00:20:21,450
la h y luego después el 1

468
00:20:21,450 --> 00:20:23,009
pues la variable c ha cambiado

469
00:20:23,009 --> 00:20:25,170
entonces esto es el carácter

470
00:20:25,170 --> 00:20:25,869
1

471
00:20:25,869 --> 00:20:28,130
ay perdón

472
00:20:28,130 --> 00:20:34,509
pues aquí efectivamente el primer

473
00:20:34,509 --> 00:20:36,450
system.out.println muestra la h

474
00:20:36,450 --> 00:20:40,480
y el segundo me muestra

475
00:20:40,480 --> 00:20:42,400
el 1 porque yo le he pasado

476
00:20:42,400 --> 00:20:43,660
el carácter 1

477
00:20:43,660 --> 00:20:48,960
ya está, hasta ahí no tiene más historias

478
00:20:48,960 --> 00:20:51,700
pero aquí ya sí que hay un matiz extraño

479
00:20:51,700 --> 00:21:10,049
a ver, vale, aquí

480
00:21:10,049 --> 00:21:14,730
¿qué ocurre? que tal y como hemos visto en esta pequeña tablita

481
00:21:14,730 --> 00:21:18,210
de aquí, que no era esta tabla de aquí

482
00:21:18,210 --> 00:21:22,309
aquí ya vemos automáticamente una correspondencia

483
00:21:22,309 --> 00:21:24,849
entre caracteres y números

484
00:21:24,849 --> 00:21:27,009
hay una correspondencia de caracteres y números

485
00:21:27,009 --> 00:21:27,829
la hemos mencionado

486
00:21:27,829 --> 00:21:31,009
los caracteres y los números

487
00:21:31,009 --> 00:21:33,569
que los codifican en binario dentro de la máquina

488
00:21:33,569 --> 00:21:36,170
están indisolublemente unidos

489
00:21:36,170 --> 00:21:39,250
universalmente unidos

490
00:21:39,250 --> 00:21:40,170
esa correspondencia

491
00:21:40,170 --> 00:21:42,049
bueno, pues tan es así

492
00:21:42,049 --> 00:21:44,410
que los lenguajes de programación

493
00:21:44,410 --> 00:21:47,250
te permiten trabajar indistintamente

494
00:21:47,250 --> 00:21:48,809
porque a veces es muy cómodo

495
00:21:48,809 --> 00:21:50,509
con el carácter

496
00:21:50,509 --> 00:21:53,130
o con el número entero que lo codifica

497
00:21:53,130 --> 00:21:55,269
que permiten trabajar

498
00:21:55,269 --> 00:21:56,890
indiscutiblemente con una cosa o con otra

499
00:21:56,890 --> 00:21:59,390
es decir

500
00:21:59,390 --> 00:22:00,869
esto en que se concreta

501
00:22:00,869 --> 00:22:03,349
por ejemplo yo quiero guardar

502
00:22:03,349 --> 00:22:05,009
el carácter A

503
00:22:05,009 --> 00:22:07,750
mayúscula que es el 65

504
00:22:07,750 --> 00:22:09,569
el carácter A

505
00:22:09,569 --> 00:22:11,150
mayúscula que es el 65

506
00:22:11,150 --> 00:22:12,630
vale

507
00:22:12,630 --> 00:22:15,269
pues el carácter A

508
00:22:15,269 --> 00:22:16,950
mayúscula que es el 65

509
00:22:16,950 --> 00:22:19,829
yo haría C igual a

510
00:22:19,829 --> 00:22:21,049
A

511
00:22:21,049 --> 00:22:23,890
vale

512
00:22:23,890 --> 00:22:28,650
y ahora lo muestro

513
00:22:28,650 --> 00:22:37,130
y aquí tengo la A

514
00:22:37,130 --> 00:22:37,569
vale

515
00:22:37,569 --> 00:22:39,990
pero este char C

516
00:22:39,990 --> 00:22:41,869
que está declarado como char

517
00:22:41,869 --> 00:22:44,910
yo puedo hacer esto también

518
00:22:44,910 --> 00:22:47,210
C igual a 65

519
00:22:47,210 --> 00:22:50,170
y como veis

520
00:22:50,170 --> 00:22:53,289
al compilador le parece perfecto

521
00:22:53,289 --> 00:22:54,470
me parece maravilloso

522
00:22:54,470 --> 00:22:58,289
es decir, a una variable declarada como char

523
00:22:58,289 --> 00:23:00,970
a una variable declarada como char

524
00:23:00,970 --> 00:23:03,009
le podemos dar

525
00:23:03,009 --> 00:23:05,369
tanto algo entre comillas

526
00:23:05,369 --> 00:23:07,089
simples, y ahí no hay duda

527
00:23:07,089 --> 00:23:08,569
sería ese carácter tal cual

528
00:23:08,569 --> 00:23:10,109
algo entre comillas simples

529
00:23:10,109 --> 00:23:12,410
o le podemos dar un número entero

530
00:23:12,410 --> 00:23:14,190
las dos cosas las va a tragar

531
00:23:14,190 --> 00:23:16,430
cuando le demos el número entero

532
00:23:16,430 --> 00:23:18,789
realmente que va a guardar dentro

533
00:23:18,789 --> 00:23:20,450
lo que realmente va a guardar

534
00:23:20,450 --> 00:23:22,750
dentro es el char

535
00:23:22,750 --> 00:23:24,809
que en la tabla ASCII se corresponde

536
00:23:24,809 --> 00:23:25,430
con ese número

537
00:23:25,430 --> 00:23:29,890
En nuestro caso, pues en el 65 se corresponde la A

538
00:23:29,890 --> 00:23:32,369
¿Y por qué va a hacer eso?

539
00:23:32,930 --> 00:23:35,150
Porque C está declarada como char

540
00:23:35,150 --> 00:23:39,690
Es decir, si C estuviera declarada como entero

541
00:23:39,690 --> 00:23:45,549
En C guardaría el número 65 sí o sí, en binario, no hay duda

542
00:23:45,549 --> 00:23:48,289
El número 65, si estuviera declarada como entero

543
00:23:48,289 --> 00:23:51,230
Pero como C está declarada como char

544
00:23:51,230 --> 00:23:53,990
lo que internamente se guarda

545
00:23:53,990 --> 00:23:55,130
es el char

546
00:23:55,130 --> 00:23:57,529
que en la tabla A

547
00:23:57,529 --> 00:23:58,789
se corresponde con el 65

548
00:23:58,789 --> 00:24:04,119
de hecho si nosotros ahora hacemos esto

549
00:24:04,119 --> 00:24:11,700
como veis

550
00:24:11,700 --> 00:24:13,980
imprime la A también

551
00:24:13,980 --> 00:24:16,619
las dos veces

552
00:24:16,619 --> 00:24:17,500
se ha imprimido la A

553
00:24:17,500 --> 00:24:19,539
y yo aquí le he dado el 65

554
00:24:19,539 --> 00:24:22,079
¿por qué no he imprimido 65?

555
00:24:22,480 --> 00:24:24,019
no he imprimido 65

556
00:24:24,019 --> 00:24:26,519
porque C está declarado como char

557
00:24:26,519 --> 00:24:28,539
entonces al estar

558
00:24:28,539 --> 00:24:30,460
declarado como char, la máquina virtual

559
00:24:30,460 --> 00:24:32,900
interpreta que ese 65

560
00:24:32,900 --> 00:24:34,279
en realidad es un char.

561
00:24:35,180 --> 00:24:36,619
Entonces, como en realidad es un char

562
00:24:36,619 --> 00:24:37,819
porque está declarado como char,

563
00:24:38,460 --> 00:24:40,140
nada de imprimir 65.

564
00:24:40,660 --> 00:24:42,059
Se va a la tabla ASCII

565
00:24:42,059 --> 00:24:44,400
y busca el carácter que se

566
00:24:44,400 --> 00:24:46,500
corresponde con el 65 y ve que

567
00:24:46,500 --> 00:24:48,359
es la mayúscula, pues

568
00:24:48,359 --> 00:24:49,220
ese es el que planta.

569
00:24:49,619 --> 00:24:51,240
Entonces, si no está determinado

570
00:24:51,240 --> 00:24:56,440
lo que hace es

571
00:24:56,440 --> 00:24:57,559
imprimir el

572
00:24:57,559 --> 00:25:00,019
carácter que corresponda.

573
00:25:00,019 --> 00:25:19,799
A ver, en una variable char, en una caja char puede ir un carácter entre comillas simples o un número entero, las dos cosas. Cuando sea un número entre comillas simples es ese char, lógicamente. Cuando sea un número entero es el carácter que en la tabla ASCII se corresponde con ese número entero. Esa es la regla.

574
00:25:19,799 --> 00:25:23,799
O sea, si la tabla llega hasta...

575
00:25:23,799 --> 00:25:26,380
a ver, hay no imprimibles

576
00:25:26,380 --> 00:25:28,619
hay no imprimibles

577
00:25:28,619 --> 00:25:33,799
¿vale? entonces

578
00:25:33,799 --> 00:25:36,079
hay un

579
00:25:36,079 --> 00:25:37,940
ASTI extendido que son los no imprimibles

580
00:25:37,940 --> 00:25:39,619
entonces lo que pasa es que

581
00:25:39,619 --> 00:25:41,859
este te lo coge, este no te lo cogería

582
00:25:41,859 --> 00:25:43,140
te diría, no, esto ya no

583
00:25:43,140 --> 00:25:45,859
¿vale? pero este sí, ¿qué imprimiría aquí?

584
00:25:45,960 --> 00:25:47,359
ni idea, no sé el mil cual es

585
00:25:47,359 --> 00:25:51,349
pues mira, esta cosa tan mona

586
00:25:51,349 --> 00:25:52,509
¿vale?

587
00:25:54,250 --> 00:25:54,650
entonces

588
00:25:54,650 --> 00:25:57,130
la tabla ASTI es mayor

589
00:25:57,130 --> 00:25:59,049
que los 256 que solemos conocer

590
00:25:59,049 --> 00:26:01,089
que son los que escribimos, tiene un montón de cosas

591
00:26:01,089 --> 00:26:03,390
pero si te sales de lo que ya

592
00:26:03,390 --> 00:26:05,349
es codificable, pues ya sí que te da

593
00:26:05,349 --> 00:26:06,970
te da errores

594
00:26:06,970 --> 00:26:08,069
vale

595
00:26:08,069 --> 00:26:14,609
con lo cual, esto nos lleva

596
00:26:14,609 --> 00:26:16,730
a que c igual a 1

597
00:26:16,730 --> 00:26:19,630
y c igual

598
00:26:19,630 --> 00:26:21,309
a 1 entre comillas

599
00:26:21,309 --> 00:26:22,509
simples, por ejemplo

600
00:26:22,509 --> 00:26:25,309
son dos cosas completamente distintas

601
00:26:25,309 --> 00:26:26,609
bueno, voy a poner

602
00:26:26,609 --> 00:26:29,089
50 porque el 1 no sé ni qué será

603
00:26:29,089 --> 00:26:32,569
Ah, no, no, quiero esto

604
00:26:32,569 --> 00:26:33,869
Venga, quiero que tenga eso

605
00:26:33,869 --> 00:26:35,009
Por ejemplo

606
00:26:35,009 --> 00:26:37,630
Esto y esto

607
00:26:37,630 --> 00:26:43,900
Esto y esto

608
00:26:43,900 --> 00:26:46,579
Son dos cosas completamente distintas

609
00:26:46,579 --> 00:26:47,400
Y se imprimirían

610
00:26:47,400 --> 00:26:49,920
Esto es el carácter 5

611
00:26:49,920 --> 00:26:51,740
El carácter 5, tal cual, el 5

612
00:26:51,740 --> 00:26:54,920
Sin embargo, esto es el carácter

613
00:26:54,920 --> 00:26:57,079
Que en la tabla ASCII está asociado al 5

614
00:26:57,079 --> 00:26:58,240
Ni idea de cuál es

615
00:26:58,240 --> 00:26:59,259
Ni idea

616
00:26:59,259 --> 00:27:01,339
Vamos a ejecutarlo

617
00:27:01,339 --> 00:27:05,240
Pues no es imprimible

618
00:27:05,240 --> 00:27:07,220
por eso me ha salido cuando no es imprimible

619
00:27:07,220 --> 00:27:08,500
sale un cuadradito

620
00:27:08,500 --> 00:27:11,299
este es el

621
00:27:11,299 --> 00:27:13,279
carácter que en la tabla se está asociado al 5

622
00:27:13,279 --> 00:27:14,920
que es uno no imprimible a saber

623
00:27:14,920 --> 00:27:17,240
y este es el

624
00:27:17,240 --> 00:27:19,240
carácter 5, luego esta

625
00:27:19,240 --> 00:27:21,380
asignación y esta son completamente

626
00:27:21,380 --> 00:27:23,039
distintas, ¿vale?

627
00:27:23,079 --> 00:27:25,140
son completamente distintas, ambas son

628
00:27:25,140 --> 00:27:26,759
válidas, pero

629
00:27:26,759 --> 00:27:29,259
son dos valores

630
00:27:29,259 --> 00:27:30,019
diferentes

631
00:27:30,019 --> 00:27:32,500
¿vale?

632
00:27:48,230 --> 00:28:13,109
A ver, pero cosas, hasta aquí está claro, ¿no? Vale, según vamos viendo estas cosas, pues vamos sacando pequeñas situaciones, entonces, igual, pues bueno, son muchas pequeñitas cosas que ahora mismo nos tienen que ir sonando, pues nos vamos encontrando, pero no es que sea una lista de cosas que uno tiene que tener siempre presentes.

633
00:28:13,109 --> 00:28:15,150
Son pequeñas cositas que vamos sacando

634
00:28:15,150 --> 00:28:17,190
Pues para que vayáis familiarizándoos un poquito

635
00:28:17,190 --> 00:28:19,150
Con todos estos matices

636
00:28:19,150 --> 00:28:21,390
De las variables y la asignación

637
00:28:21,390 --> 00:28:22,410
Vale

638
00:28:22,410 --> 00:28:24,509
Vamos a otra situación

639
00:28:24,509 --> 00:28:26,990
Venga, de hecho voy a cambiar

640
00:28:26,990 --> 00:28:28,990
De clase, porque para

641
00:28:28,990 --> 00:28:31,549
Ejecutar, si no es un rollo

642
00:28:31,549 --> 00:28:32,930
A ver

643
00:28:32,930 --> 00:28:34,829
Este de aquí

644
00:28:34,829 --> 00:28:36,230
Había metido aquí de todo

645
00:28:36,230 --> 00:28:38,750
Este le voy a

646
00:28:38,750 --> 00:28:41,210
Cambiar de nombre, lo digo porque luego cuando medio

647
00:28:41,210 --> 00:28:43,289
lo acabemos, lo subiría a la aula virtual por si

648
00:28:43,289 --> 00:28:45,230
voy a cambiarle a este

649
00:28:45,230 --> 00:28:47,109
de nombre, que siempre podéis cambiar

650
00:28:47,109 --> 00:28:48,990
a un programa que tengáis hecho

651
00:28:48,990 --> 00:28:51,410
le podéis cambiar el nombre con refactor rename

652
00:28:51,410 --> 00:28:52,269
si es que

653
00:28:52,269 --> 00:28:54,970
le voy a cambiar a

654
00:28:54,970 --> 00:28:56,950
números, porque ahí vamos a

655
00:28:56,950 --> 00:29:01,220
enteros, porque

656
00:29:01,220 --> 00:29:03,240
ahí voy a dejar los ejemplos

657
00:29:03,240 --> 00:29:04,319
con números enteros

658
00:29:04,319 --> 00:29:08,160
vale, no me ha dejado

659
00:29:08,160 --> 00:29:10,819
cambiarlo

660
00:29:10,819 --> 00:29:14,920
porque no me ha dejado cambiarlo

661
00:29:14,920 --> 00:29:27,150
enteros

662
00:29:27,150 --> 00:29:36,650
vale, entonces este voy a

663
00:29:36,650 --> 00:29:38,849
dejar lo que teníamos de enteros

664
00:29:38,849 --> 00:29:42,710
y lo de char lo voy a poner ya en otro

665
00:29:42,710 --> 00:29:47,529
control x, esto lo voy a poner en otro

666
00:29:47,529 --> 00:29:52,680
que sea caracteres

667
00:29:52,680 --> 00:29:58,180
caracteres, vale

668
00:29:58,180 --> 00:30:18,150
vale, pues esto es lo que hemos visto con caracteres

669
00:30:18,150 --> 00:30:25,259
el ejemplito, bueno la idea es que

670
00:30:25,259 --> 00:30:27,539
notéis que os vais sintiendo

671
00:30:27,539 --> 00:30:29,400
más o menos cómodos con estos

672
00:30:29,400 --> 00:30:31,440
conceptos, que los vais

673
00:30:31,440 --> 00:30:33,259
entendiendo, que nada os suena

674
00:30:33,259 --> 00:30:35,500
horriblemente raro y que os veis

675
00:30:35,500 --> 00:30:37,440
cómodos con las cosas

676
00:30:37,440 --> 00:30:39,339
que nos van saliendo y ya está

677
00:30:39,339 --> 00:30:41,960
no que tengáis que tener absolutamente

678
00:30:41,960 --> 00:30:43,819
todas las situaciones que hemos visto en la cabeza

679
00:30:43,819 --> 00:30:50,509
bueno, pues vamos a ver otra situación

680
00:30:50,509 --> 00:30:52,130
con los charlos, no, pero dime, dime

681
00:30:52,130 --> 00:30:54,529
no, el lasti en otros idiomas, por ejemplo

682
00:30:54,529 --> 00:30:56,509
el español, la ñ en otros idiomas

683
00:30:56,509 --> 00:30:58,349
en otros idiomas que también tienen más letras

684
00:30:58,349 --> 00:31:13,750
En el carácter ASTI están todos, en el extendido, bueno, a ver, están los que están, pero la Ñ lógicamente está en el ASTI, la cejilla, los carácteres, a ver, la puedes mirar por curiosidad, hay un montonazo de caracteres.

685
00:31:13,750 --> 00:31:16,690
Todos los que imprimen los editores de texto

686
00:31:16,690 --> 00:31:18,369
A ver, un editor de texto

687
00:31:18,369 --> 00:31:19,849
Tú no puedes elegir un editor de texto

688
00:31:19,849 --> 00:31:22,210
En japonés, por ejemplo

689
00:31:22,210 --> 00:31:23,890
Tienes que tener tú el propio

690
00:31:23,890 --> 00:31:25,809
Incorporar otra cosa

691
00:31:25,809 --> 00:31:27,329
¿Vale?

692
00:31:27,509 --> 00:31:30,369
O sea, en la tabla ASCII no están los caracteres japoneses

693
00:31:30,369 --> 00:31:32,009
¿Eh?

694
00:31:35,710 --> 00:31:36,390
¿Te detecta el qué?

695
00:31:37,930 --> 00:31:39,650
Sí, pero bueno, porque tiene

696
00:31:39,650 --> 00:31:41,470
Una extensión

697
00:31:41,470 --> 00:31:44,069
la tabla este original no tiene los caracteres

698
00:31:44,069 --> 00:31:45,950
japoneses, pero hoy tendría que tener 200.000

699
00:31:45,950 --> 00:31:48,109
caracteres, que son los que tienen los caracteres

700
00:31:48,109 --> 00:31:49,910
japoneses, entonces hay extensiones

701
00:31:49,910 --> 00:31:51,230
con los caracteres básicos

702
00:31:51,230 --> 00:31:55,910
de hecho el

703
00:31:55,910 --> 00:31:57,890
char c, la variable

704
00:31:57,890 --> 00:31:59,990
char de java, en realidad son 16

705
00:31:59,990 --> 00:32:01,890
bits por dentro, son 16

706
00:32:01,890 --> 00:32:07,950
con 16 ya en realidad hay un montazo de caracteres

707
00:32:07,950 --> 00:32:09,710
entonces elevado a 16, imagínate lo que es eso

708
00:32:09,710 --> 00:32:10,789
son muchísimos

709
00:32:10,789 --> 00:32:14,490
Vale, otra situación, por ejemplo

710
00:32:14,490 --> 00:32:17,990
Yo me voy a declarar una variable int

711
00:32:17,990 --> 00:32:20,910
Cambio a otra situación a ver si entendemos lo que pasa

712
00:32:20,910 --> 00:32:26,059
Venga

713
00:32:26,059 --> 00:32:28,819
Me declaro una variable int

714
00:32:28,819 --> 00:32:29,359
Vale

715
00:32:29,359 --> 00:32:33,259
A esta variable int

716
00:32:33,259 --> 00:32:36,200
Una variable int

717
00:32:36,200 --> 00:32:37,880
N, por ejemplo

718
00:32:37,880 --> 00:32:42,019
Le doy, vale

719
00:32:42,019 --> 00:32:44,319
vale, siguiente

720
00:32:44,319 --> 00:32:46,599
siguiente cosa que incorporamos

721
00:32:46,599 --> 00:32:48,660
¿vale? tenemos que ir incorporando

722
00:32:48,660 --> 00:32:50,539
cositas poco a poco porque si no

723
00:32:50,539 --> 00:32:52,240
no podemos avanzar

724
00:32:52,240 --> 00:32:54,799
en el momento en el que declaramos una variable

725
00:32:54,799 --> 00:32:56,660
en el momento

726
00:32:56,660 --> 00:32:57,920
en el que la declaramos

727
00:32:57,920 --> 00:33:00,460
en ese momento si queremos

728
00:33:00,460 --> 00:33:02,420
podemos ya asignarle un valor

729
00:33:02,420 --> 00:33:04,539
si queremos, es decir, por ejemplo

730
00:33:04,539 --> 00:33:05,680
yo quiero una variable n

731
00:33:05,680 --> 00:33:07,619
y le quiero dar un primer valor

732
00:33:07,619 --> 00:33:10,200
13 o 90

733
00:33:10,200 --> 00:33:13,720
pues yo haría esto

734
00:33:13,720 --> 00:33:14,099
¿verdad?

735
00:33:14,880 --> 00:33:17,579
y con esto he creado mi variable

736
00:33:17,579 --> 00:33:19,440
n, ha aparecido en memoria, se llama

737
00:33:19,440 --> 00:33:21,299
n y luego después

738
00:33:21,299 --> 00:33:23,160
le he asignado el valor 9, vale

739
00:33:23,160 --> 00:33:25,420
esto está bien, es un primer valor que le asigno

740
00:33:25,420 --> 00:33:27,619
vale, pues por comodidad

741
00:33:27,619 --> 00:33:28,819
en la escritura de código

742
00:33:28,819 --> 00:33:31,019
si uno quiere

743
00:33:31,019 --> 00:33:33,059
o lo necesita

744
00:33:33,059 --> 00:33:35,799
en el mismo

745
00:33:35,799 --> 00:33:37,339
momento de declarar una variable

746
00:33:37,339 --> 00:33:39,619
puedes aprovechar y darle ya

747
00:33:39,619 --> 00:33:40,759
un primer valor

748
00:33:40,759 --> 00:33:44,400
con lo cual esto se convertiría

749
00:33:44,400 --> 00:33:46,000
esto que yo he escrito aquí

750
00:33:46,000 --> 00:33:51,000
se convertiría en esto

751
00:33:51,000 --> 00:33:57,319
¿vale?

752
00:34:02,000 --> 00:34:03,819
asigno un primer valor

753
00:34:03,819 --> 00:34:07,880
en la declaración

754
00:34:07,880 --> 00:34:08,579
de la variable

755
00:34:08,579 --> 00:34:11,699
esto lo puedo hacer

756
00:34:11,699 --> 00:34:13,539
si es que yo quiero darle un primer valor

757
00:34:13,539 --> 00:34:14,820
luego ya n después

758
00:34:14,820 --> 00:34:17,059
que le quiero dar 27

759
00:34:17,059 --> 00:34:19,159
n igual a 27, luego ya a partir de ahí

760
00:34:19,159 --> 00:34:20,559
lógicamente lo que el programa necesite

761
00:34:20,559 --> 00:34:22,679
puedo asignar un primer valor

762
00:34:22,679 --> 00:34:25,260
esto es lo que se suele

763
00:34:25,260 --> 00:34:27,400
llamar inicialización

764
00:34:27,400 --> 00:34:29,500
de la variable, la estás inicializando

765
00:34:29,500 --> 00:34:31,420
¿por qué? porque la estás dando un primer

766
00:34:31,420 --> 00:34:33,440
valor, le das un primer valor

767
00:34:33,440 --> 00:34:35,880
esto es la inicialización

768
00:34:35,880 --> 00:34:41,809
la opción

769
00:34:41,809 --> 00:34:44,989
¿vale? entonces no es necesario

770
00:34:44,989 --> 00:34:46,889
que hagamos, lo hagamos

771
00:34:46,889 --> 00:34:48,730
en dos líneas, no es necesario

772
00:34:48,730 --> 00:34:51,190
podemos hacerlo en una línea

773
00:34:51,190 --> 00:34:53,010
y aquí pasan dos

774
00:34:53,010 --> 00:34:54,710
cosas, están pasando dos cosas

775
00:34:54,710 --> 00:34:57,269
creo la variable n

776
00:34:57,269 --> 00:34:59,329
en memoria, el espacio, le asocio

777
00:34:59,329 --> 00:35:01,610
el nombre n y además

778
00:35:01,610 --> 00:35:03,489
meto dentro el entero

779
00:35:03,489 --> 00:35:04,650
90, vale

780
00:35:04,650 --> 00:35:11,280
bueno, pues ahora me voy a declarar una variable char

781
00:35:11,280 --> 00:35:20,889
carácter

782
00:35:20,889 --> 00:35:22,230
por ejemplo

783
00:35:22,230 --> 00:35:25,530
vale

784
00:35:25,530 --> 00:35:29,369
carácter, pues yo que sé, por ejemplo

785
00:35:29,369 --> 00:35:30,409
le vamos a dar

786
00:35:30,409 --> 00:35:33,130
la j mayúscula

787
00:35:33,130 --> 00:35:35,170
la inicializamos a la vez que

788
00:35:35,170 --> 00:35:36,570
la creamos, vale

789
00:35:36,570 --> 00:35:53,420
Pues yo he dicho antes que los enteros y los char para Java son intercambiables, porque cada char está codificado como un entero y Java los usa como valores intercambiables.

790
00:35:53,420 --> 00:35:55,519
eso, por ejemplo

791
00:35:55,519 --> 00:35:58,260
me permitiría a mí hacer esto

792
00:35:58,260 --> 00:36:00,500
a carácter

793
00:36:00,500 --> 00:36:03,900
asignarle

794
00:36:03,900 --> 00:36:04,940
n

795
00:36:04,940 --> 00:36:06,480
¿vale?

796
00:36:07,099 --> 00:36:08,739
según eso me permitiría hacer esto

797
00:36:08,739 --> 00:36:09,300
¿vale?

798
00:36:09,739 --> 00:36:14,619
y me sale en rojo

799
00:36:14,619 --> 00:36:16,639
¿vale?

800
00:36:17,239 --> 00:36:18,780
¿por qué me sale en rojo?

801
00:36:19,039 --> 00:36:21,260
porque aunque n yo aquí le he puesto 90

802
00:36:21,260 --> 00:36:22,539
y sé que 90

803
00:36:22,539 --> 00:36:25,539
tiene una correspondencia en la tabla ASCII

804
00:36:25,539 --> 00:36:27,579
el compilador

805
00:36:27,579 --> 00:36:30,039
no sabe si lo que yo he puesto ahí

806
00:36:30,039 --> 00:36:31,940
es un número enorme

807
00:36:31,940 --> 00:36:33,780
dentro de int, que no tiene

808
00:36:33,780 --> 00:36:34,920
correspondencia a la tabla ASCII.

809
00:36:35,840 --> 00:36:38,039
Entonces, esta asignación

810
00:36:38,039 --> 00:36:39,840
así no te deja, a través

811
00:36:39,840 --> 00:36:41,920
de una variable int, no te deja.

812
00:36:42,559 --> 00:36:43,800
Si yo le pongo el 90

813
00:36:43,800 --> 00:36:44,579
directamente,

814
00:36:46,079 --> 00:36:47,139
entonces sí que te deja,

815
00:36:47,820 --> 00:36:49,719
porque el compilador sabe que el 90

816
00:36:49,719 --> 00:36:51,780
sí es un valor dentro de la

817
00:36:51,780 --> 00:36:52,480
tabla ASCII.

818
00:36:53,900 --> 00:36:54,719
Sí sabe.

819
00:36:55,780 --> 00:36:57,360
Pero no te deja hacer esto.

820
00:36:57,579 --> 00:37:00,500
porque el compilador va por reglas,

821
00:37:00,679 --> 00:37:02,380
no fija, no se, no mira

822
00:37:02,380 --> 00:37:04,500
valores concretos de las variables, va por

823
00:37:04,500 --> 00:37:06,400
reglas, y te dice, oye,

824
00:37:06,519 --> 00:37:08,239
vale, n a lo mejor ahora

825
00:37:08,239 --> 00:37:10,199
tiene 90, pero

826
00:37:10,199 --> 00:37:12,119
por principio una variable int

827
00:37:12,119 --> 00:37:14,940
podría tener 50.213,

828
00:37:14,940 --> 00:37:17,320
y 50.213

829
00:37:17,320 --> 00:37:19,019
no sería un valor que está

830
00:37:19,019 --> 00:37:20,900
en la tabla ASCII, entonces

831
00:37:20,900 --> 00:37:22,980
el compilador te cierra

832
00:37:22,980 --> 00:37:24,920
esa asignación.

833
00:37:24,920 --> 00:37:30,360
Claro, si tú quieres asignar 90

834
00:37:30,360 --> 00:37:31,300
Le pones el número

835
00:37:31,300 --> 00:37:38,679
Espera, lo comprobamos

836
00:37:38,679 --> 00:37:41,119
Esta asignación no nos deja

837
00:37:41,119 --> 00:37:50,599
Porque n podría

838
00:37:50,599 --> 00:37:53,739
Ser demasiado

839
00:37:53,739 --> 00:37:54,559
Grande

840
00:37:54,559 --> 00:37:55,599
¿Vale?

841
00:37:56,780 --> 00:37:58,780
Un segundito, ahora comprobamos lo que has dicho tú

842
00:37:58,780 --> 00:37:59,699
Esta no nos deja

843
00:37:59,699 --> 00:38:03,460
La dejo comentada, de hecho, para que el compilador

844
00:38:03,460 --> 00:38:06,750
No me...

845
00:38:06,750 --> 00:38:08,130
¿Pero qué pasa con la opuesta?

846
00:38:09,130 --> 00:38:10,389
La opuesta sí.

847
00:38:11,230 --> 00:38:17,030
A n yo le puedo dar carácter.

848
00:38:17,670 --> 00:38:17,869
¿Vale?

849
00:38:18,510 --> 00:38:19,889
Esta sí que me ha dejado.

850
00:38:21,769 --> 00:38:22,610
Esta sí deja.

851
00:38:24,539 --> 00:38:29,659
Porque carácter no va a tener nunca un número entero que no quepa ni.

852
00:38:30,719 --> 00:38:34,500
Porque la tabla así extendida, como mucho, son 16 bits.

853
00:38:36,360 --> 00:38:37,679
Entonces, esta sí.

854
00:38:37,679 --> 00:38:44,579
Pero, cuidadín con esta

855
00:38:44,579 --> 00:38:48,400
Esta sí es posible

856
00:38:48,400 --> 00:38:54,000
Esta sí es posible

857
00:38:54,000 --> 00:38:57,099
Aquí sí se hace

858
00:38:57,099 --> 00:38:59,659
Esto sería otro ejemplo, entre comillas

859
00:38:59,659 --> 00:39:00,840
De promoción automática

860
00:39:00,840 --> 00:39:02,300
Aunque exactamente no es así

861
00:39:02,300 --> 00:39:06,300
Pero esta sí te deja

862
00:39:06,300 --> 00:39:08,659
Porque un carácter

863
00:39:08,659 --> 00:39:11,219
Internamente Java lo guarda en 16 bits

864
00:39:11,219 --> 00:39:13,320
Que es la tabla así extendida

865
00:39:13,320 --> 00:39:14,300
Puede tener hasta 16

866
00:39:14,300 --> 00:39:17,000
y en una variable int cabe

867
00:39:17,000 --> 00:39:19,159
y como los char y los int

868
00:39:19,159 --> 00:39:20,840
son intercambiables, pues la tabla

869
00:39:20,840 --> 00:39:22,659
a cada char le mete un int

870
00:39:22,659 --> 00:39:27,820
pues vamos a mostrar

871
00:39:27,820 --> 00:39:29,960
entonces a carácter le hemos dado j

872
00:39:29,960 --> 00:39:32,639
esta asignación

873
00:39:32,639 --> 00:39:33,840
ha sido válida

874
00:39:33,840 --> 00:39:36,860
vamos ahora a mostrar

875
00:39:36,860 --> 00:39:38,539
tanto

876
00:39:38,539 --> 00:39:42,769
carácter como n

877
00:39:42,769 --> 00:39:47,809
no, no suma nada

878
00:39:47,809 --> 00:39:49,309
le asigna ese valor

879
00:39:49,309 --> 00:39:51,670
es una asignación

880
00:39:51,670 --> 00:39:52,829
no hay ninguna suma

881
00:39:52,829 --> 00:39:58,489
Sí, pero no porque sume

882
00:39:58,489 --> 00:40:01,269
Vamos a imprimirla, vamos a hacer las dos cosas ahora

883
00:40:01,269 --> 00:40:02,590
Vale, no

884
00:40:02,590 --> 00:40:04,969
Espera un momentito

885
00:40:04,969 --> 00:40:08,829
Está claro lo que hemos hecho, ¿no?

886
00:40:09,230 --> 00:40:10,489
El carácter tiene

887
00:40:10,489 --> 00:40:11,969
El carácter J

888
00:40:11,969 --> 00:40:14,570
Yo solo he podido asignar a N

889
00:40:14,570 --> 00:40:18,400
Primero porque un char

890
00:40:18,400 --> 00:40:19,139
Cabe en un int

891
00:40:19,139 --> 00:40:21,960
Y porque para Java los char y los int

892
00:40:21,960 --> 00:40:24,280
En realidad son lo mismo porque cada char

893
00:40:24,280 --> 00:40:26,099
Tiene un número entero que lo representa

894
00:40:26,099 --> 00:40:28,639
Voy a mostrar ahora las dos cosas

895
00:40:28,639 --> 00:40:31,969
Ejecutamos esto

896
00:40:31,969 --> 00:40:41,900
Esto no está ejecutado

897
00:40:41,900 --> 00:40:44,000
A ver, es que me ejecuta otro siempre

898
00:40:44,000 --> 00:40:49,039
Vale, ejecuto esto

899
00:40:49,039 --> 00:40:52,530
Esta es la J

900
00:40:52,530 --> 00:40:56,650
Este es el primer System.out

901
00:40:56,650 --> 00:40:58,530
La J

902
00:40:58,530 --> 00:41:01,969
Sí, yo le he dado carácter

903
00:41:01,969 --> 00:41:04,610
Y me ha mostrado la J, maravilloso

904
00:41:04,610 --> 00:41:06,989
Ahora le he dado N

905
00:41:06,989 --> 00:41:08,650
le he dado n

906
00:41:08,650 --> 00:41:11,570
y no me ha mostrado la j

907
00:41:11,570 --> 00:41:14,969
que me ha mostrado 74

908
00:41:14,969 --> 00:41:17,570
¿qué es 74?

909
00:41:18,389 --> 00:41:20,650
la codificación de j

910
00:41:20,650 --> 00:41:21,590
¿por qué?

911
00:41:21,730 --> 00:41:22,869
¿y por qué lo hace distinto?

912
00:41:23,610 --> 00:41:25,409
porque este sistema println

913
00:41:25,409 --> 00:41:26,929
funciona diferente

914
00:41:26,929 --> 00:41:29,630
si tú le das una variable declarada como char

915
00:41:29,630 --> 00:41:32,230
hoy se la das declarada como entera

916
00:41:32,230 --> 00:41:34,789
las dos tienen lo mismo dentro

917
00:41:34,789 --> 00:41:37,190
Tiene el 74 en realidad

918
00:41:37,190 --> 00:41:38,489
Las dos tienen lo mismo

919
00:41:38,489 --> 00:41:41,349
Pero cuando tú se la das declarada como char

920
00:41:41,349 --> 00:41:43,929
Él asume que lo que a ti te interesa

921
00:41:43,929 --> 00:41:44,409
Es el char

922
00:41:44,409 --> 00:41:46,929
Porque como la has declarado como char

923
00:41:46,929 --> 00:41:48,750
Asume que te interesa el char

924
00:41:48,750 --> 00:41:50,809
Entonces se va a la tabla ASTI

925
00:41:50,809 --> 00:41:53,570
Ese 74, mira a ver lo que tiene

926
00:41:53,570 --> 00:41:54,250
Y te lo muestra

927
00:41:54,250 --> 00:41:57,170
Pero porque tú al declararlo como char le estás diciendo

928
00:41:57,170 --> 00:41:59,590
Que me interesa la versión char, no la versión int

929
00:41:59,590 --> 00:42:00,630
Es lo mismo

930
00:42:00,630 --> 00:42:02,869
J y 74 son lo mismo

931
00:42:02,869 --> 00:42:04,929
pero J es versión char

932
00:42:04,929 --> 00:42:06,730
74 es versión int

933
00:42:06,730 --> 00:42:09,210
si tú has declarado como char

934
00:42:09,210 --> 00:42:12,269
él asume que te interesa su versión char

935
00:42:12,269 --> 00:42:14,369
pues te lo imprime

936
00:42:14,369 --> 00:42:15,889
aquí en el N

937
00:42:15,889 --> 00:42:18,010
está exactamente lo mismo

938
00:42:18,010 --> 00:42:20,190
los bits que forman 74

939
00:42:20,190 --> 00:42:21,250
lo mismo

940
00:42:21,250 --> 00:42:23,989
pero al haberlo declarado como int

941
00:42:23,989 --> 00:42:26,090
el N que está declarado como int

942
00:42:26,090 --> 00:42:26,650
ahí arriba

943
00:42:26,650 --> 00:42:30,070
él interpreta que la versión que te interesa a ti

944
00:42:30,070 --> 00:42:31,570
es la int, la entera

945
00:42:31,570 --> 00:42:32,389
el número entero

946
00:42:32,389 --> 00:42:33,170
porque lo has declarado

947
00:42:33,170 --> 00:42:33,590
como int

948
00:42:33,590 --> 00:42:34,710
pues por eso

949
00:42:34,710 --> 00:42:35,110
te ha mostrado

950
00:42:35,110 --> 00:42:35,769
el signo de 4

951
00:42:35,769 --> 00:42:37,489
¿vale?

952
00:42:38,269 --> 00:42:39,130
entonces simplemente

953
00:42:39,130 --> 00:42:39,909
cuidado a veces

954
00:42:39,909 --> 00:42:40,809
pues cuando se muestran

955
00:42:40,809 --> 00:42:41,469
caracteres

956
00:42:41,469 --> 00:42:42,230
por consola

957
00:42:42,230 --> 00:42:44,070
los podéis haber guardado

958
00:42:44,070 --> 00:42:44,690
esos caracteres

959
00:42:44,690 --> 00:42:45,130
en un int

960
00:42:45,130 --> 00:42:46,010
claro que podéis haberlos

961
00:42:46,010 --> 00:42:46,630
guardado en un int

962
00:42:46,630 --> 00:42:48,090
pero si los habéis guardado

963
00:42:48,090 --> 00:42:48,610
en un int

964
00:42:48,610 --> 00:42:50,550
le estáis diciendo a Java

965
00:42:50,550 --> 00:42:51,550
que lo que os interesa

966
00:42:51,550 --> 00:42:52,730
es su valor numérico

967
00:42:52,730 --> 00:42:54,409
y si lo habéis guardado

968
00:42:54,409 --> 00:42:54,929
en un char

969
00:42:54,929 --> 00:42:55,949
le estáis diciendo a Java

970
00:42:55,949 --> 00:42:57,369
que lo que os interesa

971
00:42:57,369 --> 00:42:58,510
es su valor imprimible

972
00:42:58,510 --> 00:42:59,690
¿ya está?

973
00:43:00,989 --> 00:43:01,269
¿vale?

974
00:43:01,570 --> 00:43:03,670
Venga, ahora sí que paramos

975
00:43:03,670 --> 00:43:06,110
Luego ya comprobamos lo que has dicho del byte, etc.