1
00:00:01,260 --> 00:00:05,919
estábamos diciendo cositas que podríamos haber puesto mal, ¿vale?

2
00:00:06,019 --> 00:00:08,660
Pues el nombre de identificador, importante.

3
00:00:09,480 --> 00:00:13,119
Cuando uno le dice, muéstrame por consola el contenido de algo,

4
00:00:13,539 --> 00:00:17,260
ese algo tiene que existir y estar declarado previamente, ¿vale?

5
00:00:18,879 --> 00:00:22,320
A ver, cosas también que podemos ir incorporando desde ahora.

6
00:00:23,140 --> 00:00:27,940
Si tú le dices al system.outprint del n o a otra sentencia

7
00:00:27,940 --> 00:00:29,039
desde que vayamos incorporando,

8
00:00:29,719 --> 00:00:32,280
le dices altura así, a palo seco,

9
00:00:33,240 --> 00:00:34,259
tal cual la hemos escrito,

10
00:00:34,939 --> 00:00:36,820
él sabe que tiene que ir a buscar

11
00:00:36,820 --> 00:00:39,520
una variable que se llame altura

12
00:00:39,520 --> 00:00:42,119
para mostrar su contenido,

13
00:00:42,460 --> 00:00:43,759
que es lo que hemos hecho hasta ahora, ¿verdad?

14
00:00:43,820 --> 00:00:44,420
Eso está claro.

15
00:00:45,619 --> 00:00:47,939
Pero, ¿y si yo quiero que por consola

16
00:00:47,939 --> 00:00:51,859
me muestre directamente la palabra altura, tal cual?

17
00:00:52,299 --> 00:00:54,299
O sea, no quiero que me muestre el contenido

18
00:00:54,299 --> 00:00:56,500
de la variable que se llama altura,

19
00:00:56,500 --> 00:00:59,759
Si no quiero que me muestre directamente

20
00:00:59,759 --> 00:01:01,560
La palabra altura

21
00:01:01,560 --> 00:01:03,179
Porque me apetece a mí que mi programa

22
00:01:03,179 --> 00:01:04,379
Me muestre la palabra altura

23
00:01:04,379 --> 00:01:07,260
Así de partida podríamos decir

24
00:01:07,260 --> 00:01:09,640
Uy, tengo aquí una ambigüedad, una confusión

25
00:01:09,640 --> 00:01:11,319
¿Cómo sé

26
00:01:11,319 --> 00:01:13,420
Cuando referirme a la variable

27
00:01:13,420 --> 00:01:15,180
Que se llama altura y por tanto

28
00:01:15,180 --> 00:01:16,000
Su contenido

29
00:01:16,000 --> 00:01:19,420
O cómo sé cuando me estoy

30
00:01:19,420 --> 00:01:21,879
Refiriendo al texto literal

31
00:01:21,879 --> 00:01:22,900
Altura

32
00:01:22,900 --> 00:01:24,180
Que es el que yo quiero mostrar

33
00:01:24,180 --> 00:01:26,180
Tiene que haber alguna forma de distinguir

34
00:01:26,180 --> 00:01:28,420
tiene que haber alguna forma de distinguirlo

35
00:01:28,420 --> 00:01:30,620
no puede ser que exista esa ambigüedad

36
00:01:30,620 --> 00:01:32,620
si os ocurre o os suena

37
00:01:32,620 --> 00:01:35,060
claro

38
00:01:35,060 --> 00:01:36,920
si yo no pongo comillas

39
00:01:36,920 --> 00:01:38,219
aquí no hay ninguna duda

40
00:01:38,219 --> 00:01:40,700
me estoy refiriendo a una variable

41
00:01:40,700 --> 00:01:41,680
que se llama altura

42
00:01:41,680 --> 00:01:45,000
la busco y si está declarada

43
00:01:45,000 --> 00:01:46,900
y tiene su valor

44
00:01:46,900 --> 00:01:47,459
lo muestro

45
00:01:47,459 --> 00:01:50,640
que yo quiero mostrar directamente

46
00:01:50,640 --> 00:01:51,959
el texto altura

47
00:01:51,959 --> 00:01:59,819
pues

48
00:01:59,819 --> 00:02:04,560
lo tengo que poner

49
00:02:04,560 --> 00:02:06,540
entre comillas dobles

50
00:02:06,540 --> 00:02:07,560
vale

51
00:02:07,560 --> 00:02:12,189
entre poner el

52
00:02:12,189 --> 00:02:13,870
un segundín, entre poner el LN

53
00:02:13,870 --> 00:02:15,930
y no ponerlo, esto significa

54
00:02:15,930 --> 00:02:17,469
que una vez que lo ha mostrado

55
00:02:17,469 --> 00:02:19,770
te va a saltar a línea siguiente

56
00:02:19,770 --> 00:02:21,469
para que lo siguiente que muestres

57
00:02:21,469 --> 00:02:22,870
lo haga debajo

58
00:02:22,870 --> 00:02:26,229
y si no pones el LN

59
00:02:26,229 --> 00:02:27,629
y pones el print a palo seco

60
00:02:27,629 --> 00:02:29,310
pues lo siguiente que muestres

61
00:02:29,310 --> 00:02:31,110
no te lo muestra en la siguiente línea

62
00:02:31,110 --> 00:02:33,669
podéis usar las dos, la que os dé la gana

63
00:02:33,669 --> 00:02:36,110
en función de si queréis que salte a la línea siguiente

64
00:02:36,110 --> 00:02:37,810
para el siguiente sistema autónomo, ¿vale?

65
00:02:38,110 --> 00:02:38,330
Dime.

66
00:02:38,509 --> 00:02:41,659
Eso también se puede poner en barra invertida.

67
00:02:42,479 --> 00:02:43,419
Sí, sí, sí.

68
00:02:44,060 --> 00:02:46,520
Barra invertida N es el carácter salto de línea.

69
00:02:46,659 --> 00:02:48,099
Si tú lo pones entre comillas doble,

70
00:02:48,539 --> 00:02:51,180
le estás diciendo, muéstrame por pantalla un salto de línea.

71
00:02:52,020 --> 00:02:52,259
¿Vale?

72
00:02:52,319 --> 00:02:53,639
Pero bueno, en este caso es más cómodo

73
00:02:53,639 --> 00:02:55,520
que tú uses por defecto el...

74
00:02:55,520 --> 00:02:57,080
¿Vale?

75
00:02:57,300 --> 00:02:59,020
Pues entonces, hay una diferencia...

76
00:02:59,020 --> 00:02:59,620
Ay, perdona, dime.

77
00:02:59,919 --> 00:03:02,159
Que cuando creas el marquete,

78
00:03:02,280 --> 00:03:03,620
luego tienes que crear la clase, ¿no?

79
00:03:03,620 --> 00:03:05,400
claro, creas el paquete

80
00:03:05,400 --> 00:03:06,780
dentro del paquete new class

81
00:03:06,780 --> 00:03:09,120
new class

82
00:03:09,120 --> 00:03:13,500
vale, pues entonces, primera cosa

83
00:03:13,500 --> 00:03:15,139
que ya también se nos queda en la cabeza

84
00:03:15,139 --> 00:03:16,039
y no nos olvidamos

85
00:03:16,039 --> 00:03:18,860
algo entre comillas dobles

86
00:03:18,860 --> 00:03:20,419
es ese texto literal

87
00:03:20,419 --> 00:03:23,080
eso es lo que se llama una cadena de texto

88
00:03:23,080 --> 00:03:24,719
es ese texto literal, tal cual

89
00:03:24,719 --> 00:03:26,740
sin las comillas

90
00:03:26,740 --> 00:03:29,340
es una variable

91
00:03:29,340 --> 00:03:30,300
que se llame así

92
00:03:30,300 --> 00:03:35,259
¿vale?

