1
00:00:00,500 --> 00:00:09,259
Vale, pues el miércoles habíamos empezado la programación estructurada con los conceptos básicos.

2
00:00:09,720 --> 00:00:12,259
Primero, pues, ¿qué es la programación estructurada?

3
00:00:12,339 --> 00:00:21,760
La que se basa solamente en combinar en secuencia asignación de lectura y salida de datos, decisiones y bucles.

4
00:00:21,899 --> 00:00:22,879
Ya está, ¿vale?

5
00:00:22,899 --> 00:00:29,160
Y más o menos podemos intuir un poquito de qué van las sentencias de decisión y las de bucle.

6
00:00:29,160 --> 00:00:45,140
Pero bueno, esa es un poquito más adelante, ¿no? Entonces, ya en la parte de lo relacionado con mover los datos, que también lo hacen los programas estructurados, sacar datos para que yo vea los resultados y meter datos, ahí entraba el concepto de variable, ¿verdad?

7
00:00:45,140 --> 00:00:56,000
y ya dijimos que una variable es un espacio en memoria RAM

8
00:00:56,000 --> 00:00:59,320
un espacio en memoria RAM para guardar un dato

9
00:00:59,320 --> 00:01:02,740
y ese espacio en memoria RAM recibe un nombre

10
00:01:02,740 --> 00:01:04,859
lógicamente para que el programa lo identifique

11
00:01:04,859 --> 00:01:09,060
bueno, entendido que es fundamental la existencia de variables

12
00:01:09,060 --> 00:01:10,739
en cualquier lenguaje de programación

13
00:01:10,739 --> 00:01:12,859
en cualquier programa

14
00:01:12,859 --> 00:01:18,079
porque es la única manera en la cual un programa

15
00:01:18,079 --> 00:01:20,859
puede recibir datos y sacar datos

16
00:01:20,859 --> 00:01:22,540
a través de variables, entiende la importancia

17
00:01:22,540 --> 00:01:24,239
pues ya dimos, venga, vamos a ver en Java

18
00:01:24,239 --> 00:01:28,620
en Java en particular

19
00:01:28,620 --> 00:01:30,340
cómo hago yo

20
00:01:30,340 --> 00:01:32,939
qué sentencias, de qué sentencias dispongo

21
00:01:32,939 --> 00:01:34,719
para crear variables

22
00:01:34,719 --> 00:01:37,099
porque eso es lo primero que hacemos

23
00:01:37,099 --> 00:01:38,159
¿verdad? yo ya he

24
00:01:38,159 --> 00:01:41,239
me han dado un enunciado, lo he analizado, lo he leído

25
00:01:41,239 --> 00:01:42,980
he visto más o menos lo que tengo

26
00:01:42,980 --> 00:01:44,739
que hacer, me he hecho un primer diseño, ah vale

27
00:01:44,739 --> 00:01:46,939
primero pide números, cuando tengas

28
00:01:46,939 --> 00:01:48,719
los números ya guardaditos en variables

29
00:01:48,719 --> 00:01:51,079
hace estas operaciones, ahora no sé qué

30
00:01:51,079 --> 00:01:53,319
cuando yo tengo ya un primer diseño de lo que tengo que hacer

31
00:01:53,319 --> 00:01:54,640
y ya arranco

32
00:01:54,640 --> 00:01:57,319
lo primero normalmente será

33
00:01:57,319 --> 00:01:59,159
crear las variables

34
00:01:59,159 --> 00:02:00,980
que van a recibir los datos, eso será lo primero

35
00:02:00,980 --> 00:02:03,299
crear las variables, yo ya he identificado

36
00:02:03,299 --> 00:02:05,319
que necesito, necesito dos, necesito tres

37
00:02:05,319 --> 00:02:06,859
vale, una vez lo he identificado

38
00:02:06,859 --> 00:02:09,280
y ya me pongo a teclear

39
00:02:09,280 --> 00:02:11,120
código, ya me pongo a teclearlo

40
00:02:11,120 --> 00:02:13,280
pues lo primero será, venga vamos a

41
00:02:13,280 --> 00:02:15,159
crear las variables, vale pues

42
00:02:15,159 --> 00:02:17,340
como se hace la creación de variables

43
00:02:17,340 --> 00:02:19,439
en Java, que es lo que se llama

44
00:02:19,439 --> 00:02:22,680
declaración de variables.

45
00:02:27,219 --> 00:02:28,960
La declaración de variables

46
00:02:28,960 --> 00:02:31,479
que viene a ser crear la variable,

47
00:02:31,699 --> 00:02:32,840
hacer que aparezca en RAM,

48
00:02:33,039 --> 00:02:33,819
hacer que aparezca.

49
00:02:34,900 --> 00:02:35,900
Dijimos, primero,

50
00:02:37,219 --> 00:02:38,500
selecciono su nombre.

51
00:02:39,319 --> 00:02:41,520
Nombre lo más explicativo posible

52
00:02:41,520 --> 00:02:43,500
para que el programa sea elegible

53
00:02:43,500 --> 00:02:45,360
para otra persona que no sea

54
00:02:45,360 --> 00:02:47,039
el que lo ha hecho. Nombre lo más explicativo.

55
00:02:47,580 --> 00:02:49,439
Edad, nombre, contraseña,

56
00:02:49,439 --> 00:02:51,379
lo que sea, por ejemplo

57
00:02:51,379 --> 00:02:52,780
vamos a leer un número

58
00:02:52,780 --> 00:02:54,780
pues bueno

59
00:02:54,780 --> 00:03:00,120
pues por ejemplo el nombre de mi variable

60
00:03:00,120 --> 00:03:01,840
número, vale, muy bien

61
00:03:01,840 --> 00:03:03,840
pero en Java

62
00:03:03,840 --> 00:03:05,699
al ser un lenguaje de los que se llama

63
00:03:05,699 --> 00:03:06,520
tipado

64
00:03:06,520 --> 00:03:09,419
Java es un lenguaje tipado

65
00:03:09,419 --> 00:03:11,699
a diferencia de Python por ejemplo

66
00:03:11,699 --> 00:03:12,539
y de algunos otros

67
00:03:12,539 --> 00:03:15,759
al ser un lenguaje

68
00:03:15,759 --> 00:03:16,439
tipado

69
00:03:16,439 --> 00:03:19,719
me obliga en el momento en el que

70
00:03:19,719 --> 00:03:20,819
creo la variable

71
00:03:20,819 --> 00:03:23,879
importante, creo, su espacio en memoria

72
00:03:23,879 --> 00:03:25,360
me obliga a decir

73
00:03:25,360 --> 00:03:27,199
qué tipo de dato va a haber ahí

74
00:03:27,199 --> 00:03:28,199
me obliga a decir

75
00:03:28,199 --> 00:03:31,500
vale, ¿dónde pongo yo el tipo de dato

76
00:03:31,500 --> 00:03:33,180
que va a haber ahí en este espacio?

77
00:03:33,280 --> 00:03:34,759
lo tengo que poner antes

78
00:03:34,759 --> 00:03:37,740
ahora estoy, esto es código, esto es lo que teclaría

79
00:03:37,740 --> 00:03:39,099
directamente, entonces aquí

80
00:03:39,099 --> 00:03:41,759
antes

81
00:03:41,759 --> 00:03:43,539
tengo que poner

82
00:03:43,539 --> 00:03:45,860
el tipo de dato

83
00:03:45,860 --> 00:03:47,840
que va a contener esa variable

84
00:03:47,840 --> 00:03:50,039
si va a contener números, caracteres

85
00:03:50,039 --> 00:03:51,719
qué va a contener, el tipo de dato.

86
00:03:53,870 --> 00:03:55,050
¿Por qué es importante

87
00:03:55,050 --> 00:03:57,509
especificar el tipo de dato que va a contener?

88
00:03:58,289 --> 00:03:59,770
Porque así, cuando la máquina

89
00:03:59,770 --> 00:04:01,590
virtual se pone a ejecutar esto y dice

90
00:04:01,590 --> 00:04:03,669
ah, ¿qué quieres crear? Una variable, número.

91
00:04:04,370 --> 00:04:05,729
Vale, si me dices el tipo

92
00:04:05,729 --> 00:04:07,810
te creo un espacio

93
00:04:07,810 --> 00:04:09,789
adaptado a lo que

94
00:04:09,789 --> 00:04:11,830
ocupa en memoria ese tipo de datos.

95
00:04:12,710 --> 00:04:13,689
Eso no es lo de la caja.

96
00:04:14,409 --> 00:04:14,930
Sí, sí, sí.

97
00:04:15,349 --> 00:04:17,250
La variable es espacio y memoria es la caja.