93
00:03:35,259 --> 00:03:44,259
Si yo ejecuto ahora este programa, si yo lo ejecuto ahora, pues me hace lo que preveía que me iba a hacer.

94
00:03:44,780 --> 00:03:54,300
Primero me ha mostrado el texto literal altura, el texto literal, y luego me ha mostrado el contenido de la variable altura, ¿vale?

95
00:03:54,300 --> 00:04:01,060
Y como veis, me lo ha mostrado una línea separada, porque este es el println, que significa,

96
00:04:01,060 --> 00:04:02,680
Sáltame a la siguiente línea

97
00:04:02,680 --> 00:04:04,740
Después de haber mostrado

98
00:04:04,740 --> 00:04:07,000
Si yo no hubiera puesto

99
00:04:07,000 --> 00:04:08,620
El LN

100
00:04:08,620 --> 00:04:12,659
Me lo habría sacado todo seguido

101
00:04:12,659 --> 00:04:16,660
¿Veis?

102
00:04:16,699 --> 00:04:17,980
Me lo habría sacado todo seguido

103
00:04:17,980 --> 00:04:20,600
System Print me muestra el texto altura

104
00:04:20,600 --> 00:04:22,519
Al no tener el LN

105
00:04:22,519 --> 00:04:24,360
No me ha saltado a la línea siguiente

106
00:04:24,360 --> 00:04:27,160
Con lo cual el siguiente System Print

107
00:04:27,160 --> 00:04:30,060
Que me muestra el 13

108
00:04:30,060 --> 00:04:32,399
Me lo muestra completamente pegado

109
00:04:32,399 --> 00:04:33,339
¿Vale?

110
00:04:35,220 --> 00:04:35,699
Muy feo.

111
00:04:37,459 --> 00:04:39,040
Con esto lo dejo más bonito, vale.

112
00:04:41,199 --> 00:04:44,879
Bueno, esto es solo para que incorporemos ya esta sentencia para mostrar cosas.

113
00:04:45,060 --> 00:04:49,360
Porque si no la tenemos desde ya, ¿cómo vemos el resultado de nuestros códigos?

114
00:04:49,500 --> 00:04:54,399
No podemos verlo de ninguna manera porque no sabemos ni mandar a fichero, ni a bases de datos, ni nada.

115
00:04:55,060 --> 00:05:02,839
Entonces nuestra única forma ahora mismo de ver el resultado de nuestros programas es la sentencia system.out.println.

116
00:05:02,839 --> 00:05:05,860
¿por qué se escribe tan rara con estos

117
00:05:05,860 --> 00:05:06,980
puntos y de esta manera?

118
00:05:07,879 --> 00:05:09,819
de nuevo es algo que todavía no podemos entender

119
00:05:09,819 --> 00:05:11,819
porque tiene estrictamente

120
00:05:11,819 --> 00:05:13,740
que ver con la programación orientada a objetos

121
00:05:13,740 --> 00:05:15,139
entonces ahora mismo

122
00:05:15,139 --> 00:05:17,699
quedémonos

123
00:05:17,699 --> 00:05:19,939
con que para mostrar por consola yo escribo

124
00:05:19,939 --> 00:05:21,120
esto y se acabó

125
00:05:21,120 --> 00:05:24,680
bueno

126
00:05:24,680 --> 00:05:27,379
¿qué más cosas podría yo haber hecho

127
00:05:27,379 --> 00:05:29,420
que me generaran un error

128
00:05:29,420 --> 00:05:31,180
de compilación y que me dijera

129
00:05:31,180 --> 00:05:33,079
el precompilador

130
00:05:33,079 --> 00:05:54,500
Construí esto, esto no, esto no me lo trago. Pues imaginaos que a mí se me ha quedado el dedo ahí pegado en el 3. Esto es un número entero. ¿Por qué te quejas? ¿No? Dice, ¿por qué te quejas si es un número entero? ¿O es que este no es un número entero? Claro que lo es.

131
00:05:54,500 --> 00:05:55,420
pero es muy grande

132
00:05:55,420 --> 00:05:58,519
efectivamente, dice, sí, claro que es un número entero

133
00:05:58,519 --> 00:05:59,420
pero perdona

134
00:05:59,420 --> 00:06:01,540
yo tengo 32 bits

135
00:06:01,540 --> 00:06:03,800
esto no cabe, 32 bits

136
00:06:03,800 --> 00:06:05,600
lo siento, no puedo

137
00:06:05,600 --> 00:06:08,439
guardarme ahí, pues por eso ha saltado

138
00:06:08,439 --> 00:06:10,000
¿vale?

139
00:06:16,990 --> 00:06:18,810
mensaje, esta vez tiene sentido

140
00:06:18,810 --> 00:06:21,110
¿vale? o sea, las cosas que estamos

141
00:06:21,110 --> 00:06:22,850
haciendo ahora, como son muy básicas

142
00:06:22,850 --> 00:06:24,810
el compilador acierta

143
00:06:24,810 --> 00:06:26,689
con las cosas que nos dice, tiene sentido

144
00:06:26,689 --> 00:06:28,850
me dice, perdóname, pero esto

145
00:06:28,850 --> 00:06:31,850
está fuera de los rangos

146
00:06:31,850 --> 00:06:33,810
que yo puedo manejar con int, ¿vale?

147
00:06:33,850 --> 00:06:35,189
Está fuera de los rangos, ¿vale?

148
00:06:45,699 --> 00:06:47,160
Llegará un momento en que el rojo

149
00:06:47,160 --> 00:06:48,100
desaparecerá.

150
00:06:54,589 --> 00:06:55,110
Ahí era.

151
00:06:56,850 --> 00:06:57,569
Este ya no.

152
00:06:58,329 --> 00:07:00,949
Esto ya sí se puede codificar en 32 bits.

153
00:07:02,029 --> 00:07:02,689
Esto sí,

154
00:07:02,829 --> 00:07:04,350
por ejemplo. Este sí cabe

155
00:07:04,350 --> 00:07:06,110
en 32 bits, ¿vale?

156
00:07:09,370 --> 00:07:10,550
Tenemos que sabernos

157
00:07:10,550 --> 00:07:12,589
de memoria, cuáles

158
00:07:12,589 --> 00:07:14,529
son los valores máximos

159
00:07:14,529 --> 00:07:16,470
que caben en un int, en un long

160
00:07:16,470 --> 00:07:18,449
en un... hombre pues no hace falta

161
00:07:18,449 --> 00:07:20,610
porque uno los puede consultar

162
00:07:20,610 --> 00:07:21,230
rápidamente

163
00:07:21,230 --> 00:07:23,649
¿vale?

164
00:07:24,250 --> 00:07:26,370
hay una forma rápida de verlo aquí en java

165
00:07:26,370 --> 00:07:28,550
pero bueno, no quiero ahora mezclar unas cosas con

166
00:07:28,550 --> 00:07:30,670
otras, pero si vosotros

167
00:07:30,670 --> 00:07:32,529
hacéis 2 elevado a 31

168
00:07:32,529 --> 00:07:34,509
pues es el mayor número que

169
00:07:34,509 --> 00:07:35,949
puedes hacer en 32 bits

170
00:07:35,949 --> 00:07:38,889
porque claro, como uno de los bits es para el signo

171
00:07:38,889 --> 00:07:42,189
con 32 bits, si 1 es para el signo

172
00:07:42,189 --> 00:07:43,310
positivo o negativo

173
00:07:43,310 --> 00:07:45,810
solo te valen para valor absoluto

174
00:07:45,810 --> 00:07:47,870
los 31 restantes, con lo cual

175
00:07:47,870 --> 00:07:49,750
2 elevado a 31 es lo más

176
00:07:49,750 --> 00:07:51,850
que vas a poder codificar en

177
00:07:51,850 --> 00:07:53,209
en un int

178
00:07:53,209 --> 00:07:55,350
lo que de ese número

179
00:07:55,350 --> 00:07:57,670
bueno

180
00:07:57,670 --> 00:08:00,250
ahora mismo

181
00:08:00,250 --> 00:08:01,810
que más errores nos podrían haber salido

182
00:08:01,810 --> 00:08:03,750
que mal podríamos haber escrito aquí mal

183
00:08:03,750 --> 00:08:06,029
pues hombre, por supuesto, imaginaos que yo

184
00:08:06,029 --> 00:08:07,910
a altura voy y le digo

185
00:08:07,910 --> 00:08:10,269
altura, esto

186
00:08:10,269 --> 00:08:12,209
me dice, pero ¿qué le estás

187
00:08:12,209 --> 00:08:13,250
asignando tu altura?

188
00:08:13,930 --> 00:08:16,209
¿qué altura es int? que solo puedes

189
00:08:16,209 --> 00:08:18,370
un número entero que quepa en 32 bits

190
00:08:18,370 --> 00:08:19,550
¿esto qué es?

191
00:08:20,610 --> 00:08:22,050
entonces cada vez que una sentencia

192
00:08:22,050 --> 00:08:24,269
de asignación, tú intentes

193
00:08:24,269 --> 00:08:25,769
asignar algo

194
00:08:25,769 --> 00:08:27,290
que no es

195
00:08:27,290 --> 00:08:30,170
lo que está capacitado para recibir

196
00:08:30,170 --> 00:08:31,550
siempre te va a dar ese error

197
00:08:31,550 --> 00:08:34,129
¿esto qué es? un texto literal

198
00:08:34,129 --> 00:08:35,710
ya sabemos ahora

199
00:08:35,710 --> 00:08:39,490
que algo entre comillas dobles es un texto tal cual literal.

200
00:08:40,230 --> 00:08:42,429
Pues un texto literal no es un número.

201
00:08:42,870 --> 00:08:46,929
No tiene ningún sentido que yo un texto literal lo ponga en una variable número.

202
00:08:47,210 --> 00:08:48,850
Aquí solo puedo poner números.

203
00:08:49,990 --> 00:08:59,980
Bueno, pues ahora sí, vamos a seguir viendo los tipos de datos ya para completar.

204
00:09:04,799 --> 00:09:13,460
Hemos visto, vale, a ver un momentito.

205
00:09:30,259 --> 00:09:31,799
vale

206
00:09:31,799 --> 00:09:38,450
adiós

207
00:09:38,450 --> 00:09:40,669
vale, pues entonces

208
00:09:40,669 --> 00:09:44,570
¿qué más datos podemos necesitar

209
00:09:44,570 --> 00:09:46,210
guardar nosotros? números enteros

210
00:09:46,210 --> 00:09:48,230
siempre básico, números enteros siempre hay que guardar

211
00:09:48,230 --> 00:09:49,509
ya sabemos cómo guardarlos

212
00:09:49,509 --> 00:09:52,330
¿vale? lógicamente nos faltan

213
00:09:52,330 --> 00:09:54,389
matices sobre muchas cosas, pero esos ya

214
00:09:54,389 --> 00:09:56,289
irán apareciendo, lo básico para

215
00:09:56,289 --> 00:09:57,730
guardar un número entero ya lo sabemos

216
00:09:57,730 --> 00:10:00,169
vale, pero con los números enteros

217
00:10:00,169 --> 00:10:01,230
no lo

218
00:10:01,230 --> 00:10:19,389
Pero no lo tenemos todo resuelto. También usamos a menudo los números decimales, ¿verdad? Los números reales con coma de toda la vida. Bueno, pues ¿cuál es el tipo de dato para guardar números decimales? Tenemos dos posibilidades en realidad. Tenemos dos.

219
00:10:19,389 --> 00:10:36,029
Una es el tipo float y otra es el tipo double, ¿vale? Ambos son para guardar números decimales. ¿En qué se diferencia uno de otro?

220
00:10:36,029 --> 00:10:39,129
en la precisión

221
00:10:39,129 --> 00:10:40,169
de la parte decimal

222
00:10:40,169 --> 00:10:44,159
¿vale? el float

223
00:10:44,159 --> 00:10:46,559
usa 32 bits

224
00:10:46,559 --> 00:10:48,179
y una codificación

225
00:10:48,179 --> 00:10:50,120
de punto flotante patatín

226
00:10:50,120 --> 00:10:51,019
patatín

227
00:10:51,019 --> 00:10:54,519
un tipo de codificación muy complicado

228
00:10:54,519 --> 00:10:56,139
de entender, que ni vais a estudiar

229
00:10:56,139 --> 00:10:57,460
en sistemas operativos ni nada

230
00:10:57,460 --> 00:10:59,980
el dabble usa 64 bits

231
00:10:59,980 --> 00:11:02,460
y una forma de codificar los decimales

232
00:11:02,460 --> 00:11:04,279
¿en qué se traduce para nosotros?

233
00:11:05,019 --> 00:11:06,320
que el dabble admite

234
00:11:06,320 --> 00:11:08,559
mucha más precisión de decimales

235
00:11:08,559 --> 00:11:09,940
un montón de

236
00:11:09,940 --> 00:11:12,320
dígitos en la parte

237
00:11:12,320 --> 00:11:14,279
decimal, entonces si necesitamos una precisión

238
00:11:14,279 --> 00:11:15,279
más alta, el double

239
00:11:15,279 --> 00:11:18,100
no necesitamos tanta precisión

240
00:11:18,100 --> 00:11:19,940
el flow, y ya está

241
00:11:19,940 --> 00:11:22,139
cualquiera de los dos se usa

242
00:11:22,139 --> 00:11:23,340
con bastante

243
00:11:23,340 --> 00:11:25,539
asiduidad

244
00:11:25,539 --> 00:11:27,940
no es que haya uno que se use más que otro, tampoco

245
00:11:27,940 --> 00:11:29,720
son los dos muy usados

246
00:11:29,720 --> 00:11:31,720
la verdad es que

247
00:11:31,720 --> 00:11:34,259
yo siempre uso double cuando

248
00:11:34,259 --> 00:11:36,080
trabajo con números reales y bueno

249
00:11:36,080 --> 00:11:37,980
es bastante habitual directamente usar

250
00:11:37,980 --> 00:11:39,779
DAB, tiene más precisión

251
00:11:39,779 --> 00:11:40,600
y ya está

252
00:11:40,600 --> 00:11:43,360
y para completar los tipos de datos

253
00:11:43,360 --> 00:11:46,080
antes de abrir el eclipse para hacer más ejemplos

254
00:11:47,019 --> 00:11:50,220
¿qué más cosas puedo yo

255
00:11:50,220 --> 00:11:51,779
almacenar en mis variables en RAM?

256
00:11:52,559 --> 00:11:53,580
pues me permite

257
00:11:53,580 --> 00:11:54,940
almacenar JAB

258
00:11:54,940 --> 00:11:58,139
un único carácter también

259
00:11:58,139 --> 00:12:01,620
un único carácter, punto pelota

260
00:12:01,620 --> 00:12:04,019
en ese espacio en memoria que me hable

261
00:12:04,019 --> 00:12:04,559
en la RAM

262
00:12:04,559 --> 00:12:09,210
un único carácter

263
00:12:09,210 --> 00:12:10,029
vale

264
00:12:10,029 --> 00:12:13,309
entonces ese tipo para un único carácter

265
00:12:13,309 --> 00:12:14,570
el A, el B

266
00:12:14,570 --> 00:12:16,710
la interrogación, el carácter que sea

267
00:12:16,710 --> 00:12:19,129
ese tipo es el tipo

268
00:12:19,129 --> 00:12:20,350
char

269
00:12:20,350 --> 00:12:21,629
vale

270
00:12:21,629 --> 00:12:26,730
el tipo char vale, ahora lo vemos con

271
00:12:26,730 --> 00:12:28,450
ejemplos porque igual es un poco más

272
00:12:28,450 --> 00:12:29,830
confuso de entender a veces