98
00:04:18,629 --> 00:04:19,370
Inicialmente yo dije

99
00:04:19,370 --> 00:04:20,910
una caja para meter datos.

100
00:04:20,910 --> 00:04:22,170
Pero esa caja, ¿dónde está?

101
00:04:22,529 --> 00:04:24,209
En la memoria RAM, ¿vale?

102
00:04:24,209 --> 00:04:25,509
En la memoria RAM, vale

103
00:04:25,509 --> 00:04:29,290
Entonces, si a la máquina virtual

104
00:04:29,290 --> 00:04:30,930
Le decimos, oye

105
00:04:30,930 --> 00:04:33,050
Créame una caja o espacio

106
00:04:33,050 --> 00:04:35,110
En memoria RAM para un dato

107
00:04:35,110 --> 00:04:37,089
Y que se llame

108
00:04:37,089 --> 00:04:38,730
Número, entonces

109
00:04:38,730 --> 00:04:40,370
Él te va a crear un espacio

110
00:04:40,370 --> 00:04:43,050
Y le va a asociar internamente

111
00:04:43,050 --> 00:04:44,790
Le va a asociar un nombrecito

112
00:04:44,790 --> 00:04:46,629
Por ejemplo, número

113
00:04:46,629 --> 00:04:48,310
Se lo va a asociar, vale

114
00:04:48,310 --> 00:04:50,470
Luego ya el dato, lógicamente

115
00:04:50,470 --> 00:04:52,410
será el que sea, eso ya cuando el programa

116
00:04:52,410 --> 00:04:54,189
funcione, meterá ahí lo que quiere

117
00:04:54,189 --> 00:04:56,050
y lo cambiará cuando le dé la mano

118
00:04:56,050 --> 00:04:58,829
pero el nombre con el que el programa

119
00:04:58,829 --> 00:05:00,750
se va a poder referir a este espacio

120
00:05:00,750 --> 00:05:02,129
ya está fijado

121
00:05:02,129 --> 00:05:04,850
y es este inamovible, eso ya no se cambia

122
00:05:04,850 --> 00:05:05,670
¿vale?

123
00:05:06,290 --> 00:05:07,970
bueno, pues si a la máquina virtual

124
00:05:07,970 --> 00:05:10,170
en el mismo momento de decirle

125
00:05:10,170 --> 00:05:11,569
oye, créame el espacio

126
00:05:11,569 --> 00:05:14,350
para un dato y vamos a llamarle

127
00:05:14,350 --> 00:05:15,750
número para entendernos

128
00:05:15,750 --> 00:05:18,370
si en ese mismo momento le decimos el tipo de

129
00:05:18,370 --> 00:05:20,329
dato que va a haber, si va a haber un número

130
00:05:20,329 --> 00:05:22,449
entero, si va a haber un número con muchos decimales

131
00:05:22,449 --> 00:05:24,449
si va a haber una cadena, si yo se lo digo

132
00:05:24,449 --> 00:05:26,149
pues él ya crea

133
00:05:26,149 --> 00:05:27,290
un espacio

134
00:05:27,290 --> 00:05:29,990
con un tamaño

135
00:05:29,990 --> 00:05:31,490
adaptado a ese tipo de datos

136
00:05:31,490 --> 00:05:34,029
porque no necesitan los mismos bits

137
00:05:34,029 --> 00:05:35,350
un número entero con un número decimal

138
00:05:35,350 --> 00:05:37,829
por ejemplo, ¿vale? no lo necesitan

139
00:05:37,829 --> 00:05:40,269
entonces, esa es la

140
00:05:40,269 --> 00:05:41,589
ventaja de los lenguajes

141
00:05:41,589 --> 00:05:44,430
tipados que se llaman, que son los lenguajes

142
00:05:44,430 --> 00:05:45,529
que te obligan

143
00:05:45,529 --> 00:05:48,170
a especificar el tipo de

144
00:05:48,170 --> 00:06:10,730
dato en el momento en el que creas la variable, ¿vale? Y eso es lo que hace Java. El tipo

145
00:06:10,730 --> 00:06:38,829
de dato cuando se crea la variable, ¿vale? Se crea la variable. Vale, yo muchas de las

146
00:06:38,829 --> 00:06:45,670
cosas que digo, y voy a decir muchas, debería añadir siempre en letra pequeña con matices.

147
00:06:46,990 --> 00:06:52,850
Porque todo tiene sus matices que todavía no puedo matizar porque nos falta mucha información

148
00:06:52,850 --> 00:06:55,149
y porque no podemos meterlo todo de golpe

149
00:06:55,149 --> 00:06:55,709
a mogollón

150
00:06:55,709 --> 00:06:58,410
entonces esto

151
00:06:58,410 --> 00:07:00,189
tiene sus matices

152
00:07:00,189 --> 00:07:03,370
porque versiones más recientes de Java

153
00:07:03,370 --> 00:07:05,509
pues permiten que tú

154
00:07:05,509 --> 00:07:06,850
declares una variable

155
00:07:06,850 --> 00:07:09,649
y no pongas todavía el tipo

156
00:07:09,649 --> 00:07:10,970
sino que pongas una cosa

157
00:07:10,970 --> 00:07:12,209
y lo dejes abierto

158
00:07:12,209 --> 00:07:15,250
y luego ya cuando la usas la primera vez

159
00:07:15,250 --> 00:07:16,149
defines el tipo

160
00:07:16,149 --> 00:07:19,009
pero eso es una incorporación, una tonterita

161
00:07:19,009 --> 00:07:20,449
que ni nos afecta

162
00:07:20,449 --> 00:07:31,189
Y ahora mismo no tenemos en cuenta lo que ahora tenemos que tener claro

163
00:07:31,189 --> 00:07:36,129
es que tenemos que especificar el tipo de dato cuando creo la variable, ¿vale?

164
00:07:37,129 --> 00:07:38,269
Por estas razones.

165
00:07:38,589 --> 00:07:44,410
Y la razón no es solo que los lenguajes tipados al obligarte optimizan el uso de la memoria,

166
00:07:44,970 --> 00:07:48,829
porque te crean espacios adaptados al tipo de dato que tú vas a usar.

167
00:07:48,829 --> 00:07:50,430
no solo la optimizan, la memoria

168
00:07:50,430 --> 00:07:52,649
sino que además

169
00:07:52,649 --> 00:07:54,230
hacen que el programa

170
00:07:54,230 --> 00:07:56,329
sea más robusto, falle menos

171
00:07:56,329 --> 00:07:59,009
¿por qué? porque si tú

172
00:07:59,009 --> 00:08:00,910
desde el principio cortas

173
00:08:00,910 --> 00:08:02,149
mucho las libertades

174
00:08:02,149 --> 00:08:04,850
y dices, en la variable número solo puede haber

175
00:08:04,850 --> 00:08:06,470
un número, obligadísimo

176
00:08:06,470 --> 00:08:07,790
porque me has dicho que es un número

177
00:08:07,790 --> 00:08:10,649
lo siento pero te voy a dar error

178
00:08:10,649 --> 00:08:12,610
de compilación una vez tras otra

179
00:08:12,610 --> 00:08:14,829
una vez tras otra, error de compilación

180
00:08:14,829 --> 00:08:16,750
como te empeñes en meter cosas que no son números

181
00:08:16,750 --> 00:08:18,689
es un lenguaje tipado

182
00:08:18,689 --> 00:08:20,689
corta las libertades

183
00:08:20,689 --> 00:08:22,769
y convierte al compilador

184
00:08:22,769 --> 00:08:24,990
ahí en un

185
00:08:24,990 --> 00:08:27,250
en un jefe

186
00:08:27,250 --> 00:08:28,550
que te dice

187
00:08:28,550 --> 00:08:30,629
perdona, número me has dicho que es entero

188
00:08:30,629 --> 00:08:31,790
ahora vemos como decirlo

189
00:08:31,790 --> 00:08:34,649
como me metas algo que no sea entero

190
00:08:34,649 --> 00:08:36,289
es que no puede seguir

191
00:08:36,289 --> 00:08:37,450
error de compilación

192
00:08:37,450 --> 00:08:39,850
entonces al cortar las libertades que ocurre

193
00:08:39,850 --> 00:08:40,669
que el programa

194
00:08:40,669 --> 00:08:44,149
satisface un montonazo de reglas

195
00:08:44,149 --> 00:08:45,870
y ya cuando se ejecuta

196
00:08:45,870 --> 00:08:47,210
es muy difícil que de errores

197
00:08:47,210 --> 00:08:48,950
porque lo tienes todo hiper mega controlado

198
00:08:48,950 --> 00:08:51,389
porque el compilador ya te ha hecho

199
00:08:51,389 --> 00:08:53,129
pasar revista antes