273
00:12:29,830 --> 00:12:32,190
para guardar un carácter

274
00:12:32,190 --> 00:12:34,649
un carácter es cualquier cosa

275
00:12:34,649 --> 00:12:36,710
que sea un carácter de los que escribimos

276
00:12:36,710 --> 00:12:38,629
en un ordenador

277
00:12:38,629 --> 00:12:41,210
C, B, el salto de línea

278
00:12:41,210 --> 00:12:42,450
es un carácter también

279
00:12:42,450 --> 00:12:44,149
la interrogación, el guión

280
00:12:44,149 --> 00:12:45,730
todo eso son caracteres

281
00:12:45,730 --> 00:12:48,129
pues yo puedo guardar

282
00:12:48,129 --> 00:12:49,690
uno y solo uno

283
00:12:49,690 --> 00:12:51,710
en las variables de tipo char

284
00:12:51,710 --> 00:12:56,059
¿y falta algún tipo de dato?

285
00:12:56,179 --> 00:12:57,779
pues sí, porque dijimos que eran ocho

286
00:12:57,779 --> 00:13:00,179
y hemos visto siete

287
00:13:00,179 --> 00:13:02,860
falta uno

288
00:13:02,860 --> 00:13:09,679
que es el tipo boolean

289
00:13:09,679 --> 00:13:15,500
Bueno, pues una variable de tipo Boolean

290
00:13:15,500 --> 00:13:20,159
Solo puede guardarme dos posibles valores

291
00:13:20,159 --> 00:13:22,159
Que son

292
00:13:22,159 --> 00:13:24,500
¿Verdad o mentira?

293
00:13:25,080 --> 00:13:25,519
Ya está

294
00:13:25,519 --> 00:13:27,720
Lo que viene a ser

295
00:13:27,720 --> 00:13:30,480
En inglés

296
00:13:30,480 --> 00:13:32,899
True o false

297
00:13:32,899 --> 00:13:37,350
Solo me puede guardar esas dos cosas

298
00:13:37,350 --> 00:13:38,090
O una o la otra

299
00:13:38,090 --> 00:13:41,049
No puede tener otra cosa diferente a true o false

300
00:13:41,049 --> 00:13:41,629
Esa variable

301
00:13:41,629 --> 00:13:44,610
no es como los números enteros

302
00:13:44,610 --> 00:13:47,169
que pueden tener tropecientas cosas distintas

303
00:13:47,169 --> 00:13:48,929
27, menos 12

304
00:13:48,929 --> 00:13:51,269
14.000, pueden tener mil cosas diferentes

305
00:13:51,269 --> 00:13:53,169
o no es como

306
00:13:53,169 --> 00:13:55,049
la variable char, que puede tener un montón de cosas

307
00:13:55,049 --> 00:13:56,889
a veces puede tener una A, a veces una C

308
00:13:56,889 --> 00:13:59,370
a veces una J, esas posibilidades

309
00:13:59,370 --> 00:14:01,090
no, el boolean

310
00:14:01,090 --> 00:14:03,429
solo puede tener dos cosas

311
00:14:03,429 --> 00:14:05,289
o tiene true o tiene false

312
00:14:05,289 --> 00:14:06,289
ya está

313
00:14:06,289 --> 00:14:09,570
para números

314
00:14:09,570 --> 00:14:10,669
con parte de final

315
00:14:10,669 --> 00:14:14,370
No, esos son números enteros

316
00:14:14,370 --> 00:14:16,970
Claro, números enteros

317
00:14:16,970 --> 00:14:17,990
¿Vale?

318
00:14:18,549 --> 00:14:19,570
Números enteros

319
00:14:19,570 --> 00:14:22,269
Vale, entonces

320
00:14:22,269 --> 00:14:24,830
La variable boolean, como ya iremos viendo

321
00:14:24,830 --> 00:14:28,529
Sirve para guardar

322
00:14:28,529 --> 00:14:30,250
Lo que llamamos

323
00:14:30,250 --> 00:14:31,529
Condiciones

324
00:14:31,529 --> 00:14:34,970
Porque ¿qué es lo que puede ser verdad o mentira?

325
00:14:35,429 --> 00:14:35,970
En el mundo

326
00:14:35,970 --> 00:14:37,450
Las condiciones

327
00:14:37,450 --> 00:14:39,769
Una condición

328
00:14:39,769 --> 00:15:01,450
Solo tiene dos opciones. O se cumple o no se cumple. Las cosas no se cumplen a medias en informática y en programación. Una condición. Llueve. O llueve o no llueve. A medias no estamos. ¿Vale? Es martes. O es verdad o es mentira. Pero no estamos a medias.

329
00:15:01,450 --> 00:15:30,950
O sea, las condiciones son cosas que o se cumplen o no se cumplen, no hay tutía, ¿vale? Eso es un portátil, ¿eso es verdad o es mentira? Depende, no sé, si es un portátil será verdad y si no lo es será mentira, ¿vale? Las condiciones, lo que llamamos condiciones, que todos sabemos lo que es una condición, un enunciado del tipo, mañana va a llover, esa pizarra es verde, tengo hambre, enunciados de ese tipo, se pueden o cumplir o no cumplir, ser verdad o ser mentira.

330
00:15:30,950 --> 00:15:47,509
Luego una condición solo tiene dos posibilidades, ser verdad o ser mentira, punto pelota. Pues precisamente las variables boolean valen para guardar condiciones, porque las condiciones solo tienen dos posibilidades, o son verdad o son mentira.

331
00:15:47,509 --> 00:15:49,529
y son muy útiles

332
00:15:49,529 --> 00:15:51,850
porque en un programa

333
00:15:51,850 --> 00:15:53,409
hay un montón de cosas

334
00:15:53,409 --> 00:15:55,909
que se hacen en función de si una condición

335
00:15:55,909 --> 00:15:57,070
se cumple o no se cumple

336
00:15:57,070 --> 00:15:59,409
entonces el manejo de Boolean

337
00:15:59,409 --> 00:16:00,710
es básico

338
00:16:00,710 --> 00:16:03,870
porque las condiciones son básicas

339
00:16:03,870 --> 00:16:04,929
en un programa

340
00:16:04,929 --> 00:16:07,690
como iremos incorporando

341
00:16:07,690 --> 00:16:08,350
lógicamente

342
00:16:08,350 --> 00:16:11,330
ahora lo digo para que entendáis

343
00:16:11,330 --> 00:16:13,830
por qué aparece eso, por qué aparece un tipo tan raro

344
00:16:13,830 --> 00:16:15,269
para guardar verdad o mentira

345
00:16:15,269 --> 00:16:16,669
¿por qué pinta guardar verdad o mentira?

346
00:16:16,669 --> 00:16:19,009
para qué me interesa a mí guardar verdad o mentira

347
00:16:19,009 --> 00:16:19,690
en una variable

348
00:16:19,690 --> 00:16:22,590
pues me interesa porque verdad o mentira

349
00:16:22,590 --> 00:16:24,610
son las dos posibilidades

350
00:16:24,610 --> 00:16:26,289
que puede tener

351
00:16:26,289 --> 00:16:28,110
en su interior una condición

352
00:16:28,110 --> 00:16:30,129
o es verdad o es mentira

353
00:16:30,129 --> 00:16:32,789
y como las condiciones son cosas

354
00:16:32,789 --> 00:16:34,789
que usamos continuamente en nuestros

355
00:16:34,789 --> 00:16:36,750
programas, pues guardemos

356
00:16:36,750 --> 00:16:38,830
esas condiciones en variables boolean

357
00:16:38,830 --> 00:16:40,730
que son las que pueden

358
00:16:40,730 --> 00:16:42,110
tener dos valores

359
00:16:42,110 --> 00:16:43,830
o te cumplas o no te cumplas

360
00:16:43,830 --> 00:16:45,889
y ahí viene esa variable