200
00:08:53,129 --> 00:08:54,210
¿vale?

201
00:08:55,710 --> 00:08:57,029
pero a cambio

202
00:08:57,029 --> 00:08:59,110
el tiempo de desarrollo

203
00:08:59,110 --> 00:09:01,070
es muy pesado, porque si

204
00:09:01,070 --> 00:09:03,090
utilizas que una variable tiene que ser número

205
00:09:03,090 --> 00:09:04,909
entero, solamente

206
00:09:04,909 --> 00:09:07,409
puedes meter un número entero, tienes muy poca libertad

207
00:09:07,409 --> 00:09:09,309
hay otros lenguajes

208
00:09:09,309 --> 00:09:10,649
de programación como Python

209
00:09:10,649 --> 00:09:13,090
que son lo contrario

210
00:09:13,090 --> 00:09:14,049
que es

211
00:09:14,049 --> 00:09:16,409
cuando tú crees una variable

212
00:09:16,409 --> 00:09:19,090
no digas qué tipo de dato vas a meter en ella

213
00:09:19,090 --> 00:09:20,830
y luego mete lo que te dé la gana

214
00:09:20,830 --> 00:09:22,909
es decir, errores de compilación en Python

215
00:09:22,909 --> 00:09:24,950
son muy pocos, porque ahí cabe

216
00:09:24,950 --> 00:09:26,909
todo, cabe todo, pero claro

217
00:09:26,909 --> 00:09:28,549
cuantas más libertades tienes

218
00:09:28,549 --> 00:09:31,169
más cuidadoso tienes que ser

219
00:09:31,169 --> 00:09:33,029
porque como nadie

220
00:09:33,029 --> 00:09:35,210
te lo va a prohibir, luego a la hora de ejecutar

221
00:09:35,210 --> 00:09:35,970
la pues caga

222
00:09:35,970 --> 00:09:39,289
¿vale? entonces ese es un compromiso

223
00:09:39,289 --> 00:09:40,570
en general en el desarrollo

224
00:09:40,570 --> 00:09:41,990
y en otras disciplinas

225
00:09:41,990 --> 00:09:45,090
técnicas, el compromiso entre

226
00:09:45,090 --> 00:09:47,129
cuánta libertad te dejo

227
00:09:47,129 --> 00:09:48,570
en bases de datos básicos

228
00:09:48,570 --> 00:09:51,549
también, si yo dejo mucha libertad

229
00:09:51,549 --> 00:09:52,509
al desarrollador

230
00:09:52,509 --> 00:09:55,370
su escritura de código va a ser súper ágil

231
00:09:55,370 --> 00:09:57,230
porque como le permito cualquier cosa

232
00:09:57,230 --> 00:09:59,570
pero luego el programa es muy probable

233
00:09:59,570 --> 00:10:01,090
que te dé errores de ejecución

234
00:10:01,090 --> 00:10:02,830
porque no te has dado cuenta, porque como yo

235
00:10:02,830 --> 00:10:05,289
desde la fase de compilación te he dejado hacerlo todo

236
00:10:05,289 --> 00:10:07,450
y ese es un extremo

237
00:10:07,450 --> 00:10:09,230
y el otro extremo, perdona

238
00:10:09,230 --> 00:10:10,850
mi lenguaje de programación

239
00:10:10,850 --> 00:10:12,830
te pone muchas reglas

240
00:10:12,830 --> 00:10:15,190
muchas, va a ser un rollo

241
00:10:15,190 --> 00:10:17,009
la escritura del código, porque te ponen muchas

242
00:10:17,009 --> 00:10:18,850
pero si las satisfaces todas

243
00:10:18,850 --> 00:10:21,090
vas a encontrarte muchos

244
00:10:21,090 --> 00:10:23,129
menos errores luego de ejecución que tengas que

245
00:10:23,129 --> 00:10:25,250
solucionar, porque ya te has pegado

246
00:10:25,250 --> 00:10:26,909
antes, te has pegado antes

247
00:10:26,909 --> 00:10:28,929
eso pasa en bases de datos

248
00:10:28,929 --> 00:10:31,250
las bases de datos relacionales

249
00:10:31,250 --> 00:10:33,250
¿por qué, aunque tienen

250
00:10:33,250 --> 00:10:34,570
200.000 años

251
00:10:34,570 --> 00:10:36,870
no hay manera de sacarlas del mercado?

252
00:10:38,129 --> 00:10:39,110
porque te quitan

253
00:10:39,110 --> 00:10:40,289
todas las libertades del mundo

254
00:10:40,289 --> 00:10:42,470
cuando uno diseña las tablas

255
00:10:42,470 --> 00:10:44,690
tiene que cumplir mil restricciones

256
00:10:44,690 --> 00:10:46,730
de claves primarias

257
00:10:46,730 --> 00:10:47,669
de no sé qué

258
00:10:47,669 --> 00:10:50,090
entonces ¿qué ocurre? que son muy robustas

259
00:10:50,090 --> 00:10:52,409
es muy difícil que una aplicación

260
00:10:52,409 --> 00:10:54,629
que va contra una base de datos

261
00:10:54,629 --> 00:10:56,470
que funciona usando

262
00:10:56,470 --> 00:10:58,049
una base de datos relacional falle

263
00:10:58,049 --> 00:11:00,169
porque la base de datos ha satisfecho

264
00:11:00,169 --> 00:11:01,570
tantas restricciones que es que

265
00:11:01,570 --> 00:11:03,669
es muy robusta

266
00:11:03,669 --> 00:11:05,950
pero claro, a cambio el diseñador de la base de datos

267
00:11:05,950 --> 00:11:06,990
pues te...

268
00:11:06,990 --> 00:11:10,460
bueno, pues entonces

269
00:11:10,460 --> 00:11:12,960
Esto venía a cuento

270
00:11:12,960 --> 00:11:15,360
De que como Java es tipado nos obliga a especificar el tipo

271
00:11:15,360 --> 00:11:17,019
Pues Java nos tiene que decir

272
00:11:17,019 --> 00:11:19,019
¿Cuántos tipos tenemos para elegir?

273
00:11:19,500 --> 00:11:21,259
¿Cuántos tipos tenemos para elegir?

274
00:11:22,019 --> 00:11:23,720
Pues ahí, 4, 5, 6, 7

275
00:11:23,720 --> 00:11:24,639
8

276
00:11:24,639 --> 00:11:27,240
¿Vale? 8, ¿y cuáles son?

277
00:11:30,549 --> 00:11:32,350
8 si los he contado bien, si no lo vamos a contar ahora

278
00:11:32,350 --> 00:11:33,690
¿De tipo numérico?

279
00:11:34,549 --> 00:11:36,149
No, no, no, tipos primitivos

280
00:11:36,149 --> 00:11:37,990
Sí, entonces vamos a

281
00:11:37,990 --> 00:11:39,649
Empezar, primero

282
00:11:39,649 --> 00:11:42,029
Esencialmente, números

283
00:11:42,029 --> 00:11:43,629
Caracteres

284
00:11:43,629 --> 00:11:45,330
Y booleanos

285
00:11:45,330 --> 00:11:47,570
Ahora lo decimos

286
00:11:47,570 --> 00:11:50,190
¿Qué tipos de datos me ofrece Java?

287
00:11:51,190 --> 00:11:53,009
A ver, para que quede aquí más claro

288
00:11:53,009 --> 00:12:11,269
Ahora lo...

289
00:12:11,269 --> 00:12:13,210
Tipos de datos en Java

290
00:12:13,210 --> 00:12:16,179
¿Vale?

291
00:12:17,059 --> 00:12:19,100
Ahora vamos a añadir la coletilla de primitivos

292
00:12:19,100 --> 00:12:20,740
Cuando ahora ya entendamos qué significa

293
00:12:20,740 --> 00:12:22,659
¿Sería lo mismo decir tipos de booleanos?

294
00:12:23,519 --> 00:12:24,340
Sí, sí, sí

295
00:12:24,340 --> 00:12:26,100
O sea, tipos de...

296
00:12:26,100 --> 00:12:28,539
Sí, si te entiendes mejor así.

297
00:12:30,340 --> 00:12:33,620
Vale, pues a ver, esencialmente son números, caracteres o booleanos,

298
00:12:33,759 --> 00:12:35,240
ahora veremos que son booleanos.

299
00:12:36,440 --> 00:12:39,440
Pero son números enteros.

300
00:12:41,120 --> 00:12:43,000
Ahora veremos qué posibilidades tenemos.

301
00:12:43,200 --> 00:12:44,019
Números enteros.

302
00:12:45,460 --> 00:12:46,820
Todos sabemos lo que es un número entero.