361
00:16:45,889 --> 00:17:25,269
Muy bien. Vale, pues ahora vamos a practicar un poco con ellas aquí para acabar de entenderlas. A ver, abrimos nuestro eclipse otra vez. Ahí. Vale. Vale, entonces variables enteras, pues un poquito su manejo.

362
00:17:25,269 --> 00:18:09,579
Venga, pues ahora vamos a declarar, a ver, voy a poner aquí variables enteras, vale, variables decimales, vale, pues por ejemplo, declaro yo mi variable decimal, double, lo que, cualquier cosa, vale, double número, ya está, una declaración de variable perfectamente válida.

363
00:18:09,700 --> 00:18:12,240
quiero asignarle un valor

364
00:18:12,240 --> 00:18:16,059
la sentencia de asignación

365
00:18:16,059 --> 00:18:17,779
ya sabemos exactamente como es

366
00:18:17,779 --> 00:18:20,380
la variable en la que le quiero asignar

367
00:18:20,380 --> 00:18:22,119
seguido del operador

368
00:18:22,119 --> 00:18:22,839
de asignación

369
00:18:22,839 --> 00:18:25,980
y el valor que yo quiera asignarle

370
00:18:25,980 --> 00:18:27,619
el valor que yo quiera asignarle

371
00:18:27,619 --> 00:18:29,700
valor compatible

372
00:18:29,700 --> 00:18:31,019
con double

373
00:18:31,019 --> 00:18:34,799
vale

374
00:18:34,799 --> 00:18:41,859
esta asignación debe ser que es válida

375
00:18:41,859 --> 00:18:44,180
porque el compilador

376
00:18:44,180 --> 00:18:46,220
no se ha quejado, debe ser que es válida

377
00:18:46,220 --> 00:18:49,819
¿Os parece que es válida?

378
00:18:54,940 --> 00:18:56,319
Claro, y 65 no lo es

379
00:18:56,319 --> 00:18:57,799
65,0

380
00:18:57,799 --> 00:19:01,160
Todos los enteros son números decimales

381
00:19:01,160 --> 00:19:01,599
Todos

382
00:19:01,599 --> 00:19:05,319
Los números enteros son un subconjunto

383
00:19:05,319 --> 00:19:06,440
De los números decimales

384
00:19:06,440 --> 00:19:08,200
Entonces

385
00:19:08,200 --> 00:19:10,400
Yo pongo 65

386
00:19:10,400 --> 00:19:12,279
¿Y qué hace él?

387
00:19:13,160 --> 00:19:14,559
Como ve que va a un double

388
00:19:14,559 --> 00:19:17,519
En lugar de codificarlo como entero en binario

389
00:19:17,519 --> 00:19:20,119
Lo codifica con su parte decimal

390
00:19:20,119 --> 00:19:21,500
Siendo su parte decimal

391
00:19:21,500 --> 00:19:23,599
coma cero, lo codifica como

392
00:19:23,599 --> 00:19:25,339
dabel y dice, me has dado

393
00:19:25,339 --> 00:19:27,519
65, como vas a un dabel

394
00:19:27,519 --> 00:19:29,619
deduzco que es 65 coma cero

395
00:19:29,619 --> 00:19:31,420
y te lo codifico como

396
00:19:31,420 --> 00:19:33,579
decimal, con parte decimal coma cero

397
00:19:33,579 --> 00:19:34,359
y te lo guardo aquí

398
00:19:34,359 --> 00:19:37,440
luego esto es válido, ¿vale? lo que pasa es que

399
00:19:37,440 --> 00:19:39,740
va a estar guardado

400
00:19:39,740 --> 00:19:41,660
y codificado de una manera diferente

401
00:19:41,660 --> 00:19:43,339
a cuando yo lo guardaba en altura

402
00:19:43,339 --> 00:19:45,819
es decir, si yo hago esto

403
00:19:45,819 --> 00:19:47,279
altura que era entero

404
00:19:47,279 --> 00:19:53,869
en estas dos sentencias

405
00:19:53,869 --> 00:19:54,750
en ambas

406
00:19:54,750 --> 00:19:57,930
se ha guardado en la variable correspondiente

407
00:19:57,930 --> 00:19:58,589
el 65

408
00:19:58,589 --> 00:20:00,190
y ya está

409
00:20:00,190 --> 00:20:03,009
pero en la de arriba el 65

410
00:20:03,009 --> 00:20:04,769
se ha codificado en decimal

411
00:20:04,769 --> 00:20:07,210
con el coma cero

412
00:20:07,210 --> 00:20:09,710
y en el de abajo se ha codificado en binario

413
00:20:09,710 --> 00:20:10,329
como entero

414
00:20:10,329 --> 00:20:13,089
pero eso nos importa nada

415
00:20:13,089 --> 00:20:15,569
que más nos da como lo codifique

416
00:20:15,569 --> 00:20:16,450
él internamente

417
00:20:16,450 --> 00:20:18,950
nos da igual, a nosotros nos importa

418
00:20:18,950 --> 00:20:20,349
que en número está el 65

419
00:20:20,349 --> 00:20:22,089
y en altura está el 65

420
00:20:22,089 --> 00:20:23,690
¿vale?

421
00:20:23,690 --> 00:20:26,309
internamente está codificado distinto

422
00:20:26,309 --> 00:20:28,589
porque esta está en dabel y esta está en in

423
00:20:28,589 --> 00:20:30,190
pero eso a los dos nos da un poco igual

424
00:20:30,190 --> 00:20:33,769
vamos a mostrar ahora

425
00:20:33,769 --> 00:20:35,970
las dos variables estas

426
00:20:35,970 --> 00:20:40,920
voy a mostrar primero altura

427
00:20:40,920 --> 00:20:44,240
y voy a mostrar luego

428
00:20:44,240 --> 00:20:46,839
número

429
00:20:46,839 --> 00:20:55,009
si

430
00:20:55,009 --> 00:20:56,890
eso es un aviso, significa que la

431
00:20:56,890 --> 00:20:59,589
en cuanto a que la variable todavía no la has usado

432
00:20:59,589 --> 00:21:01,470
las

433
00:21:01,470 --> 00:21:04,130
los subrayados amarillos

434
00:21:04,130 --> 00:21:06,630
son como sugerencias de que

435
00:21:06,630 --> 00:21:08,609
sintácticamente esté bien

436
00:21:08,609 --> 00:21:10,670
pero no acabo de ver yo la utilidad

437
00:21:10,670 --> 00:21:12,470
de esto, entonces te salía porque todavía

438
00:21:12,470 --> 00:21:13,890
no habías usado la variable y te decía

439
00:21:13,890 --> 00:21:16,789
creas una variable en cuanto la hayas usado

440
00:21:16,789 --> 00:21:18,309
te desaparece el amarillo

441
00:21:18,309 --> 00:21:22,269
¿vale? entonces

442
00:21:22,269 --> 00:21:24,950
vamos a ejecutar

443
00:21:24,950 --> 00:21:25,990
este programa ahora

444
00:21:25,990 --> 00:21:28,609
nos debería mostrar 2.65

445
00:21:28,609 --> 00:21:30,990
¿verdad? vamos a ejecutarlo

446
00:21:30,990 --> 00:21:33,690
espera, voy a poner el n aquí

447
00:21:33,690 --> 00:21:35,009
que si no queda muy mezclado

448
00:21:35,009 --> 00:21:41,190
¿vale?

449
00:21:41,990 --> 00:21:42,630
pues sí

450
00:21:42,630 --> 00:21:45,369
me ha mostrado dos 65

451
00:21:45,369 --> 00:21:46,930
pero fijaos lo que ha hecho

452
00:21:46,930 --> 00:21:49,450
en el system.println altura

453
00:21:49,450 --> 00:21:51,130
que es entero

454
00:21:51,130 --> 00:21:53,009
me ha mostrado el 65

455
00:21:53,009 --> 00:21:54,910
porque tiene un entero 65

456
00:21:54,910 --> 00:21:57,369
sin embargo, cuando yo he mostrado

457
00:21:57,369 --> 00:21:59,349
número, como número

458
00:21:59,349 --> 00:22:01,430
lo ha guardado con su parte

459
00:22:01,430 --> 00:22:03,230
decimal, porque lo ha guardado en double

460
00:22:03,230 --> 00:22:05,250
y double tiene su parte decimal

461
00:22:05,250 --> 00:22:07,970
pues lo ha guardado como 65,0

462
00:22:07,970 --> 00:22:10,250
porque en los DABEL y en los LOAD

463
00:22:10,250 --> 00:22:12,890
existe la parte decimal

464
00:22:12,890 --> 00:22:15,150
entonces cuando yo lo he mostrado

465
00:22:15,150 --> 00:22:18,289
ahora ya me ha mostrado el 65,0

466
00:22:18,289 --> 00:22:20,069
porque lo ha guardado como decimal

467
00:22:20,069 --> 00:22:21,089
con su parte decimal

468
00:22:21,089 --> 00:22:21,910
¿vale?

469
00:22:23,569 --> 00:22:25,930
pero bueno, efectos prácticos de operar

470
00:22:25,930 --> 00:22:27,990
van a ser los números iguales

471
00:22:27,990 --> 00:22:28,490
lógicamente

472
00:22:28,490 --> 00:22:30,710
65,0

473
00:22:30,710 --> 00:22:37,619
que yo quiero poner un número con parte decimal

474
00:22:37,619 --> 00:22:42,980
Pues se lo pongo tranquilamente

475
00:22:42,980 --> 00:22:50,740
Número igual a 75, y la coma famosa es punto

476
00:22:50,740 --> 00:22:52,740
En nuestro caso

477
00:22:52,740 --> 00:22:58,200
¿Vale? Cuando yo quiero ya especificar una parte decimal

478
00:22:58,200 --> 00:23:00,660
Para un double o para un float

479
00:23:00,660 --> 00:23:02,400
¿Vale?

480
00:23:05,220 --> 00:23:06,940
Pongo el punto, lo pongo como

481
00:23:06,940 --> 00:23:08,440
¿Vale?

482
00:23:08,440 --> 00:23:11,880
bueno pues aquí esta es una asignación

483
00:23:11,880 --> 00:23:13,940
que va, encaja en double perfectamente

484
00:23:13,940 --> 00:23:20,799
lógicamente este numerito

485
00:23:20,799 --> 00:23:22,380
en altura no encajaría

486
00:23:22,380 --> 00:23:30,339
esto ya si que no

487
00:23:30,339 --> 00:23:31,319
normal

488
00:23:31,319 --> 00:23:33,380
el compilador me dice

489
00:23:33,380 --> 00:23:36,319
esto es un número con parte decimal

490
00:23:36,319 --> 00:23:38,299
yo no puedo guardar

491
00:23:38,299 --> 00:23:40,819
en una variable que has declarado de tipo entero

492
00:23:40,819 --> 00:23:42,559
algo que no sea

493
00:23:42,559 --> 00:23:43,440
un número entero

494
00:23:43,440 --> 00:23:46,599
porque no puedo, porque yo solo guardo

495
00:23:46,599 --> 00:23:48,579
números enteros, este es un número

496
00:23:48,579 --> 00:23:49,619
con parte decimal

497
00:23:49,619 --> 00:23:51,799
no puede ir en altura

498
00:23:51,799 --> 00:23:54,339
¿vale? ahí sí que se queja el compilador

499
00:23:54,339 --> 00:23:56,160
como debe ser

500
00:23:56,160 --> 00:23:58,420
aquí sin embargo

501
00:23:58,420 --> 00:23:59,339
no se ha quejado

502
00:23:59,339 --> 00:24:01,940
porque 65

503
00:24:01,940 --> 00:24:04,220
es un entero pero

504
00:24:04,220 --> 00:24:06,940
también es un decimal, porque 65

505
00:24:06,940 --> 00:24:08,579
también se puede ver

506
00:24:08,579 --> 00:24:10,000
como 65,0

507
00:24:10,000 --> 00:24:10,819
también vale

508
00:24:10,819 --> 00:24:13,980
entonces cuando a un double le asignas

509
00:24:13,980 --> 00:24:15,819
un int, a un decimal

510
00:24:15,819 --> 00:24:17,480
le asignas un entero, no hay ningún problema

511
00:24:17,480 --> 00:24:21,059
la máquina virtual hace

512
00:24:21,059 --> 00:24:22,880
lo que se llama

513
00:24:22,880 --> 00:24:25,140
pero bueno, tampoco quiero olvidaros ahora con tecnología

514
00:24:25,140 --> 00:24:26,460
la promoción automática

515
00:24:26,460 --> 00:24:28,920
que es, me has dado

516
00:24:28,920 --> 00:24:31,559
65 para guardar en un decimal

517
00:24:31,559 --> 00:24:33,220
no tengo ningún problema

518
00:24:33,220 --> 00:24:34,779
lo voy a guardar en un decimal

519
00:24:34,779 --> 00:24:37,160
y me invento yo el coma cero

520
00:24:37,160 --> 00:24:39,460
porque el coma cero no te molesta a ti para nada

521
00:24:39,460 --> 00:24:40,519
ese coma cero

522
00:24:40,519 --> 00:24:42,960
pero lo contrario no lo hace

523
00:24:42,960 --> 00:24:45,200
porque le quitaría información

524
00:24:45,200 --> 00:24:47,799
lo contrario, tú le das un decimal

525
00:24:47,799 --> 00:24:49,279
para que lo guarden un entero

526
00:24:49,279 --> 00:24:51,579
podría

527
00:24:51,579 --> 00:24:53,700
Java haberse inventado que dijera

528
00:24:53,700 --> 00:24:56,160
pues me como la parte decimal

529
00:24:56,160 --> 00:24:58,440
y guardo el segundo 54

530
00:24:58,440 --> 00:25:00,059
podría inventárselo

531
00:25:00,059 --> 00:25:01,359
pero es que sería ya quitar

532
00:25:01,359 --> 00:25:03,119
la información que tú has dado

533
00:25:03,119 --> 00:25:05,359
a ti te puede importar mucho ese coma 8

534
00:25:05,359 --> 00:25:06,160
no me lo quites

535
00:25:06,160 --> 00:25:10,240
entonces, número entero a variable decimal

536
00:25:10,240 --> 00:25:11,180
ningún problema

537
00:25:11,180 --> 00:25:12,819
porque

538
00:25:12,819 --> 00:25:15,420
el programa, la máquina virtual

539
00:25:15,420 --> 00:25:17,200
te añade el coma cero directamente

540
00:25:17,200 --> 00:25:19,359
número decimal

541
00:25:19,359 --> 00:25:21,559
a variable entera, no puedes

542
00:25:21,559 --> 00:25:23,500
porque tendría

543
00:25:23,500 --> 00:25:25,500
que cargarse información

544
00:25:25,500 --> 00:25:27,500
que es la parte decimal y eso no lo va a hacer

545
00:25:27,500 --> 00:25:29,319
¿vale?

546
00:25:33,799 --> 00:25:34,359
vale

547
00:25:34,359 --> 00:25:39,690
esto lógicamente no se puede

548
00:25:39,690 --> 00:25:50,809
a ver

549
00:25:50,809 --> 00:25:53,329
boolean antes de ir a char

550
00:25:53,329 --> 00:25:54,529
¿vale?

551
00:25:54,529 --> 00:25:56,289
veremos más ejemplos

552
00:25:56,289 --> 00:25:58,450
lógicamente de enteros, double, float

553
00:25:58,450 --> 00:26:00,289
esto es un poquito para tener un vistazo

554
00:26:00,289 --> 00:26:01,730
por encima de los tipos de variables