303
00:12:48,440 --> 00:12:48,980
¿Vale?

304
00:12:53,899 --> 00:12:54,899
Números enteros.

305
00:12:55,700 --> 00:12:56,759
Números decimales.

306
00:13:04,370 --> 00:13:04,929
Caracteres.

307
00:13:08,200 --> 00:13:09,840
¿Y booleanos?

308
00:13:14,100 --> 00:13:14,840
No, no, no.

309
00:13:14,860 --> 00:13:16,360
Es que cada uno de ellos engloba otro.

310
00:13:17,039 --> 00:13:19,000
O sea, estoy poniendo los cuatro conjuntos

311
00:13:19,000 --> 00:13:20,320
de tipos. Ahora los especificamos.

312
00:13:23,000 --> 00:13:23,700
Vale, entonces.

313
00:13:26,960 --> 00:13:28,159
Estos son cuatro,

314
00:13:28,399 --> 00:13:30,559
las cuatro posibilidades, pero cada una

315
00:13:30,559 --> 00:13:31,919
de ellas tiene subconjuntos.

316
00:13:32,639 --> 00:13:34,279
Entonces, en general, todavía no he dicho

317
00:13:34,279 --> 00:13:36,700
tipo de acto específico. En general, podemos tener

318
00:13:36,700 --> 00:13:37,980
números enteros,

319
00:13:38,480 --> 00:13:40,220
decimales, caracteres o booleanos.

320
00:13:41,360 --> 00:13:42,600
En general. Ahora especificamos

321
00:13:42,600 --> 00:13:44,759
un poco más que es booleano, cuando lleguemos a ahí.

322
00:13:45,399 --> 00:13:46,379
Y no hay

323
00:13:46,379 --> 00:13:48,679
más cosas con las que pueda trabajar el programa.

324
00:13:49,220 --> 00:13:50,860
No hay nada, solo puede trabajar con eso.

325
00:13:51,320 --> 00:13:52,519
Si tú quieres trabajar con algo

326
00:13:52,519 --> 00:13:54,639
un poco más complicado, como, perdona, pero es que

327
00:13:54,639 --> 00:13:56,460
mi aplicación no trata

328
00:13:56,460 --> 00:13:58,659
de numeritos o trata de caracteres.

329
00:13:58,659 --> 00:14:00,080
Mi aplicación trata

330
00:14:00,080 --> 00:14:02,139
de alumnos de mi instituto.

331
00:14:02,879 --> 00:14:04,720
Y mi alumno no es

332
00:14:04,720 --> 00:14:06,919
ni un número, ni un carácter,

333
00:14:07,100 --> 00:14:08,039
ni un booleano. ¿Qué hago?

334
00:14:08,720 --> 00:14:10,620
No pasa nada. Java

335
00:14:10,620 --> 00:14:12,460
construye tipos

336
00:14:12,460 --> 00:14:15,080
complejos montados

337
00:14:15,080 --> 00:14:16,059
sobre estos

338
00:14:16,059 --> 00:14:18,600
que se llaman tipos objetos.

339
00:14:19,100 --> 00:14:20,960
Por eso ya, por la parte de la ciencia de la ciencia.

340
00:14:21,659 --> 00:14:23,279
Pero están montados sobre esto.

341
00:14:23,779 --> 00:14:24,960
Uno de esos tipos objetos

342
00:14:24,960 --> 00:14:27,039
complejos, si uno entra adentro

343
00:14:27,039 --> 00:14:29,240
a ver lo que tiene, solo puede tener

344
00:14:29,240 --> 00:14:31,379
o números o caracteres

345
00:14:31,379 --> 00:14:33,179
o booleanos, ya está, porque eso es lo único

346
00:14:33,179 --> 00:14:34,480
que hay por debajo de los datos.

347
00:14:34,679 --> 00:14:35,399
No hay nada más.

348
00:14:37,179 --> 00:14:39,440
Cualquier cosa que queramos representar,

349
00:14:40,220 --> 00:14:40,980
pues mi aplicación

350
00:14:40,980 --> 00:14:42,360
trabaja con facturas.

351
00:14:42,460 --> 00:14:45,720
pues vale, y tu factura tendrá

352
00:14:45,720 --> 00:14:48,220
muchas características, pero todas ellas

353
00:14:48,220 --> 00:14:50,340
tienes que ser capaz de representarla

354
00:14:50,340 --> 00:14:52,299
o con números o con caracteres

355
00:14:52,299 --> 00:14:53,419
o con booleanos, no hay más

356
00:14:53,419 --> 00:14:55,080
bueno, pues entonces

357
00:14:55,080 --> 00:14:58,440
ahora esto como se traduce en lenguaje Java

358
00:14:58,440 --> 00:15:03,279
pues para números enteros

359
00:15:03,279 --> 00:15:05,200
hay cuatro posibilidades

360
00:15:05,200 --> 00:15:06,879
que mi número

361
00:15:06,879 --> 00:15:08,940
con el que yo voy a trabajar sea muy pequeñito

362
00:15:08,940 --> 00:15:09,980
que me quepa en 8 bits

363
00:15:09,980 --> 00:15:12,840
que sea como mucho

364
00:15:12,840 --> 00:15:14,980
de menos 127 a 127.

365
00:15:15,799 --> 00:15:17,019
El código binario, el contorno.

366
00:15:17,539 --> 00:15:18,860
Vale, pues si es un número entero,

367
00:15:18,940 --> 00:15:19,720
muy pequeñito.

368
00:15:20,899 --> 00:15:21,120
Dime.

369
00:15:22,080 --> 00:15:24,600
¿VAR entraría como un número complejo?

370
00:15:25,279 --> 00:15:26,240
¿V-A-R?

371
00:15:26,740 --> 00:15:28,860
No, VAR es una especie de la variable

372
00:15:28,860 --> 00:15:30,860
que se queda abierta, la crearé cuando

373
00:15:30,860 --> 00:15:31,860
me la uses por primera vez.

374
00:15:31,940 --> 00:15:33,340
No es un tipo de dato.

375
00:15:33,340 --> 00:15:34,779
No, no, no es un tipo de dato ni es nada.

376
00:15:35,679 --> 00:15:37,039
VAR es otro concepto que no,

377
00:15:37,240 --> 00:15:37,940
olvídalo por ahora.

378
00:15:38,539 --> 00:15:40,500
Vale, entonces, byte, eso ya es byte,

379
00:15:40,580 --> 00:15:41,460
ya sí que es un término de datos.

380
00:15:41,460 --> 00:15:44,120
bytes significa un número entero

381
00:15:44,120 --> 00:15:45,820
que cabe en 8 bits

382
00:15:45,820 --> 00:15:51,019
entonces si mi programa

383
00:15:51,019 --> 00:15:53,299
va a usar numeritos comprendidos

384
00:15:53,299 --> 00:15:54,519
entre menos 127

385
00:15:54,519 --> 00:15:57,179
y 127 aproximadamente

386
00:15:57,179 --> 00:15:58,539
que es lo que cabe en 8 bits

387
00:15:58,539 --> 00:16:00,700
con el complemento negativo

388
00:16:00,700 --> 00:16:02,120
complemento a 1, complemento a 2

389
00:16:02,120 --> 00:16:04,600
pues ya está, es un byte

390
00:16:04,600 --> 00:16:07,360
que yo voy a usar

391
00:16:07,360 --> 00:16:08,779
números un poquito más grandes

392
00:16:08,779 --> 00:16:10,779
que necesito hasta 16 bits

393
00:16:10,779 --> 00:16:12,559
para representarlos, hasta 16

394
00:16:12,559 --> 00:16:16,620
Pues hay otro tipo de dato que es el tipo de dato short

395
00:16:16,620 --> 00:16:22,620
Y ahí me reserva hasta 16 bits

396
00:16:22,620 --> 00:16:31,360
Normalmente el tipo byte y short no lo solemos usar

397
00:16:31,360 --> 00:16:33,080
Porque cuando uno trabaja con números

398
00:16:33,080 --> 00:16:36,899
Pues suele necesitar números más grandes que los que caben en 16 bits

399
00:16:36,899 --> 00:16:40,539
¿Cuál es el que normalmente siempre se usa?

400
00:16:41,440 --> 00:16:45,990
Pues el int, que es número entero

401
00:16:45,990 --> 00:16:50,149
Pero que la máquina virtual me deja hasta 32 bits

402
00:16:50,149 --> 00:16:52,210
hasta 32

403
00:16:52,210 --> 00:16:55,049
en 32 bits

404
00:16:55,049 --> 00:16:56,730
caben números enteros muy grandes

405
00:16:56,730 --> 00:16:59,169
seguramente más de los que

406
00:16:59,169 --> 00:17:00,809
nunca podamos

407
00:17:00,809 --> 00:17:01,669
vayamos a usar

408
00:17:01,669 --> 00:17:09,250
bueno, el int

409
00:17:09,250 --> 00:17:10,589
tendrá desde

410
00:17:10,589 --> 00:17:12,509
menos 2 elevado a menos 30

411
00:17:12,509 --> 00:17:14,650
menos 2 elevado a 31

412
00:17:14,650 --> 00:17:16,710
hasta más 2 elevado a 31

413
00:17:16,710 --> 00:17:18,250
porque el último bit es el del signo

414
00:17:18,250 --> 00:17:20,490
¿Habéis visto ya la representación en complemento a 1 o en complemento a 2 en el sistema?

415
00:17:22,329 --> 00:17:25,990
En sistemas informáticos, ¿habéis visto ya la representación en complemento a 1 o en complemento a 2?

416
00:17:26,430 --> 00:17:30,809
Bueno, pues en 32 bits cabe desde menos 2 elevado a 31 hasta 2 elevado a 31,

417
00:17:30,950 --> 00:17:33,730
que es un montón, es mucho.

418
00:17:38,690 --> 00:17:43,250
Siempre ponemos sí, siempre ponemos sí, porque es lo más habitual, lo más...

419
00:17:43,710 --> 00:17:47,390
Pero, si necesitamos números mucho más grandotes,

420
00:17:47,390 --> 00:17:50,390
tenemos el tipo de dato long

421
00:17:50,390 --> 00:17:54,329
en el que me caben hasta

422
00:17:54,329 --> 00:17:59,329
en el que la máquina virtual me da hasta 64 bits

423
00:17:59,329 --> 00:18:02,509
que ya es un huevo de bits

424
00:18:02,509 --> 00:18:06,039
hay veces que usamos el long

425
00:18:06,039 --> 00:18:08,259
porque estamos representando conceptos

426
00:18:08,259 --> 00:18:12,539
que sí que deberían tener tamaños de ficheros

427
00:18:12,539 --> 00:18:13,359
yo que sé, algo así

428
00:18:13,359 --> 00:18:15,799
vale, pues entonces

429
00:18:15,799 --> 00:18:18,599
que yo estoy haciendo un programa

430
00:18:18,599 --> 00:18:20,940
en el que voy a usar una variable

431
00:18:20,940 --> 00:18:21,539
entera

432
00:18:21,539 --> 00:18:24,980
para representar la edad de alguien

433
00:18:24,980 --> 00:18:26,880
pues en Java directamente

434
00:18:26,880 --> 00:18:28,700
que escribiré en mi trozo

435
00:18:28,700 --> 00:18:30,579
de código ese que va dentro del main

436
00:18:30,579 --> 00:18:31,180
entre llaves

437
00:18:31,180 --> 00:18:34,119
¿qué escribiré ahí

438
00:18:34,119 --> 00:18:36,680
para crear esa variable?

439
00:18:37,640 --> 00:18:38,599
pues escribiré

440
00:18:38,599 --> 00:18:40,420
primero selecciono el tipo de dato

441
00:18:40,420 --> 00:18:42,240
pues sí, porque un número entero

442
00:18:42,240 --> 00:18:43,460
solemos coger siempre

443
00:18:43,460 --> 00:18:45,460
primero el tipo de dato

444
00:18:45,460 --> 00:18:47,759
y espacio

445
00:18:47,759 --> 00:18:49,839
el nombre de la variable

446
00:18:49,839 --> 00:18:52,819
el que yo haya elegido lo más explicativo posible

447
00:18:52,819 --> 00:18:54,759
punto y coma

448
00:18:54,759 --> 00:18:56,400
punto y coma

449
00:18:56,400 --> 00:18:58,299
y se acabó

450
00:18:58,299 --> 00:18:59,680
esta sentencia

451
00:18:59,680 --> 00:19:02,180
ya es una sentencia válida

452
00:19:02,180 --> 00:19:02,779
de Java

453
00:19:02,779 --> 00:19:06,079
bloque de código

454
00:19:06,079 --> 00:19:08,720
y cuando la máquina virtual

455
00:19:08,720 --> 00:19:09,579
llega a ella

456
00:19:09,579 --> 00:19:11,640
¿qué hace la máquina virtual?

457
00:19:12,440 --> 00:19:14,200
pues hace aparecer

458
00:19:14,200 --> 00:19:16,700
un espacio en memoria RAM

459
00:19:16,700 --> 00:19:18,460
¿de cuánto?

460
00:19:18,980 --> 00:19:20,180
de 32 bits

461
00:19:20,180 --> 00:19:22,500
porque int ocupa 32

462
00:19:22,500 --> 00:19:27,329
y le asocia

463
00:19:27,329 --> 00:19:28,650
internamente un nombre

464
00:19:28,650 --> 00:19:30,609
el nombre que yo ya he dicho, en este caso

465
00:19:30,609 --> 00:19:31,849
le asocia el nombre edad

466
00:19:31,849 --> 00:19:34,710
y ya está, y ahí se queda

467
00:19:34,710 --> 00:19:37,980
a ver, físicamente

468
00:19:37,980 --> 00:19:40,359
en los bits que forman

469
00:19:40,359 --> 00:19:41,779
una memoria RAM o un disco duro

470
00:19:41,779 --> 00:19:43,920
físicamente no puede haberla nada

471
00:19:43,920 --> 00:19:46,359
físicamente siempre tiene que haber 0 o 1

472
00:19:46,359 --> 00:19:48,240
porque esos son los transistores, los destables

473
00:19:48,240 --> 00:19:49,720
los dispositivos

474
00:19:49,720 --> 00:19:51,420
Y eso tiene cero y tiene uno

475
00:19:51,420 --> 00:19:53,900
Entonces, bueno, internamente

476
00:19:53,900 --> 00:19:56,460
Él lo inicializa

477
00:19:56,460 --> 00:19:58,339
Inicialmente lo inicializa a cero

478
00:19:58,339 --> 00:20:00,680
Pero esta inicialización

479
00:20:00,680 --> 00:20:01,920
A cero no nos vale para nada

480
00:20:01,920 --> 00:20:03,460
Porque Java

481
00:20:03,460 --> 00:20:06,259
No nos permite usar esta variable

482
00:20:06,259 --> 00:20:07,500
Para hacer cosas con ella

483
00:20:07,500 --> 00:20:09,180
Hasta que no le demos un valor

484
00:20:09,180 --> 00:20:11,440
¿Vale? Pero para dar valores a variables

485
00:20:11,440 --> 00:20:12,319
Ahora lo vemos después

486
00:20:12,319 --> 00:20:15,420
Pero bueno, que sepamos que además de crearla

487
00:20:15,420 --> 00:20:17,319
Con el tamaño correspondiente

488
00:20:17,319 --> 00:20:18,579
Y asociarle un nombre

489
00:20:18,579 --> 00:20:21,079
la llena de algo, porque no puede dejar

490
00:20:21,079 --> 00:20:23,279
los bits indefinidos, bueno, pues la llena

491
00:20:23,279 --> 00:20:25,200
de todo cero y ya está, pero no nos sirve

492
00:20:25,200 --> 00:20:26,140
para nada ese valor

493
00:20:26,140 --> 00:20:28,880
no podemos usarlo para nada

494
00:20:28,880 --> 00:20:31,180
vale, pues números está claro

495
00:20:31,180 --> 00:20:33,400
cuando necesitemos números enteros

496
00:20:33,400 --> 00:20:34,960
seleccionamos el tipo de dato y ya está

497
00:20:34,960 --> 00:20:37,160
que normalmente va a ser siempre

498
00:20:37,160 --> 00:20:39,339
in, porque si es tanto, para trabajar con números

499
00:20:39,339 --> 00:20:41,200
enteros, porque 32 bits

500
00:20:41,200 --> 00:20:42,799
no son tanto y el problema ahora

501
00:20:42,799 --> 00:20:45,019
no es la rampa

502
00:20:45,019 --> 00:20:47,180
todavía en programas de hace mil años

503
00:20:47,180 --> 00:20:49,660
pues podríamos igual pretender optimizar

504
00:20:49,660 --> 00:20:50,819
un poquito más pero ahora ya

505
00:20:50,819 --> 00:20:53,720
vale, eso en cuanto a números

506
00:20:53,720 --> 00:20:55,940
enteros, pero yo resulta

507
00:20:55,940 --> 00:20:57,740
que mi aplicación tiene que trabajar

508
00:20:57,740 --> 00:20:58,700
con decimales

509
00:20:58,700 --> 00:21:01,660
pues como tiene que trabajar con

510
00:21:01,660 --> 00:21:03,779
decimales no me valen ninguno de estos