555
00:26:01,730 --> 00:26:05,839
yo quiero una variable boolean

556
00:26:05,839 --> 00:26:07,779
por ejemplo, pues venga

557
00:26:07,779 --> 00:26:10,259
llueve

558
00:26:10,259 --> 00:26:12,440
vale, perfectamente declarada

559
00:26:12,440 --> 00:26:14,380
las variables boolean

560
00:26:14,380 --> 00:26:15,559
como todas las variables

561
00:26:15,559 --> 00:26:18,359
si tienen que tener nombres que expliquen

562
00:26:18,359 --> 00:26:19,180
lo que contienen

563
00:26:19,180 --> 00:26:22,619
pues es un nombre muy típico de una variable boolean

564
00:26:22,619 --> 00:26:23,559
expresa una condición

565
00:26:23,559 --> 00:26:24,980
expresa que llueve

566
00:26:24,980 --> 00:26:28,839
¿Vale? Como los nombres habituales de las variables boolean, la condición que expresa.

567
00:26:29,319 --> 00:26:35,140
Terminado, es azul, amarillo, condiciones que pueden ser verdad o mentira.

568
00:26:35,740 --> 00:26:38,339
Vale, pues mi variable boolean ahí perfectamente.

569
00:26:39,980 --> 00:26:48,440
¿Qué ocurre? Que a mi variable boolean yo solo le puedo asignar dos posibles valores, que son verdad o mentira.

570
00:26:49,240 --> 00:26:53,000
¿Y cómo expreso esos dos posibles valores?

571
00:26:53,000 --> 00:26:58,180
Pues los expreso con estas dos palabras reservadas.

572
00:27:06,359 --> 00:27:09,880
Solo admite estas asignaciones, o true o false.

573
00:27:11,720 --> 00:27:14,819
O algo que se evalúe como true o false, pero bueno, eso ya lo veremos.

574
00:27:15,859 --> 00:27:16,980
Ya está, no puedo tener otra cosa.

575
00:27:17,579 --> 00:27:19,599
No puedo darle un número, no puedo darle otra cosa.

576
00:27:19,640 --> 00:27:20,420
O true o false.

577
00:27:21,220 --> 00:27:23,920
O algo equivalente a true o false, como ya veremos.

578
00:27:28,000 --> 00:27:29,460
No tienen más misterio.

579
00:27:29,460 --> 00:27:50,019
Y ahora, por último, para este vistazo así muy global de tipos de variables, la variable char.

580
00:27:50,720 --> 00:28:02,259
¿Qué puede tener la variable char? Un único carácter, nada más. Solo puede tener un carácter.

581
00:28:03,799 --> 00:28:06,279
Entonces, vamos a hacerle asignaciones válidas.

582
00:28:11,910 --> 00:28:14,930
Aquí se me ha puesto rojo cuando yo he intentado hacer esta asignación.

583
00:28:17,009 --> 00:28:19,369
¿Por qué se os ocurre que se me ha puesto en rojo?

584
00:28:19,529 --> 00:28:22,589
se me ha puesto en rojo porque

585
00:28:22,589 --> 00:28:24,069
como yo he dicho antes

586
00:28:24,069 --> 00:28:26,430
cuando tú escribes algo

587
00:28:26,430 --> 00:28:29,109
en la asignación

588
00:28:29,109 --> 00:28:30,750
sin entre comillas y sin nada

589
00:28:30,750 --> 00:28:32,890
la máquina virtual

590
00:28:32,890 --> 00:28:34,390
siempre va a entender

591
00:28:34,390 --> 00:28:36,369
que es una variable que existe

592
00:28:36,369 --> 00:28:38,049
entonces dice A

593
00:28:38,049 --> 00:28:40,230
B, está aquí escrito

594
00:28:40,230 --> 00:28:42,410
pues debe ser que hay alguna variable que se llama B

595
00:28:42,410 --> 00:28:43,809
¿vale?

596
00:28:44,029 --> 00:28:46,410
igual que aquí, cuando yo he escrito altura

597
00:28:46,410 --> 00:28:47,950
él ha dicho A

598
00:28:47,950 --> 00:28:49,990
va a ser que hay una variable que se llame altura

599
00:28:49,990 --> 00:28:52,190
o A va a ser que hay una variable que se llama número

600
00:28:52,190 --> 00:28:53,589
¿vale?

601
00:28:54,089 --> 00:28:56,309
entonces dice A pues va a ser que hay una variable

602
00:28:56,309 --> 00:28:56,970
que se llama B

603
00:28:56,970 --> 00:28:58,789
va hacia arriba y dice

604
00:28:58,789 --> 00:29:01,710
no hay ninguna variable declarada que se llame B

605
00:29:01,710 --> 00:29:02,970
ninguna

606
00:29:02,970 --> 00:29:06,029
claro, es que nosotros no queríamos eso

607
00:29:06,029 --> 00:29:07,769
nos hemos equivocado escribiendo

608
00:29:07,769 --> 00:29:09,430
lo que nosotros queríamos era

609
00:29:09,430 --> 00:29:11,750
asignar directamente

610
00:29:11,750 --> 00:29:14,430
el carácter literal tal cual B

611
00:29:14,430 --> 00:29:16,589
era lo que queríamos asignar

612
00:29:16,589 --> 00:29:19,630
El carácter literal tal cual, no una variable que se llame B.

613
00:29:21,009 --> 00:29:29,329
Entonces, ¿qué poníamos cuando queremos asignar algo que sea literal eso, ese texto, y no una variable que sea B?

614
00:29:31,509 --> 00:29:40,789
Poníamos comillas, dobles, pero no, porque ponemos comillas dobles cuando son muchos caracteres, cuando es un texto.

615
00:29:41,869 --> 00:29:44,750
Cuando es un único carácter, comillas simple.

616
00:29:44,750 --> 00:29:47,549
si ponéis comillas dobles

617
00:29:47,549 --> 00:29:48,609
de hecho se va a quejar

618
00:29:48,609 --> 00:29:50,930
vale

619
00:29:50,930 --> 00:29:53,690
comilla

620
00:29:53,690 --> 00:29:55,609
simple, la comilla está vertical

621
00:29:55,609 --> 00:29:57,609
simple, ahora sí

622
00:29:57,609 --> 00:30:13,980
entonces

623
00:30:13,980 --> 00:30:16,579
cuando yo quiero expresar un char

624
00:30:16,579 --> 00:30:18,440
es decir, un único carácter

625
00:30:18,440 --> 00:30:20,500
un char, tiene que ser siempre

626
00:30:20,500 --> 00:30:21,500
con la comilla simple

627
00:30:21,500 --> 00:30:31,630
el texto entre comillas dobles

628
00:30:31,630 --> 00:30:33,569
es otra cosa distinta

629
00:30:33,569 --> 00:30:35,549
el texto entre comillas dobles

630
00:30:35,549 --> 00:30:37,589
es una cosa que se llama string, cadena

631
00:30:37,589 --> 00:30:37,910
que

632
00:30:37,910 --> 00:30:41,009
ahora mismo todavía no la vamos a ver porque

633
00:30:41,009 --> 00:30:43,509
es un tipo objeto, no es un tipo

634
00:30:43,509 --> 00:30:44,309
primitivo, ¿vale?

635
00:30:44,890 --> 00:30:47,329
Ahora mismo quedémonos en este repaso

636
00:30:47,329 --> 00:30:48,730
por encima de que el char

637
00:30:48,730 --> 00:30:51,109
es un carácter único

638
00:30:51,109 --> 00:30:51,990
entrecomillado

639
00:30:51,990 --> 00:30:55,069
entre las comillas simples y me vale cualquiera

640
00:30:55,069 --> 00:31:04,339
Pues si lo has

641
00:31:04,339 --> 00:31:05,140
escrito bien

642
00:31:05,140 --> 00:31:08,220
no se te tendría que