511
00:21:03,779 --> 00:21:04,559
tipos de datos

512
00:21:04,559 --> 00:21:12,990
una cosa que yo hago

513
00:21:12,990 --> 00:21:14,609
un byte

514
00:21:14,609 --> 00:21:17,390
la persona que más

515
00:21:17,390 --> 00:21:18,789
ha vivido creo que eran 120

516
00:21:18,789 --> 00:21:21,009
y resulta que ahora hay uno que tiene 140

517
00:21:21,009 --> 00:21:25,569
No puedes cambiar.

518
00:21:25,670 --> 00:21:26,670
La variable edad ya no te vale.

519
00:21:26,809 --> 00:21:29,150
Tienes que crear otra variable edad

520
00:21:29,150 --> 00:21:31,349
para esa nueva edad.

521
00:21:31,809 --> 00:21:33,210
La variable edad, desde el momento en que tú

522
00:21:33,210 --> 00:21:34,269
ya la has declarado así,

523
00:21:35,609 --> 00:21:36,690
te has puesto

524
00:21:36,690 --> 00:21:39,809
byte edad.

525
00:21:41,470 --> 00:21:42,849
En esta variable el programa

526
00:21:42,849 --> 00:21:44,829
no te va a dejar meter

527
00:21:44,829 --> 00:21:47,230
números mayores que los que caben

528
00:21:47,230 --> 00:21:49,250
en un byte. Se acabó. No puedes cambiar.

529
00:21:49,769 --> 00:21:51,250
A esta variable ya no le puedes

530
00:21:51,250 --> 00:21:52,490
cambiar el tipo. No se puede.

531
00:21:53,890 --> 00:21:55,230
No se puede. Una vez

532
00:21:55,230 --> 00:21:57,170
que la variable está declarada con un tipo

533
00:21:57,170 --> 00:21:58,910
asignado, se acabó.

534
00:21:59,009 --> 00:22:00,230
Ese es su tipo para siempre.

535
00:22:02,690 --> 00:22:04,069
No puedes borrar una variable.

536
00:22:04,369 --> 00:22:05,430
Esa variable está así

537
00:22:05,430 --> 00:22:05,890
para siempre.

538
00:22:07,190 --> 00:22:07,630
No puedes.

539
00:22:12,569 --> 00:22:13,589
Eso es otra cosa.

540
00:22:14,029 --> 00:22:15,490
Ahora lo veo. Cuando veamos los tipos

541
00:22:15,490 --> 00:22:16,990
de datos, ahora ya vamos a meterle valores.

542
00:22:17,529 --> 00:22:19,490
Pero una vez que la variable

543
00:22:19,490 --> 00:22:20,890
está declarada y tiene un tipo,

544
00:22:21,250 --> 00:22:27,250
Esa variable se acabó, solamente tienes espacio y memoria, y eso no puede cambiar.

545
00:22:27,250 --> 00:22:34,250
Entonces, ¿que necesitas meter ahí un número mayor de 127? Pues te creas otra variable para ello.

546
00:22:34,250 --> 00:22:37,250
No hay otra.

547
00:22:37,250 --> 00:22:47,259
Claro, los nombres de las variables tienen que ser únicos, aunque sean diferentes tipos.

548
00:22:47,259 --> 00:22:49,039
¿vale? de nuevo aquí digo

549
00:22:49,039 --> 00:22:51,019
con matices porque depende

550
00:22:51,019 --> 00:22:52,940
del bloque de código en que estés, pero eso

551
00:22:52,940 --> 00:22:55,039
ya nos meteremos cuando tengamos

552
00:22:55,039 --> 00:22:57,039
diferentes bloques de código, ámbito de

553
00:22:57,039 --> 00:22:58,859
variable esto sería, pero

554
00:22:58,859 --> 00:23:00,619
respondiendo a tu pregunta

555
00:23:00,619 --> 00:23:03,039
el nombre de la variable tiene que ser único dentro de

556
00:23:03,039 --> 00:23:05,200
tu programa, dentro de tu programa

557
00:23:05,200 --> 00:23:06,960
tiene que ser único aunque sea de diferente tipo

558
00:23:06,960 --> 00:23:09,160
¿vale? porque si no

559
00:23:09,160 --> 00:23:11,279
si tú le llamas

560
00:23:11,279 --> 00:23:12,440
al programa para decirle

561
00:23:12,440 --> 00:23:15,279
suma n más 3

562
00:23:15,279 --> 00:23:17,019
y n tiene su

563
00:23:17,019 --> 00:23:18,380
un decimario, un entero,

564
00:23:18,960 --> 00:23:20,400
a los dos podría sumar de tres.

565
00:23:20,680 --> 00:23:23,000
El programa dirá, ¿a qué n quiere sumar?

566
00:23:23,579 --> 00:23:24,700
Tendría una confusión.

567
00:23:25,960 --> 00:23:27,460
Entonces, los nombres de variables

568
00:23:27,460 --> 00:23:29,740
tienen que ser únicos en nuestro programa,

569
00:23:29,859 --> 00:23:30,799
que el tipo sea distinto.

570
00:23:40,470 --> 00:23:41,890
No puede ser ni a esa variable.

571
00:23:42,289 --> 00:23:44,029
Esa variable va a vivir siempre

572
00:23:44,029 --> 00:23:46,930
mientras el bloque de código en el que esté

573
00:23:46,930 --> 00:23:48,009
se esté ejecutando.

574
00:23:48,789 --> 00:23:50,390
Cuando ese bloque de código ha terminado,

575
00:23:50,509 --> 00:23:52,809
pero esto ya es una cosa más esotérica,

576
00:23:52,809 --> 00:23:55,289
ya esa variable desaparece

577
00:23:55,289 --> 00:23:56,569
es que el programa ha terminado

578
00:23:56,569 --> 00:23:59,470
pero una vez que está esa variable

579
00:23:59,470 --> 00:24:01,210
va a estar ahí siempre con ese nombre

580
00:24:01,210 --> 00:24:02,670
y ocupándole el tamaño by

581
00:24:02,670 --> 00:24:04,910
eso ya no vale

582
00:24:04,910 --> 00:24:07,920
y no las puedes eliminar

583
00:24:07,920 --> 00:24:09,059
no pueden desaparecer

584
00:24:09,059 --> 00:24:10,980
no hay ninguna sentencia para

585
00:24:10,980 --> 00:24:12,339
haz desaparecer esta variable

586
00:24:12,339 --> 00:24:17,670
claro, cambiar el nombre de la variable

587
00:24:17,670 --> 00:24:19,650
ahora ya vemos como asignar valores a variables

588
00:24:19,650 --> 00:24:21,369
y todo, le puedes tú cambiar

589
00:24:21,369 --> 00:24:23,190
el contenido

590
00:24:23,190 --> 00:24:24,750
y darle el contenido que quieras

591
00:24:24,750 --> 00:24:41,089
¿No? A edad, ahora, pues ahora cuando veamos la asignación, pero vamos, es muy sencillo, yo quiero meter en edad 7, pues edad igual 7, esto es edad de asignación, vale, pues en este momento edad se queda con el 7 dentro.

592
00:24:41,089 --> 00:24:44,170
que ahora quiero que edad tenga 18

593
00:24:44,170 --> 00:24:45,809
porque ha llegado otro usuario

594
00:24:45,809 --> 00:24:48,309
edad igual a 18

595
00:24:48,309 --> 00:24:49,930
y ahora edad tiene 18 dentro

596
00:24:49,930 --> 00:24:52,170
pero la variable edad

597
00:24:52,170 --> 00:24:54,609
con sus 32 bits de espacio

598
00:24:54,609 --> 00:24:56,809
esa va a estar siempre ahí con sus 32 bits

599
00:24:56,809 --> 00:24:57,630
y de ahí no se mueve

600
00:24:57,630 --> 00:25:00,509
lo que va a cambiar simplemente

601
00:25:00,509 --> 00:25:02,069
es

602
00:25:02,069 --> 00:25:05,079
lo que va dentro

603
00:25:05,079 --> 00:25:07,720
aquí va un 7

604
00:25:07,720 --> 00:25:09,720
y después de haber ejecutado

605
00:25:09,720 --> 00:25:11,420
esta pues irá

606
00:25:11,420 --> 00:25:14,079
un 18, pero lo que es

607
00:25:14,079 --> 00:25:15,940
el espacio en ra, y el nombre

608
00:25:15,940 --> 00:25:17,740
asociado, ese ya se queda de por vida

609
00:25:17,740 --> 00:25:19,160
desde el momento en el que tú has hecho

610
00:25:19,160 --> 00:25:20,720
la declaración

611
00:25:20,720 --> 00:25:23,480
¿vale? eso se llama

612
00:25:23,480 --> 00:25:24,900
declarar una variable

613
00:25:24,900 --> 00:25:27,859
hacerla aparecer con su

614
00:25:27,859 --> 00:25:30,140
nombre, su tipo, y terminando en el punto y con

615
00:25:30,140 --> 00:25:35,700
vale, entonces

616
00:25:35,700 --> 00:25:38,259
si yo no necesito

617
00:25:38,259 --> 00:25:39,940
una entera, sino lo que

618
00:25:39,940 --> 00:25:41,680
necesito es una variable decimal

619
00:25:41,680 --> 00:25:43,700
pues no me vale

620
00:25:43,700 --> 00:25:45,539
ninguno de los cuatro tipos que hemos dicho.

621
00:25:47,559 --> 00:25:49,279
¿Qué tipos tengo?

622
00:25:49,799 --> 00:25:51,660
Bueno, me da dos posibilidades Java

623
00:25:51,660 --> 00:25:53,480
en función de la precisión.

624
00:25:53,559 --> 00:25:55,700
Si yo quiero menos decimales o más.

625
00:25:56,480 --> 00:25:57,599
En función de la precisión

626
00:25:57,599 --> 00:25:58,680
me da dos posibilidades.

627
00:25:59,920 --> 00:26:00,980
O el tipo

628
00:26:00,980 --> 00:26:04,140
Float

629
00:26:04,140 --> 00:26:07,339
o el tipo Double.

630
00:26:09,859 --> 00:26:11,339
Me da estas dos opciones.

631
00:26:12,819 --> 00:26:13,740
Este es el que se llama

632
00:26:13,740 --> 00:26:14,980
en simple precisión

633
00:26:14,980 --> 00:26:16,099
y en doble precisión.

634
00:26:16,099 --> 00:26:19,319
En este hay más precisión, más cifras decimales

635
00:26:19,319 --> 00:26:20,000
Puedo poner

636
00:26:20,000 --> 00:26:22,119
Y este menos cifras decimales

637
00:26:22,119 --> 00:26:23,339
El float

638
00:26:23,339 --> 00:26:26,460
Ocupa 32 bits

639
00:26:26,460 --> 00:26:28,420
Y el dabble

640
00:26:28,420 --> 00:26:30,299
64 bits

641
00:26:30,299 --> 00:26:32,700
¿Vale?

642
00:26:37,339 --> 00:26:39,859
¿Cómo se codifica por dentro un dabble, un float?

643
00:26:40,220 --> 00:26:41,559
No da igual, igual que incluso

644
00:26:41,559 --> 00:26:43,099
¿Cómo se codifica por dentro? No da lo mismo

645
00:26:43,099 --> 00:26:45,960
Lo asignamos el valor y ya está

646
00:26:45,960 --> 00:26:47,700
¿Vale? Pues ya está

647
00:26:47,700 --> 00:26:48,259
Entonces

648
00:26:48,259 --> 00:26:50,819
Estos son los dos tipos, decimales

649
00:26:50,819 --> 00:26:52,039
si yo quiero un número decimal

650
00:26:52,039 --> 00:26:56,200
pero puede

651
00:26:56,200 --> 00:26:58,519
que yo no quiera

652
00:26:58,519 --> 00:27:01,039
un número, ni entero ni decimal

653
00:27:01,039 --> 00:27:02,279
sino que mi dato sea

654
00:27:02,279 --> 00:27:04,099
un carácter

655
00:27:04,099 --> 00:27:07,599
solo uno, porque Java no me permite guardar más

656
00:27:07,599 --> 00:27:09,440
con estos tipos de datos

657
00:27:09,440 --> 00:27:12,609
entonces

658
00:27:12,609 --> 00:27:15,170
si yo quiero un carácter

659
00:27:15,170 --> 00:27:17,210
A, B, C, J, H

660
00:27:17,210 --> 00:27:18,329
dólar, almohadilla

661
00:27:18,329 --> 00:27:21,490
cualquiera de los caracteres de esa famosa tabla ASCII

662
00:27:21,490 --> 00:27:23,670
que ya mostramos el otro día

663
00:27:23,670 --> 00:27:25,609
cualquiera de sus caracteres, yo quiero que un dato

664
00:27:25,609 --> 00:27:27,329
tenga un carácter

665
00:27:27,329 --> 00:27:30,109
el tipo que tengo que declarar

666
00:27:30,109 --> 00:27:31,210
es el

667
00:27:31,210 --> 00:27:32,750
char

668
00:27:32,750 --> 00:27:34,730
tipo char

669
00:27:34,730 --> 00:27:37,069
¿eh?

670
00:27:37,789 --> 00:27:39,849
sí, c-h-a-r

671
00:27:39,849 --> 00:27:42,049
ahora cuando ya en el código pongamos

672
00:27:42,049 --> 00:27:43,650
variables, asignaciones, etc.

673
00:27:44,289 --> 00:27:45,369
pues ya lo vamos a ver más claro

674
00:27:45,369 --> 00:27:47,970
ahora los estoy enunciando para ver los que son

675
00:27:47,970 --> 00:27:49,430
entonces llevamos ya

676
00:27:49,430 --> 00:27:51,690
7, los 4 enteros

677
00:27:51,690 --> 00:27:54,230
estos dos, 6 más ese 7

678
00:27:54,230 --> 00:27:55,170
nos falta el octavo

679
00:27:55,170 --> 00:27:57,950
vale, pero repito

680
00:27:57,950 --> 00:28:01,880
que tú dices

681
00:28:01,880 --> 00:28:03,599
oye, perdona, pero es que lo que pasa en la aplicación

682
00:28:03,599 --> 00:28:04,720
son nombres de personas

683
00:28:04,720 --> 00:28:06,599
un nombre de persona

684
00:28:06,599 --> 00:28:09,819
no me cabe en un número, evidentemente

685
00:28:09,819 --> 00:28:12,079
y en un único char no me cabe un nombre de persona

686
00:28:12,079 --> 00:28:14,539
pues hay que usar

687
00:28:14,539 --> 00:28:16,160
hay que construir

688
00:28:16,160 --> 00:28:18,539
un tipo complejo

689
00:28:18,539 --> 00:28:19,559
basado en estos

690
00:28:19,559 --> 00:28:22,319
y el tipo complejo basado en estos

691
00:28:22,319 --> 00:28:23,200
en este caso será

692
00:28:23,200 --> 00:28:26,599
muchos char juntos

693
00:28:26,599 --> 00:28:28,859
muchos char juntos

694
00:28:28,859 --> 00:28:30,599
ya sé que pueden ser un nombre

695
00:28:30,599 --> 00:28:33,059
¿cómo construimos

696
00:28:33,059 --> 00:28:34,500
un tipo complejo

697
00:28:34,500 --> 00:28:35,720
basado en esos

698
00:28:35,720 --> 00:28:38,259
o lo que es lo mismo, pegando muchos de esos?

699
00:28:39,420 --> 00:28:40,460
pues ya lo veremos

700
00:28:40,460 --> 00:28:41,339
en el procedimiento de objetos

701
00:28:41,339 --> 00:28:43,220
pero afortunadamente

702
00:28:43,220 --> 00:28:46,500
algunos de esos tipos

703
00:28:46,500 --> 00:28:48,359
de datos complejos que están basados

704
00:28:48,359 --> 00:28:50,019
en muchos de esos pegados

705
00:28:50,019 --> 00:28:52,359
afortunadamente algunos ya están hechos

706
00:28:52,359 --> 00:28:54,380
los podríamos usar desde ya

707
00:28:54,380 --> 00:28:56,259
como el string

708
00:28:56,259 --> 00:28:57,539
pero eso lo haremos después

709
00:28:57,539 --> 00:28:59,900
por ahora olvidaos de eso

710
00:28:59,900 --> 00:29:02,359
bueno, pues el char es el tipo de datos

711
00:29:02,359 --> 00:29:04,380
y yo quiero guardar un único carácter

712
00:29:04,380 --> 00:29:05,039
punto pelota

713
00:29:05,039 --> 00:29:06,900
¿y cuál nos falta?

714
00:29:08,180 --> 00:29:09,900
el tipo de dato booleano

715
00:29:09,900 --> 00:29:11,279
que es el más complicado de entender

716
00:29:11,279 --> 00:29:14,119
¿cuándo necesito yo que una variable

717
00:29:14,119 --> 00:29:16,339
sea booleana? porque a mí los

718
00:29:16,339 --> 00:29:18,579
los números y los caracteres

719
00:29:18,579 --> 00:29:19,940
me suenan, son los de toda la vida

720
00:29:19,940 --> 00:29:22,059
mis datos son números o son texto