643
00:31:08,220 --> 00:31:09,000
seguir quejando

644
00:31:09,000 --> 00:31:12,180
puedes tener algo anidado

645
00:31:12,180 --> 00:31:14,259
por arriba, abajo, cualquier carácter.

646
00:31:20,579 --> 00:31:21,180
Vale, pues

647
00:31:21,180 --> 00:31:23,200
estos que hemos mencionado

648
00:31:23,200 --> 00:31:23,880
entonces,

649
00:31:25,559 --> 00:31:27,299
estos tipos que hemos mencionado con

650
00:31:27,299 --> 00:31:29,180
unos ejemplos muy, muy, muy

651
00:31:29,180 --> 00:31:30,579
básicos de asignación,

652
00:31:31,680 --> 00:31:33,079
estos son los tipos

653
00:31:33,079 --> 00:31:34,200
de Java,

654
00:31:35,279 --> 00:31:37,240
los tipos que

655
00:31:37,240 --> 00:31:39,039
se llaman primitivos,

656
00:31:40,039 --> 00:31:46,420
que son 8

657
00:31:46,420 --> 00:31:47,539
los que hemos dicho.

658
00:31:50,140 --> 00:31:52,059
Short, el byte se me ha escapado.

659
00:31:52,200 --> 00:31:55,000
short, byte, long

660
00:31:55,000 --> 00:31:56,960
bueno, los he puesto en otro orden pero da igual

661
00:31:56,960 --> 00:31:58,079
int

662
00:31:58,079 --> 00:32:02,619
double

663
00:32:02,619 --> 00:32:04,900
char

664
00:32:04,900 --> 00:32:09,799
y boolean

665
00:32:09,799 --> 00:32:12,079
ya está, son los tipos primitivos

666
00:32:12,079 --> 00:32:13,299
no hay más

667
00:32:13,299 --> 00:32:16,420
y me diréis, Jolín, pues sí que vamos

668
00:32:16,420 --> 00:32:18,579
escasos, solamente puedo

669
00:32:18,579 --> 00:32:20,420
guardar ese tipo de datos

670
00:32:20,420 --> 00:32:24,500
pues en tipos primitivos sí

671
00:32:24,500 --> 00:32:25,799
que son los únicos que hay

672
00:32:25,799 --> 00:32:46,759
Pero, ¿y si yo quiero guardar, por ejemplo, un nombre? Un nombre es Álvaro González. Álvaro González es un nombre, no es un único chat, son muchos caracteres. Ni es un número tampoco, ni es un boolean.

673
00:32:46,759 --> 00:32:48,740
y es un dato muy natural

674
00:32:48,740 --> 00:32:50,920
en un lenguaje, en un programa

675
00:32:50,920 --> 00:32:53,259
trabajar con cadenas, con nombres de cosas

676
00:32:53,259 --> 00:32:54,700
con nombres de alumnos

677
00:32:54,700 --> 00:32:56,900
pues ahí tengo un problema

678
00:32:56,900 --> 00:32:58,500
con estos tipos primitivos

679
00:32:58,500 --> 00:33:01,400
y si mi aplicación es una aplicación que trabaja

680
00:33:01,400 --> 00:33:02,119
con facturas

681
00:33:02,119 --> 00:33:05,500
y yo necesito guardar

682
00:33:05,500 --> 00:33:05,940
pues

683
00:33:05,940 --> 00:33:09,380
la cantidad

684
00:33:09,380 --> 00:33:11,519
de la factura, los ítems

685
00:33:11,519 --> 00:33:13,539
que son un montón de cosas

686
00:33:13,539 --> 00:33:15,460
¿qué hago? es que eso no me cabe

687
00:33:15,460 --> 00:33:17,099
aquí, si es que solamente puedo guardar

688
00:33:17,099 --> 00:33:18,319
un número suelto

689
00:33:18,319 --> 00:33:21,480
entero, decimal, un char

690
00:33:21,480 --> 00:33:23,619
suelto y un true o false, es lo único que puedo

691
00:33:23,619 --> 00:33:25,400
guardar, ¿qué hago entonces para hacer

692
00:33:25,400 --> 00:33:27,519
programas en los que necesito datos más complejos?

693
00:33:30,059 --> 00:33:30,339
pues

694
00:33:30,339 --> 00:33:33,140
tendríamos que

695
00:33:33,140 --> 00:33:35,200
construir, que no podemos hacerlo

696
00:33:35,200 --> 00:33:36,299
todavía, pero lo digo

697
00:33:36,299 --> 00:33:39,259
para que sepáis que lógicamente hay soluciones

698
00:33:39,259 --> 00:33:41,200
de almacenamiento más allá de estos

699
00:33:41,200 --> 00:33:42,759
tipos primitivos, porque si no estaríamos

700
00:33:42,759 --> 00:33:44,839
bien escasitos

701
00:33:44,839 --> 00:33:47,200
pues tendríamos que construir nosotros

702
00:33:47,200 --> 00:33:50,059
y crear y declarar nosotros por código

703
00:33:50,059 --> 00:33:52,299
una cosa que se llaman

704
00:33:52,299 --> 00:33:54,319
los tipos objeto

705
00:33:54,319 --> 00:33:59,220
que ahora mismo solamente

706
00:33:59,220 --> 00:34:01,400
lo digo pues por complejitud

707
00:34:01,400 --> 00:34:02,839
ahora no lo vamos a ver

708
00:34:02,839 --> 00:34:03,519
obviamente

709
00:34:03,519 --> 00:34:06,059
entonces los

710
00:34:06,059 --> 00:34:08,380
tenemos los tipos primitivos

711
00:34:08,380 --> 00:34:10,360
estos que hemos visto

712
00:34:10,360 --> 00:34:12,679
que ya sabemos por encima como funciona

713
00:34:12,679 --> 00:34:15,320
y los tipos objeto

714
00:34:15,320 --> 00:34:16,639
y que son los tipos objeto

715
00:34:16,639 --> 00:34:18,880
tipos que se hacen

716
00:34:18,880 --> 00:34:21,159
A mano y se construyen

717
00:34:21,159 --> 00:34:22,860
Combinando los primitivos

718
00:34:22,860 --> 00:34:24,840
Para tener un tipo más complejo

719
00:34:24,840 --> 00:34:25,500
¿Vale?

720
00:34:26,159 --> 00:34:27,639
Que yo necesito

721
00:34:27,639 --> 00:34:29,480
Guardar información

722
00:34:29,480 --> 00:34:31,460
En la que necesito

723
00:34:31,460 --> 00:34:33,599
Un montón de char y dos números

724
00:34:33,599 --> 00:34:35,579
Pues me construyo

725
00:34:35,579 --> 00:34:37,260
Un tipo objeto que tiene dentro

726
00:34:37,260 --> 00:34:38,639
Un montón de char y dos números

727
00:34:38,639 --> 00:34:40,539
Y le doy un nombre, mi tipo nuevo

728
00:34:40,539 --> 00:34:43,239
Ya tengo un tipo para guardar

729
00:34:43,239 --> 00:34:44,360
Unos datos más complejos

730
00:34:44,360 --> 00:34:47,559
Pero bueno, ahora solo lo menciono

731
00:34:47,559 --> 00:34:50,039
y ya lo veremos más adelante

732
00:34:50,039 --> 00:34:51,639
vale, ahora mismo nos importa

733
00:34:51,639 --> 00:34:53,300
trabajar y manejar

734
00:34:53,300 --> 00:34:56,099
los tipos primitivos y ya está

735
00:34:56,099 --> 00:34:59,679
vale

736
00:34:59,679 --> 00:35:04,920
pues vamos a parar aquí

737
00:35:04,920 --> 00:35:07,420
en lugar de cuando suene el timbre, para que no se haga

738
00:35:07,420 --> 00:35:08,159
demasiado largo

739
00:35:08,159 --> 00:35:12,119
antes de seguir con lo que os iba a contar