721
00:29:22,059 --> 00:29:24,640
es de lo que se trata todo en la vida, no números o textos

722
00:29:24,640 --> 00:29:25,180
que no hay más

723
00:29:25,180 --> 00:29:28,420
y luego combinación de eso, pero ya está

724
00:29:28,420 --> 00:29:30,160
y esto de booleano, ¿qué es?

725
00:29:31,140 --> 00:29:32,519
esto de booleano tiene que ver

726
00:29:32,519 --> 00:29:34,500
con que para los programas es muy importante

727
00:29:34,500 --> 00:29:36,720
información relativa

728
00:29:36,720 --> 00:29:38,579
a si algo

729
00:29:38,579 --> 00:29:40,160
está pasando

730
00:29:40,160 --> 00:29:41,660
o no está pasando

731
00:29:41,660 --> 00:29:44,519
es decir, todos tenemos

732
00:29:44,519 --> 00:29:46,920
claro que los números y los caracteres

733
00:29:46,920 --> 00:29:48,740
son datos para el programa

734
00:29:48,740 --> 00:29:51,339
opera con números, opera con caracteres

735
00:29:51,339 --> 00:29:52,980
Dejamos el texto y descansamos un momento.

736
00:29:53,740 --> 00:29:56,420
Todos tenemos claro que los números y los caracteres son datos,

737
00:29:56,539 --> 00:29:58,319
que el programa opera con datos, eso está claro y seguro.

738
00:29:59,000 --> 00:30:03,680
Pero es que para un programa, un dato también es si algo pasa o no.

739
00:30:04,920 --> 00:30:08,140
Por ejemplo, si está lloviendo o no está lloviendo.

740
00:30:08,859 --> 00:30:10,680
Eso también es un dato, ¿vale?

741
00:30:11,740 --> 00:30:13,279
¿Por qué te mueves así por la buena?

742
00:30:13,859 --> 00:30:15,079
¿Por qué te mueves así por la buena?

743
00:30:16,079 --> 00:30:18,599
¿Vale? Pero porque he dicho, acabo ahora y ya paramos un momento.

744
00:30:18,599 --> 00:30:19,740
Ah, entendí que acabaste.

745
00:30:19,740 --> 00:30:22,700
No, no he dicho, acabamos esto y ya paramos un momento

746
00:30:22,700 --> 00:30:24,519
Ah, no, no

747
00:30:24,519 --> 00:30:25,960
¿Qué?

748
00:30:27,059 --> 00:30:27,859
Ya, pero si

749
00:30:27,859 --> 00:30:30,660
Sí, pero no se lo pude ver que desconectáis

750
00:30:30,660 --> 00:30:31,359
Después de hablar

751
00:30:31,359 --> 00:30:34,480
Porque a mí me han dicho

752
00:30:34,480 --> 00:30:35,880
No hables nunca más porque yo no soy

753
00:30:35,880 --> 00:30:37,880
Porque nadie dice

754
00:30:37,880 --> 00:30:41,359
Bueno, vamos a acabar esto de booleano

755
00:30:41,359 --> 00:30:42,920
Vale, y nada

756
00:30:42,920 --> 00:30:44,759
Paramos dos, tres minutos y salimos antes

757
00:30:44,759 --> 00:30:45,200
Igual de

758
00:30:45,200 --> 00:30:47,000
Porque está bueno estar

759
00:30:47,000 --> 00:30:58,000
Vale, pues entonces, para un programa, algo como está lloviendo o no está lloviendo es un dato también.

760
00:30:59,000 --> 00:31:04,059
Algo como el número es par o el número es sin par es un dato también.

761
00:31:04,779 --> 00:31:13,880
Luego, cosas, enunciados, que pueden ser solamente o verdad o mentira, también son datos.

762
00:31:13,880 --> 00:31:16,660
¿Vale? Los datos son algo que

763
00:31:16,660 --> 00:31:18,680
Pueden ser números, 3, 5, 7, 8

764
00:31:18,680 --> 00:31:20,640
Los datos son algo que

765
00:31:20,640 --> 00:31:22,380
Pueden ser caracteres, A, C, J

766
00:31:22,380 --> 00:31:24,660
Pero los datos también son algo que

767
00:31:24,660 --> 00:31:26,440
Pueden ser, ¿verdad o mentira?

768
00:31:26,960 --> 00:31:28,720
¿Cómo? ¿Está lloviendo? No está lloviendo

769
00:31:28,720 --> 00:31:30,180
¿Hace calor? Hace calor

770
00:31:30,180 --> 00:31:32,160
Eso también es un dato

771
00:31:32,160 --> 00:31:35,220
Pero claro, ese dato solo tiene dos posibles valores

772
00:31:35,220 --> 00:31:35,980
¿Qué es?

773
00:31:36,680 --> 00:31:38,039
¿Es verdad o mentira?

774
00:31:38,220 --> 00:31:40,259
Son los únicos dos posibles valores que tiene eso

775
00:31:40,259 --> 00:31:42,599
Pues para eso sirven las variables

776
00:31:42,599 --> 00:31:43,680
Booleanas

777
00:31:43,680 --> 00:31:45,799
el tipo de dato, ¿cómo se llama?

778
00:31:46,779 --> 00:31:47,339
Boolean.

779
00:31:47,940 --> 00:31:48,700
Se llama Boolean.

780
00:31:49,559 --> 00:31:52,099
Y cuando uno declara una variable Boolean,

781
00:31:53,759 --> 00:31:54,240
yo que sé,

782
00:31:54,299 --> 00:31:55,579
una variable Boolean cualquiera,

783
00:31:56,940 --> 00:31:58,640
pues esa variable de tipo Boolean

784
00:31:58,640 --> 00:32:00,920
solo puede tener

785
00:32:00,920 --> 00:32:02,440
dos posibles valores,

786
00:32:02,680 --> 00:32:04,380
que son, ¿verdad?

787
00:32:05,160 --> 00:32:05,599
Mentira.

788
00:32:06,140 --> 00:32:07,220
Ya están dos posibles valores.

789
00:32:07,720 --> 00:32:10,519
Igual que una variable float puede tener infinitos,

790
00:32:11,240 --> 00:32:12,380
bueno, infinitos porque

791
00:32:12,380 --> 00:32:13,920
que los que quepan en 32 bits.

792
00:32:14,900 --> 00:32:16,839
Una variable char puede tener mogollón,

793
00:32:18,220 --> 00:32:19,160
los de la tabla ASTI.

794
00:32:19,640 --> 00:32:21,920
Una variable boolean solo puede tener

795
00:32:21,920 --> 00:32:24,940
dos valores posibles, verdad o mentira.

796
00:32:26,460 --> 00:32:27,640
Y de nuevo diréis,

797
00:32:27,980 --> 00:32:30,400
¿pero para qué me sirve una variable boolean?

798
00:32:31,220 --> 00:32:33,319
Pues me sirve para guardar en ella

799
00:32:33,319 --> 00:32:36,039
enunciados sobre cosas que pueden ser

800
00:32:36,039 --> 00:32:36,819
verdades o mentiras.

801
00:32:37,519 --> 00:32:38,759
Enunciados del tipo, pues,

802
00:32:38,839 --> 00:32:39,819
está lloviendo, no está lloviendo,

803
00:32:39,920 --> 00:32:41,500
algo puede ser verdad o mentira.

804
00:32:41,500 --> 00:32:43,619
¿cómo? ¿cómo guardamos

805
00:32:43,619 --> 00:32:45,420
esos enunciados a una variable boolean?

806
00:32:45,500 --> 00:32:47,220
¿cómo guardo un número aquí? está claro

807
00:32:47,220 --> 00:32:49,480
le meto el número, ¿cómo guardo

808
00:32:49,480 --> 00:32:51,359
algo que puede ser verdad o mentira

809
00:32:51,359 --> 00:32:53,339
que es más abstracto a una variable

810
00:32:53,339 --> 00:32:55,220
boolean? bueno, pues ya lo veremos

811
00:32:55,220 --> 00:32:57,259
¿vale? pero ahora mismo

812
00:32:57,259 --> 00:32:59,339
que quede claro que sirven para

813
00:32:59,339 --> 00:33:01,079
guardar valores

814
00:33:01,079 --> 00:33:03,619
que solo son dos posibilidades

815
00:33:03,619 --> 00:33:05,380
¿es verdad o es mentira?

816
00:33:05,799 --> 00:33:07,700
¿vale? venga, paramos unos

817
00:33:07,700 --> 00:33:08,640
minutos

818
00:33:08,640 --> 00:33:11,380
es una condición

819
00:33:11,380 --> 00:33:11,880
Gracias por ver el video.