1
00:00:04,459 --> 00:00:17,800
Vale, bueno, pues entonces, vamos a empezar con, vamos a concretar ya un poquito como con Java, podemos hacer programas estructurados, que ya sabemos que combinan esos tres tipos de ciclología que hemos visto.

2
00:00:17,800 --> 00:00:25,859
Bueno, pues hay antes una cosa fundamental, un concepto fundamental que tenemos que tener

3
00:00:25,859 --> 00:00:29,179
Que es el concepto de dato, ¿verdad?

4
00:00:34,229 --> 00:00:41,909
Esto, porque muchas veces orientamos la tarea de programación a órdenes que hacen cosas

5
00:00:41,909 --> 00:00:48,609
Y está claro, los programas son una secuencia de sentencias, órdenes que hacen cosas, eso lo sabemos

6
00:00:48,609 --> 00:00:50,570
pero claro, esas cosas que hace

7
00:00:50,570 --> 00:00:52,509
las estamos diciendo abstracto, esas cosas que hacen

8
00:00:52,509 --> 00:00:54,070
que son, que es lo que hacen

9
00:00:54,070 --> 00:00:56,310
pues los programas, esas sentencias

10
00:00:56,310 --> 00:00:58,530
en realidad, lo único que hacen

11
00:00:58,530 --> 00:01:00,750
es mover datos

12
00:01:00,750 --> 00:01:02,829
eso es lo que hacen todas las aplicaciones

13
00:01:02,829 --> 00:01:04,609
del mundo, mover datos

14
00:01:04,609 --> 00:01:06,030
ya está, no hacen ninguna otra cosa

15
00:01:06,030 --> 00:01:07,989
lo que pasa es que

16
00:01:07,989 --> 00:01:10,810
como resultado del movimiento

17
00:01:10,810 --> 00:01:12,790
de esos datos, esos datos a veces se mueven

18
00:01:12,790 --> 00:01:14,689
a una salida, como puede ser

19
00:01:14,689 --> 00:01:16,569
ponerse en las ventanitas que esté

20
00:01:16,569 --> 00:01:20,269
ponerse la consola, esos datos a veces se recogen

21
00:01:20,269 --> 00:01:24,709
que los hemos introducido por consola, los hemos introducido pinchando en una ventana

22
00:01:24,709 --> 00:01:28,890
y la aplicación mueve, sigue moviendo esos datos

23
00:01:28,890 --> 00:01:31,849
y opera con ellos, las aplicaciones mueven datos de un sitio a otro

24
00:01:31,849 --> 00:01:36,790
si os ocurre algo, alguna situación que hayáis vivido con alguna aplicación

25
00:01:36,790 --> 00:01:40,109
informática que no se pueda expresar lo que hace

26
00:01:40,109 --> 00:01:43,689
en términos de que está moviendo datos

27
00:01:43,689 --> 00:01:45,170
Cuando hacéis login

28
00:01:45,170 --> 00:01:46,709
¿Qué hace la aplicación?

29
00:01:46,930 --> 00:01:49,390
Coge el dato que le habéis dado vosotros

30
00:01:49,390 --> 00:01:50,590
Primer movimiento de dato

31
00:01:50,590 --> 00:01:52,810
Coge ese dato

32
00:01:52,810 --> 00:01:56,049
Y luego consulta en una base de datos

33
00:01:56,049 --> 00:01:58,010
Y lo trae, segundo movimiento de dato

34
00:01:58,010 --> 00:02:00,069
Consulta lo que ha pedido la base de datos

35
00:02:00,069 --> 00:02:00,890
Con el que le habéis dado

36
00:02:00,890 --> 00:02:02,510
Si es igual

37
00:02:02,510 --> 00:02:05,390
Te dice, si eres correcto

38
00:02:05,390 --> 00:02:07,129
Es decir, el dato

39
00:02:07,129 --> 00:02:09,289
Si eres correcto, te lo pone en la pantalla

40
00:02:09,289 --> 00:02:11,090
Todas las aplicaciones

41
00:02:11,090 --> 00:02:12,250
Todo lo que hacen

42
00:02:12,250 --> 00:02:14,069
se puede traducir en última instancia

43
00:02:14,069 --> 00:02:15,710
es un movimiento de datos de un sitio a otro

44
00:02:15,710 --> 00:02:17,870
entonces cuando decimos secuencias que hacen cosas

45
00:02:17,870 --> 00:02:20,229
las secuencias no lo que hacen es mover datos

46
00:02:20,229 --> 00:02:21,770
ya está, eso es lo único que hacen

47
00:02:21,770 --> 00:02:24,310
luego, el concepto de datos

48
00:02:24,310 --> 00:02:24,889
es fundamental

49
00:02:24,889 --> 00:02:29,909
bueno, pues entonces tenemos que concretar

50
00:02:29,909 --> 00:02:31,069
de alguna manera, y ese dato

51
00:02:31,069 --> 00:02:33,849
de donde lo saca Java, donde está ese dato

52
00:02:33,849 --> 00:02:36,110
que hace con él, Java o cualquier otro lenguaje de operación

53
00:02:36,110 --> 00:02:37,849
si va a mover datos

54
00:02:37,849 --> 00:02:39,569
de donde coge esos datos

55
00:02:39,569 --> 00:02:41,949
bueno, pues ahí viene el

56
00:02:41,949 --> 00:02:54,259
concepto más importante de programación, que es el concepto de variable. Y mientras

57
00:02:54,259 --> 00:03:00,659
no tengamos ese concepto claro y no sepamos habilitar estas variables, es imposible hacer

58
00:03:00,659 --> 00:03:04,979
ningún programa, porque los programas, como yo he dicho, lo único que hacen son mover

59
00:03:04,979 --> 00:03:11,520
datos, pues esos datos tienen que estar en algún sitio. Bueno, pues, ¿qué es una variable?

60
00:03:11,520 --> 00:03:15,550
Una variable

61
00:03:15,550 --> 00:03:18,629
Que es un término

62
00:03:18,629 --> 00:03:20,710
Que aplica a cualquier lenguaje de pronunciación

63
00:03:20,710 --> 00:03:21,389
A cualquiera

64
00:03:21,389 --> 00:03:25,189
Una variable es un espacio en memoria

65
00:03:25,189 --> 00:03:26,610
Para guardar un dato

66
00:03:26,610 --> 00:03:28,669
Eso es una variable y nada más que eso

67
00:03:28,669 --> 00:03:39,300
Un espacio en memoria RAM

68
00:03:39,300 --> 00:03:41,400
Para guardar un dato

69
00:03:41,400 --> 00:03:52,030
Las variables están en RAM sí o sí

70
00:03:52,030 --> 00:03:52,909
Siempre

71
00:03:52,909 --> 00:03:55,409
Para que el ordenador pueda trabajar con un dato

72
00:03:55,409 --> 00:03:56,610
tiene que estar en una variable

73
00:03:56,610 --> 00:03:57,849
y la variable está en RAN

74
00:03:57,849 --> 00:04:01,430
otra cosa es que hay sentencias

75
00:04:01,430 --> 00:04:02,870
cuyas órdenes

76
00:04:02,870 --> 00:04:04,830
que sirven específicamente

77
00:04:04,830 --> 00:04:07,569
para mover de una ubicación externa

78
00:04:07,569 --> 00:04:08,610
a una variable

79
00:04:08,610 --> 00:04:11,789
pero hasta que no ejecutemos esa sentencia de traslación

80
00:04:11,789 --> 00:04:12,770
el ordenador no puede

81
00:04:12,770 --> 00:04:15,849
el programa no puede hacer cosas con esa variable

82
00:04:15,849 --> 00:04:17,810
es decir, hay sentencias específicas

83
00:04:17,810 --> 00:04:20,110
de trasladar del exterior a variables

84
00:04:20,110 --> 00:04:21,889
y luego

85
00:04:21,889 --> 00:04:23,649
de trasladar de variables al exterior

86
00:04:23,649 --> 00:04:26,149
pero luego ya todas las operaciones

87
00:04:26,149 --> 00:04:27,689
todo lo que haya que hacer

88
00:04:27,689 --> 00:04:29,430
se tiene que hacer con las variables

89
00:04:29,430 --> 00:04:31,589
es decir, un programa no puede sumar

90
00:04:31,589 --> 00:04:34,110
dos números si esos dos números

91
00:04:34,110 --> 00:04:35,829
están alojados en ubicaciones

92
00:04:35,829 --> 00:04:37,269
que no sean variables, no puede

93
00:04:37,269 --> 00:04:39,790
un programa solo puede trabajar con datos

94
00:04:39,790 --> 00:04:41,389
que están en variables, pero claro

95
00:04:41,389 --> 00:04:42,730
para que los datos lleguen a variables

96
00:04:42,730 --> 00:04:44,970
tienen que llegar de algún lado

97
00:04:44,970 --> 00:04:47,610
entonces hay sentencias específicas

98
00:04:47,610 --> 00:04:49,629
que sirven solo para eso

99
00:04:49,629 --> 00:04:51,589
mover de ese lado

100
00:04:51,589 --> 00:04:53,730
sea base de datos, sea lo que sea

101
00:04:53,730 --> 00:04:56,149
a la variable, para poder trabajar con ello

102
00:04:56,149 --> 00:04:56,490
dime

103
00:04:56,490 --> 00:05:11,100
pero si dices que una variable es un cambio de la característica

104
00:05:11,100 --> 00:05:13,180
del disco duro para que funcione en ambos lados

105
00:05:13,180 --> 00:05:15,519
a ver, si tu programa se está ejecutando en Linux

106
00:05:15,519 --> 00:05:17,100
y

107
00:05:17,100 --> 00:05:19,639
tú no puedes leer

108
00:05:19,639 --> 00:05:21,060
del disco duro

109
00:05:21,060 --> 00:05:23,199
que no sea compatible

110
00:05:23,199 --> 00:05:25,740
claro, no sé si va por ahí tu pregunta

111
00:05:25,740 --> 00:05:26,420
no sé si lo entiendo

112
00:05:26,420 --> 00:05:27,800
mi pregunta es

113
00:05:27,800 --> 00:05:31,620
que no puede ser

114
00:05:31,620 --> 00:05:34,980
La memoria puede ser en un sitio que tampoco sea la RAM, me refiero, o sea...

115
00:05:34,980 --> 00:05:37,100
Bueno, eso no es la memoria, eso es el almacenamiento permanente.

116
00:05:37,879 --> 00:05:42,620
O sea, tenemos memoria RAM, que es los datos con los que cualquier software

117
00:05:42,620 --> 00:05:45,360
tiene que trabajar cuando está funcionando,

118
00:05:45,680 --> 00:05:47,579
sea el sistema operativo, sea un programa nuestro,

119
00:05:47,740 --> 00:05:50,180
todos los datos tienen que estar en memoria RAM, ¿vale?

120
00:05:50,240 --> 00:05:53,319
Para que cualquier programa sea el que sea, sistema operativo en su lugar,

121
00:05:53,339 --> 00:05:54,019
para trabajar con él.

122
00:05:54,680 --> 00:05:56,740
Y luego otra cosa ya es el almacenamiento permanente,

123
00:05:56,740 --> 00:06:00,500
porque claro, cuando ese programa sea sistema operativo,

124
00:06:00,500 --> 00:06:02,459
sea nuestro propio programa, cuando ese programa

125
00:06:02,459 --> 00:06:04,620
termina, todo lo que hay en RAM

126
00:06:04,620 --> 00:06:06,939
asociado a él, con lo que el trabajo desaparece

127
00:06:06,939 --> 00:06:08,220
entonces si

128
00:06:08,220 --> 00:06:10,819
el programa no quiere que desaparezca

129
00:06:10,819 --> 00:06:12,519
porque quiere que se conserve para que

130
00:06:12,519 --> 00:06:14,600
la siguiente ejecución se detrace

131
00:06:14,600 --> 00:06:16,459
en el valor, entonces ya lo tiene que pasar

132
00:06:16,459 --> 00:06:17,819
a almacenamiento permanente

133
00:06:17,819 --> 00:06:20,920
almacenamiento permanente es disco duro

134
00:06:20,920 --> 00:06:22,779
base de datos, pendrive

135
00:06:22,779 --> 00:06:23,939
lo que es almacenamiento permanente

136
00:06:23,939 --> 00:06:26,399
entonces claro, lo que sí que tiene que haber es

137
00:06:26,399 --> 00:06:28,540
desde el lenguaje de programación

138
00:06:28,540 --> 00:06:30,899
la posibilidad de hacer ese movimiento

139
00:06:30,899 --> 00:06:32,740
pero solo eso

140
00:06:32,740 --> 00:06:34,819
mover de almacenamiento permanente

141
00:06:34,819 --> 00:06:36,459
el que sea disco duro

142
00:06:36,459 --> 00:06:38,079
pendrive a variable

143
00:06:38,079 --> 00:06:39,980
y luego de variable a disco duro

144
00:06:39,980 --> 00:06:42,259
pero luego todas las operaciones

145
00:06:42,259 --> 00:06:43,300
todo el trabajo

146
00:06:43,300 --> 00:06:46,199
ya del programa se tiene que hacer cuando los datos

147
00:06:46,199 --> 00:06:46,899
ya están ahí

148
00:06:46,899 --> 00:06:49,019
se han trasladado previamente

149
00:06:49,019 --> 00:06:51,699
entonces claro, desde un programa

150
00:06:51,699 --> 00:06:53,759
tú solamente podrás hacer ese traslado

151
00:06:53,759 --> 00:06:55,839
de almacenamientos permanentes

152
00:06:55,839 --> 00:06:57,300
pues bueno, sí que son compatibles

153
00:06:57,300 --> 00:06:58,899
que tu programa pueda abrir

154
00:06:58,899 --> 00:07:00,560
un socket hacia ellos

155
00:07:00,560 --> 00:07:02,000
o como lo haga internamente

156
00:07:02,000 --> 00:07:04,139
pero nosotros invocamos la sentencia y ya está

157
00:07:04,139 --> 00:07:06,620
como lo hace internamente eso no podemos meternos

158
00:07:06,620 --> 00:07:07,439
¿vale?

159
00:07:08,060 --> 00:07:10,540
bueno, pues la variable es un espacio

160
00:07:10,540 --> 00:07:12,399
en memoria RAM para guardar

161
00:07:12,399 --> 00:07:12,879
un dato

162
00:07:12,879 --> 00:07:18,769
y nuestros programas van a trabajar

163
00:07:18,769 --> 00:07:20,329
con los datos que estén en variables

164
00:07:20,329 --> 00:07:22,990
lo que pasa es que claro, ese programa

165
00:07:22,990 --> 00:07:25,089
de alguna manera tendrá que incluir

166
00:07:25,949 --> 00:07:28,329
sentencias

167
00:07:28,329 --> 00:07:33,610
para que esto sea útil, porque si queremos trabajar con un dato

168
00:07:33,610 --> 00:07:35,949
que nosotros le estamos suministrando a un programa,

169
00:07:36,149 --> 00:07:39,509
que le das dos números y te dice cuál es mayor que otro.

170
00:07:40,189 --> 00:07:44,730
Entonces, para comparar si el numerito primero es mayor que el segundo,

171
00:07:44,870 --> 00:07:47,529
para compararlos, esos numeritos los tiene que tener en memoria.

172
00:07:48,009 --> 00:07:57,000
Imaginaos un programa que le das dos números y te dice

173
00:07:57,000 --> 00:07:59,459
el primero es el mayor, el segundo es el mayor

174
00:07:59,459 --> 00:08:01,160
o son iguales, una chorrada de programa

175
00:08:01,160 --> 00:08:24,360
¿vale?

176
00:08:24,379 --> 00:08:26,300
entonces el análisis de esta enunciada es muy sencillo

177
00:08:26,300 --> 00:08:28,259
porque todos entendemos que nos han pedido

178
00:08:28,259 --> 00:08:30,100
vamos, dos números

179
00:08:30,100 --> 00:08:32,100
y nuestro programa en Java

180
00:08:32,100 --> 00:08:34,059
esos dos números, pues tiene que decir

181
00:08:34,059 --> 00:08:36,759
el mayor es el primero, el mayor es el segundo

182
00:08:36,759 --> 00:08:38,659
son iguales, tres posibles salidas

183
00:08:38,659 --> 00:08:39,659
tres mensajitos

184
00:08:39,659 --> 00:08:42,460
¿vale? esa sería la fase

185
00:08:42,460 --> 00:08:44,320
de análisis completamente hecha

186
00:08:44,320 --> 00:08:45,960
¿entiendo lo que

187
00:08:45,960 --> 00:08:47,440
me pide? sí

188
00:08:47,440 --> 00:08:49,639
¿Qué datos de entrada necesita?

189
00:08:50,019 --> 00:08:52,279
Dos números que le suministramos desde el exterior

190
00:08:52,279 --> 00:08:54,960
¿Cuáles son sus posibles salidas?

191
00:08:55,860 --> 00:08:57,340
Tres posibles mensajes

192
00:08:57,340 --> 00:08:59,000
El primero es el mayor

193
00:08:59,000 --> 00:09:00,000
El segundo es el mayor

194
00:09:00,000 --> 00:09:00,759
Son iguales

195
00:09:00,759 --> 00:09:02,840
Todo esto para la parte de análisis

196
00:09:02,840 --> 00:09:05,220
Que uno hace conectado con su cliente

197
00:09:05,220 --> 00:09:06,659
¿Quieres eso?

198
00:09:06,799 --> 00:09:08,840
¿Quieres que te muestre estos tres mensajes posibles?

199
00:09:09,860 --> 00:09:11,799
¿O quieres alguna otra posibilidad

200
00:09:11,799 --> 00:09:12,919
Que yo no he contemplado?

201
00:09:13,000 --> 00:09:14,419
¿O no te gustan estos mensajes?

202
00:09:14,899 --> 00:09:16,659
¿O además de los datos de entrada

203
00:09:16,659 --> 00:09:19,059
necesitas otra cosa para ver si lo que quieres

204
00:09:19,059 --> 00:09:20,700
es decir si es mayor

205
00:09:20,700 --> 00:09:22,980
si es menor, eso forma parte de la parte

206
00:09:22,980 --> 00:09:24,960
de análisis, en este caso una vez hecha sería

207
00:09:24,960 --> 00:09:26,679
vale, datos de entrada

208
00:09:26,679 --> 00:09:29,159
dos, salidas

209
00:09:29,159 --> 00:09:31,220
tres posibles

210
00:09:31,220 --> 00:09:32,840
mensajes, el primero es mayor

211
00:09:32,840 --> 00:09:34,340
esos dos mayores son iguales

212
00:09:34,340 --> 00:09:36,639
ya que lo tenemos todo analizado pues ya

213
00:09:36,639 --> 00:09:39,039
construiríamos el programa, dos líneas

214
00:09:39,039 --> 00:09:39,759
vale, ya he hecho

215
00:09:39,759 --> 00:09:41,740
pero para qué lo pongo

216
00:09:41,740 --> 00:09:44,860
porque el programa tiene que trabajar

217
00:09:44,860 --> 00:09:46,019
con esos dos números

218
00:09:46,019 --> 00:09:49,100
entonces esos dos números tienen que caer en la RAM

219
00:09:49,100 --> 00:09:50,200
en algún sitio, tienen que caer

220
00:09:50,200 --> 00:09:51,799
entonces

221
00:09:51,799 --> 00:09:55,039
este programa en algún momento tendrá que poner

222
00:09:55,039 --> 00:09:56,120
una sentencia que sea

223
00:09:56,120 --> 00:09:57,659
coger

224
00:09:57,659 --> 00:10:00,299
la fuente del dato

225
00:10:00,299 --> 00:10:02,720
que si el programa es

226
00:10:02,720 --> 00:10:04,460
que yo le meto el dato por teclado

227
00:10:04,460 --> 00:10:06,600
pues entonces tendremos que

228
00:10:06,600 --> 00:10:08,559
usar la sentencia

229
00:10:08,559 --> 00:10:10,960
que es capaz de leer

230
00:10:10,960 --> 00:10:12,539
lo que hay en el buffer del teclado

231
00:10:12,539 --> 00:10:14,820
porque cuando uno teclea algo

232
00:10:14,820 --> 00:10:15,519
en el teclado

233
00:10:15,519 --> 00:10:17,779
Eso va a un buffer del teclado

234
00:10:17,779 --> 00:10:20,759
Y como no haya ninguna aplicación

235
00:10:20,759 --> 00:10:22,919
Ninguna aplicación ahí

236
00:10:22,919 --> 00:10:24,519
Pendiente del buffer del teclado

237
00:10:24,519 --> 00:10:26,100
Eso se puede quedar en el buffer del teclado de por vida

238
00:10:26,100 --> 00:10:27,860
Lo que pasa es que normalmente

239
00:10:27,860 --> 00:10:30,279
Cuando escribimos en el teclado

240
00:10:30,279 --> 00:10:32,360
Es porque tenemos una aplicación arrancada

241
00:10:32,360 --> 00:10:33,659
Que está ahí a la escucha

242
00:10:33,659 --> 00:10:34,799
Como el Word, por ejemplo

243
00:10:34,799 --> 00:10:36,600
Tenemos el Word que está ahí escuchando

244
00:10:36,600 --> 00:10:39,259
Y en cuanto ve que hay una cosa en el buffer del teclado

245
00:10:39,259 --> 00:10:41,299
Lo saca del buffer del teclado

246
00:10:41,299 --> 00:10:43,159
Y lo pone en la pantallita

247
00:10:43,159 --> 00:10:45,559
Pues este programa sería igual

248
00:10:45,559 --> 00:10:47,679
Tiene que haber una sentencia

249
00:10:47,679 --> 00:10:50,320
Que coja lo que haya

250
00:10:50,320 --> 00:10:51,539
En el buffer del teclado

251
00:10:51,539 --> 00:10:53,279
Y lo pase a la memoria RAM

252
00:10:53,279 --> 00:10:55,399
¿Vale? Entonces

253
00:10:55,399 --> 00:10:57,220
Nosotros te creamos el 27

254
00:10:57,220 --> 00:10:59,360
Pues entonces

255
00:10:59,360 --> 00:11:01,100
Una sentencia, que ya veremos cuál

256
00:11:01,100 --> 00:11:03,799
Tiene que coger lo que hay en el buffer del teclado

257
00:11:03,799 --> 00:11:05,860
Porque para este programa en particular

258
00:11:05,860 --> 00:11:07,299
Esa es nuestra fuente de datos

259
00:11:07,299 --> 00:11:09,200
Podríamos leer un archivo de otro lado, pero no

260
00:11:09,200 --> 00:11:10,440
El teclado está bien, vale

261
00:11:10,440 --> 00:11:12,320
Pues coge lo que haya en memoria RAM

262
00:11:12,320 --> 00:11:15,779
Primer paso imprescindible, porque el programa solo puede trabajar si está en RAM.

263
00:11:16,480 --> 00:11:23,220
Siguiente paso del programa, volver al buffer del teclado, a ver si alguien ha escrito ya el segundo número.

264
00:11:24,299 --> 00:11:28,779
Como alguien no lo haya escrito, pues el programa se estaría esperando dos horas hasta que el buffer del teclado se llene.

265
00:11:29,259 --> 00:11:31,679
Bueno, pues ahora el teclado se ha llenado, ha llegado el numerito.

266
00:11:32,539 --> 00:11:35,899
Lo paso a RAM y ahora ya es cuando empieza el programa.

267
00:11:36,440 --> 00:11:38,879
Ya están los dos en RAM, ya están los dos en variables.

268
00:11:38,879 --> 00:11:41,080
ahora ya que están en variables

269
00:11:41,080 --> 00:11:42,460
ya podemos empezar a hablar

270
00:11:42,460 --> 00:11:44,399
y empezar a decir, vale, ¿qué hago con los números?

271
00:11:44,480 --> 00:11:46,120
¿los sumo, los resto, los comparo?

272
00:11:47,720 --> 00:11:48,860
¿los multiplico?

273
00:11:49,000 --> 00:11:49,720
¿les quito 100?

274
00:11:50,080 --> 00:11:51,220
ahora ya podemos empezar a hablar

275
00:11:51,220 --> 00:11:53,179
pero porque ya están en memoria RAM

276
00:11:53,179 --> 00:11:54,340
ya están en una variable

277
00:11:54,340 --> 00:11:58,379
luego, los datos con los que trabaja

278
00:11:58,379 --> 00:11:59,879
cualquier aplicación

279
00:11:59,879 --> 00:12:02,379
tienen que estar en memoria RAM

280
00:12:02,379 --> 00:12:04,519
y para ello se habrán hecho previamente

281
00:12:04,519 --> 00:12:06,539
las sentencias que correspondan

282
00:12:06,539 --> 00:12:08,279
para que esos datos de entrada lleguen

283
00:12:08,279 --> 00:12:13,179
que será la de leer del teclado

284
00:12:13,179 --> 00:12:14,820
la de leer de un disco duro

285
00:12:14,820 --> 00:12:15,740
la de la que sea

286
00:12:15,740 --> 00:12:18,220
cuando ya está en RAM

287
00:12:18,220 --> 00:12:20,039
ya empezamos a trabajar, empezamos a operar

288
00:12:20,039 --> 00:12:22,340
empezamos a hacer decisiones, bucles, lo que sea

289
00:12:22,340 --> 00:12:23,399
pero tiene que estar en RAM

290
00:12:23,399 --> 00:12:25,340
bueno, pues eso es una variable

291
00:12:25,340 --> 00:12:27,340
una variable es

292
00:12:27,340 --> 00:12:30,519
un espacio en memoria RAM para guardar un dato

293
00:12:30,519 --> 00:12:32,720
y es imprescindible que existan las variables

294
00:12:32,720 --> 00:12:34,820
porque si no, el programa no puede trabajar con datos

295
00:12:34,820 --> 00:12:36,500
¿de qué nos sirve?

296
00:12:36,500 --> 00:18:34,279
A ver, perdonadme, pero es que tengo una situación un poco peliaguda en casa

297
00:18:34,279 --> 00:18:36,059
y tengo que coger el teléfono cuando me llaman.

298
00:18:43,339 --> 00:18:44,579
¡Uh! Y no he cortado la grabación.

299
00:18:44,680 --> 00:18:46,599
¿Veis? Estas son las cosas que me pasan siempre.

300
00:18:46,599 --> 00:18:54,000
Así que ahora pues tendréis que, si alguien la ve, pues tendrá un rato muy gordo que tendrá que pasarlo rápido.

301
00:18:54,819 --> 00:18:56,299
Porque os oirá bailar a vosotros.

302
00:18:56,519 --> 00:18:59,619
O si no, uno lo evita.

303
00:19:00,539 --> 00:19:06,200
Claro, pero os aviso de eso, de que si a veces estamos grabando y entra alguien, pues yo no me acuerdo y bueno.

304
00:19:06,920 --> 00:19:09,599
Pues eso, que al final son grabaciones así y igual muchas veces es puro...

305
00:19:11,460 --> 00:19:15,880
Vale, pues entonces, está claro lo que es una variable, ¿verdad?

306
00:19:15,880 --> 00:19:17,839
y que son necesarias porque el programa

307
00:19:17,839 --> 00:19:20,240
tiene que trabajar con los datos en la memoria RAM

308
00:19:20,240 --> 00:19:21,839
¿vale?

309
00:19:21,940 --> 00:19:24,180
tenemos claro ese concepto

310
00:19:24,180 --> 00:19:25,799
de que es una variable

311
00:19:25,799 --> 00:19:28,420
pues entonces, si queremos hacer programas

312
00:19:28,420 --> 00:19:30,599
antes de empezar a hacer las sentencias

313
00:19:30,599 --> 00:19:32,619
propiamente dichas del lenguaje de programación

314
00:19:32,619 --> 00:19:34,460
que son las decisiones

315
00:19:34,460 --> 00:19:35,140
los bucles

316
00:19:35,140 --> 00:19:36,480
y no hay más

317
00:19:36,480 --> 00:19:39,220
vamos a ver

318
00:19:39,220 --> 00:19:41,720
cómo hacer que aparezcan variables

319
00:19:41,720 --> 00:19:43,519
en un programa para que un programa

320
00:19:43,519 --> 00:19:45,319
pueda usarlas para meter datos en ella

321
00:19:45,319 --> 00:19:47,740
pues venga

322
00:19:47,740 --> 00:20:03,880
a ver

323
00:20:03,880 --> 00:20:05,920
ahora ya

324
00:20:05,920 --> 00:20:08,339
sí que tenemos que concretar ya en el lenguaje

325
00:20:08,339 --> 00:20:10,240
de programación, ya no podemos hablar

326
00:20:10,240 --> 00:20:11,980
en términos generales de cualquier lenguaje

327
00:20:11,980 --> 00:20:14,559
aunque en todos

328
00:20:14,559 --> 00:20:15,640
el concepto es el mismo

329
00:20:15,640 --> 00:20:17,960
una variable, un espacio de memoria RAM

330
00:20:17,960 --> 00:20:20,440
pues venga, ahora ya sí que nos metemos

331
00:20:20,440 --> 00:20:21,720
en variables en Java

332
00:20:21,720 --> 00:20:32,180
pues está claro que son

333
00:20:32,180 --> 00:20:34,279
una cajita

334
00:20:34,279 --> 00:20:36,019
de memoria RAM, yo las variables

335
00:20:36,019 --> 00:20:37,779
Siempre las identifico así

336
00:20:37,779 --> 00:20:39,559
Como un cuadradito, pero son una cajita

337
00:20:39,559 --> 00:20:41,599
Son una cajita para meter un dato

338
00:20:41,599 --> 00:20:43,779
¿Verdad? Son una cajita para meter un dato

339
00:20:43,779 --> 00:20:46,420
Así es como yo las represento gráficamente

340
00:20:46,420 --> 00:20:47,400
Cuando utilizamos cosas

341
00:20:47,400 --> 00:20:48,579
Son una cajita para meter un dato

342
00:20:48,579 --> 00:20:50,500
Vale, entonces

343
00:20:50,500 --> 00:20:54,440
¿Qué tipo de dato se mete en memoria RAM?

344
00:20:54,799 --> 00:20:57,059
¿Qué tipo de datos usamos?

345
00:20:57,240 --> 00:20:57,980
Pues en realidad

346
00:20:57,980 --> 00:21:00,299
Números o letras

347
00:21:00,299 --> 00:21:01,839
Ya está, números o letras, no hay más

348
00:21:01,839 --> 00:21:04,420
Lo que pasa es que esos números y letras

349
00:21:04,420 --> 00:21:05,339
Luego dan información

350
00:21:05,339 --> 00:21:08,440
Pero toda la información

351
00:21:08,440 --> 00:21:10,619
Que los humanos manejamos

352
00:21:10,619 --> 00:21:11,380
Toda la información

353
00:21:11,380 --> 00:21:13,900
Se puede concretar con números y letras

354
00:21:13,900 --> 00:21:14,880
¿Vale? Ya está

355
00:21:14,880 --> 00:21:16,279
Pues

356
00:21:16,279 --> 00:21:19,380
Ahora es

357
00:21:19,380 --> 00:21:22,680
Entonces una variable yo puedo meter el 37

358
00:21:22,680 --> 00:21:24,700
En una variable

359
00:21:24,700 --> 00:21:26,180
Yo puedo meter el carácter A

360
00:21:26,180 --> 00:21:30,099
Esas cosas las puedo meter en variables

361
00:21:30,099 --> 00:21:31,539
Entonces ahora

362
00:21:31,539 --> 00:21:33,400
Surge la pregunta

363
00:21:33,400 --> 00:21:39,140
el espacio de memoria

364
00:21:39,140 --> 00:21:40,740
vale el mismo espacio

365
00:21:40,740 --> 00:21:41,960
vale la misma cajita

366
00:21:41,960 --> 00:21:44,960
si yo voy a meter números o si voy a meter letras

367
00:21:44,960 --> 00:21:46,539
o si voy a meter números grandes

368
00:21:46,539 --> 00:21:47,559
o números pequeños

369
00:21:47,559 --> 00:21:49,500
pues yo no voy a la misma cajita

370
00:21:49,500 --> 00:21:52,240
para que el programa funcione

371
00:21:52,240 --> 00:21:54,640
genere los menos errores

372
00:21:54,640 --> 00:21:56,900
efectos secundarios indeseados

373
00:21:56,900 --> 00:21:58,819
Java es un lenguaje

374
00:21:58,819 --> 00:21:59,519
que se llama

375
00:21:59,519 --> 00:22:01,900
tipado, es un lenguaje tipado

376
00:22:01,900 --> 00:22:03,380
que no lo son todos tipados

377
00:22:03,380 --> 00:22:09,140
concepto también en la cabeza

378
00:22:09,140 --> 00:22:09,779
como todos

379
00:22:09,779 --> 00:22:12,779
¿qué es un lenguaje tipado?

380
00:22:13,039 --> 00:22:15,200
un lenguaje tipado es un lenguaje de programación

381
00:22:15,200 --> 00:22:16,640
que exige

382
00:22:16,640 --> 00:22:19,559
que tú digas el tipo de dato

383
00:22:19,559 --> 00:22:20,819
que va a tener una variable

384
00:22:20,819 --> 00:22:22,319
antes de usarla

385
00:22:22,319 --> 00:22:48,900
exige que digas el tipo de dato

386
00:22:48,900 --> 00:22:50,019
que va a albergar

387
00:22:50,019 --> 00:22:52,440
una variable

388
00:22:52,440 --> 00:23:00,940
antes de

389
00:23:00,940 --> 00:23:01,980
usarla

390
00:23:01,980 --> 00:23:05,990
¿vale?

391
00:23:05,990 --> 00:23:09,740
No todos son tipados

392
00:23:09,740 --> 00:23:11,180
Hay lenguajes de programación

393
00:23:11,180 --> 00:23:12,700
Que tú puedes usar una variable

394
00:23:12,700 --> 00:23:14,339
Y meterle un número

395
00:23:14,339 --> 00:23:16,720
La primera vez que la usas

396
00:23:16,720 --> 00:23:18,920
Y siete sentencias más abajo

397
00:23:18,920 --> 00:23:20,240
Le metes una cadena de texto

398
00:23:20,240 --> 00:23:22,180
Entonces el lenguaje

399
00:23:22,180 --> 00:23:22,819
¿Perdón?

400
00:23:24,440 --> 00:23:25,119
Python

401
00:23:25,119 --> 00:23:27,359
PHP sí

402
00:23:27,359 --> 00:23:29,299
Python puede hacerlo

403
00:23:29,299 --> 00:23:31,440
Pero puedes definir los tipos también

404
00:23:31,440 --> 00:23:33,019
Y en ese caso funciona mejor

405
00:23:33,019 --> 00:23:38,440
¿por qué es más peligroso

406
00:23:38,440 --> 00:23:40,119
que no uses

407
00:23:40,119 --> 00:23:41,660
la posibilidad de definir los tipos?

408
00:23:41,940 --> 00:23:43,200
como te ofrecen algunos lenguajes

409
00:23:43,200 --> 00:23:45,819
ahí no tengo muy claro cómo funciona

410
00:23:45,819 --> 00:23:46,740
tengo que mirarlo

411
00:23:46,740 --> 00:23:49,059
¿eh?

412
00:23:52,750 --> 00:23:53,609
¿definir o declarar?

413
00:23:55,009 --> 00:23:55,930
¿quién está hablando?

414
00:23:56,650 --> 00:23:56,769
ah

415
00:23:56,769 --> 00:23:59,529
es que son cosas distintas

416
00:23:59,529 --> 00:24:01,529
pero bueno, no pasa nada, vamos a dejarlo ahí

417
00:24:01,529 --> 00:24:03,869
lo importante es que distinguamos qué significa tipado o no tipado

418
00:24:03,869 --> 00:24:06,589
entonces, ¿cuál sería el problema de un lenguaje

419
00:24:06,589 --> 00:24:09,049
que te permite que tú no comprometas

420
00:24:09,049 --> 00:24:10,609
el tipo de dato antes de usarlo

421
00:24:10,609 --> 00:24:12,890
y no digas, esta variable va a ser

422
00:24:12,890 --> 00:24:14,029
para números, esta variable va a ser para detrás

423
00:24:14,029 --> 00:24:15,349
¿cuál puede ser el problema?

424
00:24:16,250 --> 00:24:19,150
que cabe más cualquier cosa

425
00:24:19,150 --> 00:24:20,609
es decir, que se puede

426
00:24:20,609 --> 00:24:22,690
que tú puedes colar muchas cosas

427
00:24:22,690 --> 00:24:24,250
sin tener errores de compilación

428
00:24:24,250 --> 00:24:26,109
y cuidado

429
00:24:26,109 --> 00:24:28,730
un lenguaje que es muy abierto

430
00:24:28,730 --> 00:24:30,589
y te permite que escribas cualquier cosa

431
00:24:30,589 --> 00:24:33,349
y no te da errores de compilación porque te permite cualquier cosa

432
00:24:33,349 --> 00:24:35,130
por ejemplo, con una variable metas

433
00:24:35,130 --> 00:24:36,950
primero un número, luego metes una letra

434
00:24:36,950 --> 00:24:39,750
entonces no te va a dar errores de compilación, te viene cualquier cosa

435
00:24:39,750 --> 00:24:41,490
pues cuidado, porque cuanto más

436
00:24:41,490 --> 00:24:43,450
abierto y más te deje hacer, cuanto más

437
00:24:43,450 --> 00:24:44,130
libertad

438
00:24:44,130 --> 00:24:47,630
seguramente más probable sea cagarla

439
00:24:47,630 --> 00:24:48,650
cuando eso se ejecute

440
00:24:48,650 --> 00:24:51,470
entonces siempre hay un compromiso en general

441
00:24:51,470 --> 00:24:53,289
en informática, tanto en el diseño de bases de datos

442
00:24:53,289 --> 00:24:54,710
como en la operación, hay un compromiso entre

443
00:24:54,710 --> 00:24:57,630
la libertad de acción del programador

444
00:24:57,630 --> 00:24:59,549
y luego los errores

445
00:24:59,549 --> 00:25:00,670
que puedan surgir en esa

446
00:25:00,670 --> 00:25:03,289
en ese programa y ejecutándose

447
00:25:03,289 --> 00:25:06,769
si el lenguaje te permite mucha libertad

448
00:25:06,769 --> 00:25:08,569
de acción, estupendo

449
00:25:08,569 --> 00:25:10,130
lo vas a tener más fácil para hacer un desarrollo

450
00:25:10,130 --> 00:25:12,430
pero a lo mejor no te das cuenta

451
00:25:12,430 --> 00:25:13,890
de cosas, no te das cuenta

452
00:25:13,890 --> 00:25:16,390
porque el compilador no hace una primera criba

453
00:25:16,390 --> 00:25:18,170
no te das cuenta y a la hora de ejecutar

454
00:25:18,170 --> 00:25:19,630
se hacen errores con los que no contabas

455
00:25:19,630 --> 00:25:22,490
si el lenguaje es muy estricto

456
00:25:22,490 --> 00:25:23,730
es un rollo

457
00:25:23,730 --> 00:25:25,970
porque se hacen errores de compilación todo el rato

458
00:25:25,970 --> 00:25:27,710
y tienes que pensarlo todo más

459
00:25:27,710 --> 00:25:29,750
pero a cambio

460
00:25:29,750 --> 00:25:31,710
es más segura la ejecución

461
00:25:31,710 --> 00:25:33,789
entonces bueno, hay un compromiso

462
00:25:33,789 --> 00:25:34,710
en bases de datos igual

463
00:25:34,710 --> 00:25:37,430
las bases de datos relacionales que no las he visto ya este año

464
00:25:37,430 --> 00:25:40,250
imponen tropecientas restricciones

465
00:25:40,250 --> 00:25:41,930
para hacerlas tablas de relaciones

466
00:25:41,930 --> 00:25:43,970
pero a cambio son muy robustas

467
00:25:43,970 --> 00:25:44,970
luego en su funcionamiento

468
00:25:44,970 --> 00:25:48,029
cuando no queremos tanto arrobuster

469
00:25:48,029 --> 00:25:49,950
es un rollo de una base de datos relacional

470
00:25:49,950 --> 00:25:52,470
por eso hay otros modelos de datos relacionales

471
00:25:52,470 --> 00:25:53,930
pero bueno, es otro tema

472
00:25:53,930 --> 00:25:55,910
en cualquier caso, Java es tiparo

473
00:25:55,910 --> 00:25:57,809
ha incorporado una pequeña

474
00:25:57,809 --> 00:26:00,309
un pequeño matiz en las versiones

475
00:26:00,309 --> 00:26:01,089
estas últimas

476
00:26:01,089 --> 00:26:03,289
que bueno, dejamos para su momento

477
00:26:03,289 --> 00:26:05,329
para no contar cada cosa

478
00:26:05,329 --> 00:26:07,069
añadiendo muchas cosas

479
00:26:07,069 --> 00:26:09,210
para tratar de huir un poco de esto

480
00:26:09,210 --> 00:26:11,130
pero ahora ya es un parchecillo

481
00:26:11,130 --> 00:26:12,190
que lo que hace es

482
00:26:12,190 --> 00:26:15,230
te permite no comprometerte en un momento un tipo de dato

483
00:26:15,230 --> 00:26:16,990
pero una vez que te has comprometido no puedes cambiarlo

484
00:26:16,990 --> 00:26:18,349
es un parche medio raro

485
00:26:18,349 --> 00:26:20,490
bueno, pues a ver, Java

486
00:26:20,490 --> 00:26:22,690
hasta el uso

487
00:26:22,690 --> 00:26:24,329
os vais a ver en todas partes

488
00:26:24,329 --> 00:26:25,690
y vais a usar siempre

489
00:26:25,690 --> 00:26:27,630
y vais a ver en cualquier lado que vais a trabajar

490
00:26:27,630 --> 00:26:30,769
al menos a corto plazo

491
00:26:30,769 --> 00:26:34,210
Java exige que tú comprometas

492
00:26:34,210 --> 00:26:35,930
El tipo de dato que vas a salvar en una variable

493
00:26:35,930 --> 00:26:36,589
Antes de usarlo

494
00:26:36,589 --> 00:26:39,650
Bueno, pues entonces la siguiente pregunta es

495
00:26:39,650 --> 00:26:40,829
¿Y qué tipos de datos tenemos?

496
00:26:42,029 --> 00:26:43,710
Bueno, pues tipos de datos en Java

497
00:26:43,710 --> 00:26:45,490
Esa sería la siguiente cosa

498
00:26:45,490 --> 00:26:47,609
¿Qué tipos de datos tengo?

499
00:26:47,690 --> 00:26:48,650
¿Qué alternativas tengo?

500
00:27:01,259 --> 00:27:02,720
Vale, pues tengo estos

501
00:27:02,720 --> 00:27:04,720
Aquí ya tenemos que empezar a dar información

502
00:27:04,720 --> 00:27:06,039
Pues bueno, que hay que darla

503
00:27:06,039 --> 00:27:07,720
Porque es básica y hay que conocerla

504
00:27:07,720 --> 00:27:09,900
Vale, para guardar números

505
00:27:09,900 --> 00:27:12,859
Hay dos tipos de números en general

506
00:27:12,859 --> 00:27:14,319
Los enteros

507
00:27:14,319 --> 00:27:16,500
Y los que llevan decimales

508
00:27:16,500 --> 00:27:17,380
Los números reales

509
00:27:17,380 --> 00:27:20,680
Bueno, pues para guardar números enteros

510
00:27:20,680 --> 00:27:24,599
Hay hasta cuatro tipos de datos

511
00:27:24,599 --> 00:27:27,400
Cuatro tipos diferentes

512
00:27:27,400 --> 00:27:29,460
By, short, in

513
00:27:29,460 --> 00:27:31,220
Y long

514
00:27:31,220 --> 00:27:35,240
Y estos son para guardar enteros

515
00:27:35,240 --> 00:27:38,660
Numeritos enteros

516
00:27:38,660 --> 00:27:41,599
Positivos y negativos

517
00:27:41,599 --> 00:27:42,920
¿Vale?

518
00:27:43,180 --> 00:27:44,279
Positivos y negativos

519
00:27:44,279 --> 00:27:57,930
¿Por qué hay cuatro tipos de datos?

520
00:27:59,730 --> 00:28:01,490
Hombre, porque a lo mejor hay aplicaciones

521
00:28:01,490 --> 00:28:03,349
Que van a trabajar solo con números enteros

522
00:28:03,349 --> 00:28:04,369
Pues como mucho

523
00:28:04,369 --> 00:28:08,150
Que alcancen un valor absoluto de 400, 500

524
00:28:08,150 --> 00:28:10,690
A lo mejor hay aplicaciones que trabajan con números muy grandes

525
00:28:10,690 --> 00:28:14,190
Bueno, pues se diferencian

526
00:28:14,190 --> 00:28:15,690
En la cantidad de bits

527
00:28:15,690 --> 00:28:18,490
Que dedican cada uno

528
00:28:18,490 --> 00:28:28,750
almacenar la variable. Las variables byte, las variables de tipo byte dedican solo, ocupan

529
00:28:28,750 --> 00:28:38,049
más que dedican, ocupan solo 8 bits de memoria RAM para guardar el dato. Sin embargo, las

530
00:28:38,049 --> 00:28:46,589
variables short dedican 16 bits para guardar el dato. Sin embargo, las variables in dedican

531
00:28:46,589 --> 00:28:47,950
32 bits

532
00:28:47,950 --> 00:28:50,630
Y las variables log

533
00:28:50,630 --> 00:28:51,930
Dedican 64

534
00:28:51,930 --> 00:28:57,859
Entonces, que yo voy a usar

535
00:28:57,859 --> 00:29:00,079
Números muy grandotes

536
00:29:00,079 --> 00:29:03,900
Pues puedo usar el tipo log

537
00:29:03,900 --> 00:29:05,880
Porque el tipo log me va a dar

538
00:29:05,880 --> 00:29:07,920
Números de

539
00:29:07,920 --> 00:29:12,200
La codificación en complemento a 1

540
00:29:12,200 --> 00:29:14,099
O complemento a 2, imagino que no habéis visto

541
00:29:14,099 --> 00:29:15,660
Nada de sistemas todavía, ni os suena

542
00:29:15,660 --> 00:29:18,400
O a lo mejor os suenan los de sistemas

543
00:29:18,400 --> 00:29:19,839
los que ha dicho el grado medio

544
00:29:19,839 --> 00:29:22,640
no nos vamos a meter en ellos, no tiene mayor importancia

545
00:29:22,640 --> 00:29:22,980
pero

546
00:29:22,980 --> 00:29:26,460
esto que yo menciono ahora

547
00:29:26,460 --> 00:29:28,119
de complemento a 1 o complemento a 2

548
00:29:28,119 --> 00:29:30,359
son formas de codificar

549
00:29:30,359 --> 00:29:32,460
los números enteros en binario

550
00:29:32,460 --> 00:29:34,299
en ordenador, porque lo que sí que sabéis

551
00:29:34,299 --> 00:29:36,519
claro es que en ordenador todo está codificado

552
00:29:36,519 --> 00:29:38,339
con ceros y unos, ahí sí que no hay alternativa

553
00:29:38,339 --> 00:29:39,420
todo está con ceros y unos

554
00:29:39,420 --> 00:29:41,519
pues si yo quiero un número entero

555
00:29:41,519 --> 00:29:43,700
para pasarlo a ceros y unos

556
00:29:43,700 --> 00:29:46,319
están estos mecanismos, complemento a 2

557
00:29:46,319 --> 00:29:47,200
Y complemento a 1

558
00:29:47,200 --> 00:29:50,079
Entonces este mecanismo

559
00:29:50,079 --> 00:29:51,200
El complemento a 2

560
00:29:51,200 --> 00:29:53,359
Sigue unas reglas

561
00:29:53,359 --> 00:29:56,059
Como que el bit más significativo

562
00:29:56,059 --> 00:29:57,660
Es el de signo

563
00:29:57,660 --> 00:30:00,059
El que me indica si el número es negativo o positivo

564
00:30:00,059 --> 00:30:01,740
Porque los números enteros son negativos o positivos

565
00:30:01,740 --> 00:30:04,619
Entonces el bit más significativo

566
00:30:04,619 --> 00:30:07,039
Me indica el signo

567
00:30:07,039 --> 00:30:08,200
Si es positivo o negativo

568
00:30:08,200 --> 00:30:09,680
Y el resto de bits

569
00:30:09,680 --> 00:30:12,460
Ya me codifica el valor del número entero

570
00:30:12,460 --> 00:30:13,140
Pero en binario

571
00:30:13,140 --> 00:30:16,019
Entonces por ejemplo

572
00:30:16,019 --> 00:30:18,640
no, tendríamos 63 bits

573
00:30:18,640 --> 00:30:21,799
para el valor absoluto

574
00:30:21,799 --> 00:30:23,740
los que os suene esto

575
00:30:23,740 --> 00:30:25,640
que esto en particular no nos importa a nosotros

576
00:30:25,640 --> 00:30:27,200
pero bueno, es cultura informática

577
00:30:27,200 --> 00:30:29,920
que en algún momento os tiene que sonar

578
00:30:29,920 --> 00:30:31,839
si no es por aquí os tendrá que sonar por sistemas

579
00:30:31,839 --> 00:30:34,039
pues con 63 bits

580
00:30:34,039 --> 00:30:36,160
uno puede codificar

581
00:30:36,160 --> 00:30:38,279
números, el número más alto

582
00:30:38,279 --> 00:30:39,160
que puede codificar

583
00:30:39,160 --> 00:30:41,319
es este, ¿verdad?

584
00:30:41,319 --> 00:30:42,380
2 elevado a 63

585
00:30:42,380 --> 00:30:43,420
¿no?

586
00:30:43,420 --> 00:30:46,000
Con 63 bits

587
00:30:46,000 --> 00:30:47,640
¿Vale?

588
00:30:50,059 --> 00:30:53,240
Bueno, no, 263, no, 264 menos 1, perdón

589
00:30:53,240 --> 00:30:57,019
¿Vale? Este

590
00:30:57,019 --> 00:31:00,839
¿No? O sea, con 2 bits, pues uno puede codificar 4 números

591
00:31:00,839 --> 00:31:02,339
¿Vale?

592
00:31:02,819 --> 00:31:04,299
Bueno, esto nos da igual

593
00:31:04,299 --> 00:31:06,440
Lo que quiero decir es que cuantos más bits haya

594
00:31:06,440 --> 00:31:10,099
Puedes codificar números en valor absoluto más grandotes

595
00:31:10,099 --> 00:31:12,619
Obviamente, eso es evidente

596
00:31:12,619 --> 00:31:15,500
Puedes codificar números más grandotes

597
00:31:15,500 --> 00:31:16,859
cuantos más bits haya

598
00:31:16,859 --> 00:31:19,839
y el número máximo que puede codificar el long

599
00:31:19,839 --> 00:31:21,420
es gigantesco, muy grande

600
00:31:21,420 --> 00:31:23,960
entonces aplicaciones que vayan a trabajar

601
00:31:23,960 --> 00:31:25,160
con números enteros tan grandes

602
00:31:25,160 --> 00:31:26,779
pues es raro que haya

603
00:31:26,779 --> 00:31:29,599
entonces normalmente el tipo de dato que se usa

604
00:31:29,599 --> 00:31:30,940
normalmente por defecto

605
00:31:30,940 --> 00:31:33,480
cuando uno va a trabajar con números enteros

606
00:31:33,480 --> 00:31:35,720
suele ser este, este es el más habitual

607
00:31:35,720 --> 00:31:37,640
cada vez que trabajamos con números enteros

608
00:31:37,640 --> 00:31:38,779
usamos este

609
00:31:38,779 --> 00:31:41,880
vale, entonces ahora

610
00:31:41,880 --> 00:31:43,339
cuando lo veamos en la pantalla

611
00:31:43,339 --> 00:31:44,880
pues podemos mirar por curiosidad

612
00:31:44,880 --> 00:31:50,220
cuál es el número máximo positivo y el número mínimo negativo

613
00:31:50,220 --> 00:31:52,619
que me permite codificar un IN, un LONG, un SHORT,

614
00:31:52,700 --> 00:31:54,420
por si yo tengo que tomar una decisión en un momento dado

615
00:31:54,420 --> 00:31:55,940
de qué tipo de datos se adapta más.

616
00:31:57,279 --> 00:31:58,779
Bueno, pues para eso valen estos cuatro,

617
00:31:58,920 --> 00:32:01,839
para codificar números enteros, positivos y negativos.

618
00:32:02,420 --> 00:32:06,759
Y la diferencia entre ellos es el tamaño que dedica en RAM.

619
00:32:08,420 --> 00:32:10,799
Cuanto menos tamaño dedique en RAM, en principio sería mejor,

620
00:32:10,880 --> 00:32:11,720
menos RAM ocupada.

621
00:32:11,720 --> 00:32:16,400
Pero bueno, la RAM tampoco tendría que ser un problema en la mayoría de las aplicaciones.

622
00:32:17,519 --> 00:32:23,059
Vale, pues ya sabemos que aparte de enteros, hay números con decimales, que también podemos necesitar codificar.

623
00:32:23,200 --> 00:32:29,720
Nuestras aplicaciones pueden trabajar con decimales, claro, con notas decimales, con precios, una aplicación de factura y cada decimales.

624
00:32:31,000 --> 00:32:36,319
Bueno, pues para codificar números decimales, tenemos dos tipos de datos.

625
00:32:36,319 --> 00:32:48,559
tenemos el float

626
00:32:48,559 --> 00:32:51,480
y el double

627
00:32:51,480 --> 00:32:56,710
esto para codificar números reales

628
00:32:56,710 --> 00:32:57,690
o decimales

629
00:32:57,690 --> 00:33:00,470
como os guste más llamarlos

630
00:33:00,470 --> 00:33:01,369
o sea su número

631
00:33:01,369 --> 00:33:05,529
su nombre

632
00:33:05,529 --> 00:33:12,819
adecuado sería llamarles números reales

633
00:33:12,819 --> 00:33:13,740
vale, pero bueno

634
00:33:13,740 --> 00:33:15,700
si os gusta más decimales, no, no, no

635
00:33:15,700 --> 00:33:17,460
números con cifras decimales

636
00:33:17,460 --> 00:33:33,730
¿Vale la diferencia entre ellos? Pues que Float usa 32 bits para guardar el número decimal y Dabble usa 64 bits.

637
00:33:34,470 --> 00:33:51,049
¿Cómo se codifican los números decimales? Con un sistema de codificación que no nos vamos a meter aquí porque es una historia,

638
00:33:51,049 --> 00:33:53,849
pero la diferencia entre FOAD y DABEL

639
00:33:53,849 --> 00:33:56,349
es que DABEL permite más precisión

640
00:33:56,349 --> 00:33:57,950
como su nombre indica

641
00:33:57,950 --> 00:34:00,470
y permite guardar números

642
00:34:00,470 --> 00:34:01,849
con más cifras decimales

643
00:34:01,849 --> 00:34:03,609
¿vale? con más cifras decimales

644
00:34:03,609 --> 00:34:06,210
entonces si yo quiero mucha precisión

645
00:34:06,210 --> 00:34:07,829
o lo que es lo mismo, muchas cifras decimales

646
00:34:07,829 --> 00:34:09,110
la precisión para mí es importante

647
00:34:09,110 --> 00:34:11,650
pues utilizaré el DABEL

648
00:34:11,650 --> 00:34:14,150
y si no quiero mucha precisión

649
00:34:14,150 --> 00:34:15,130
utilizaré el FOAD

650
00:34:15,130 --> 00:34:18,409
ambos son para lo mismo, para cifras decimales

651
00:34:18,409 --> 00:34:20,889
¿vale?

652
00:34:21,050 --> 00:34:24,230
Bueno, pues ya llevamos seis tipos de datos

653
00:34:24,230 --> 00:34:25,429
Nos faltan en realidad

654
00:34:25,429 --> 00:34:27,929
Dos, nada más

655
00:34:27,929 --> 00:34:32,949
Aparte de números, ¿qué otra cosa se puede almacenar en una variable?

656
00:34:34,389 --> 00:34:36,949
Una letra, un carácter, punto pelota

657
00:34:36,949 --> 00:34:40,710
Y para guardar una letra, un carácter

658
00:34:40,710 --> 00:34:42,230
Lo que llamamos un char, en general

659
00:34:42,230 --> 00:34:44,289
El tipo de dato, ¿cómo se llama?

660
00:34:45,329 --> 00:34:47,010
Pues char, como nos podríamos imaginar

661
00:34:47,010 --> 00:34:52,469
Y el char es para guardar un carácter

662
00:34:52,469 --> 00:34:54,309
y se acabó

663
00:34:54,309 --> 00:35:03,219
solo uno

664
00:35:03,219 --> 00:35:05,699
en la variable char

665
00:35:05,699 --> 00:35:07,960
solo cabe la codificación de un carácter

666
00:35:07,960 --> 00:35:09,579
char en realidad

667
00:35:09,579 --> 00:35:12,219
ocupa, aunque estos detalles

668
00:35:12,219 --> 00:35:14,039
no nos importan mucho a nosotros tampoco

669
00:35:14,039 --> 00:35:16,239
ocupa memoria de 16 bits

670
00:35:16,239 --> 00:35:18,460
aunque la mayoría de las veces

671
00:35:18,460 --> 00:35:19,019
solo

672
00:35:19,019 --> 00:35:21,940
este es el que nos interesa, porque de hecho en la tabla

673
00:35:21,940 --> 00:35:24,239
solo se tienen en cuenta

674
00:35:24,239 --> 00:35:25,079
8 bits

675
00:35:25,079 --> 00:35:27,800
pero Java utiliza el unicode

676
00:35:27,800 --> 00:35:29,380
para codificar caracteres

677
00:35:29,380 --> 00:35:31,880
lo utiliza internamente el unicode que se llama

678
00:35:31,880 --> 00:35:34,280
y que en el unicode son 16 bits

679
00:35:34,280 --> 00:35:35,619
entonces la variable char son 16

680
00:35:35,619 --> 00:35:36,960
pero vamos

681
00:35:36,960 --> 00:35:39,699
lo que va aquí dentro es el código

682
00:35:39,699 --> 00:35:42,300
en realidad es el código asti según la tabla asti

683
00:35:42,300 --> 00:35:43,260
del carácter

684
00:35:43,260 --> 00:35:45,480
entonces un char y ya está

685
00:35:45,480 --> 00:35:47,539
¿que uno quiere guardar nombres?

686
00:35:48,199 --> 00:35:49,360
pues tiene que guardar la variable char

687
00:35:49,360 --> 00:35:52,880
la variable es char

688
00:35:52,880 --> 00:35:53,559
nada más

689
00:35:53,559 --> 00:35:56,699
¿y cuál nos falta?

690
00:35:57,699 --> 00:35:59,360
nos falta una que es medio rara

691
00:35:59,360 --> 00:36:04,380
que recoge la siguiente idea

692
00:36:04,380 --> 00:36:10,699
la información normalmente son datos

693
00:36:10,699 --> 00:36:11,539
¿verdad? son datos

694
00:36:11,539 --> 00:36:14,280
pues una serie de caracteres

695
00:36:14,280 --> 00:36:15,739
que sean nombres, una serie de números

696
00:36:15,739 --> 00:36:18,059
la información son datos, normalmente son datos

697
00:36:18,059 --> 00:36:20,639
pero la información a veces también es

698
00:36:20,639 --> 00:36:23,039
saber si algo ha ocurrido o no ha ocurrido

699
00:36:23,039 --> 00:36:24,800
eso también es información

700
00:36:24,800 --> 00:36:27,260
¿no? saber si algo pasa o no

701
00:36:27,260 --> 00:36:28,960
eso es información también

702
00:36:28,960 --> 00:36:31,320
De hecho, para un programa

703
00:36:31,320 --> 00:36:33,199
Es una información interesante

704
00:36:33,199 --> 00:36:35,880
Porque muchas veces en función de si algo ocurre o no

705
00:36:35,880 --> 00:36:38,500
Es decir, en función de esa información

706
00:36:38,500 --> 00:36:39,800
Hace una cosa o hace otra

707
00:36:39,800 --> 00:36:41,699
Entonces

708
00:36:41,699 --> 00:36:45,300
Lo que se plantea Java

709
00:36:45,300 --> 00:36:46,360
Es tener una variable

710
00:36:46,360 --> 00:36:49,139
Para guardar la siguiente información

711
00:36:49,139 --> 00:36:51,420
Si o no

712
00:36:51,420 --> 00:36:54,179
Es decir, esto es verdad o esto es mentira

713
00:36:54,179 --> 00:36:55,099
Verdad o mentira

714
00:36:55,099 --> 00:36:55,920
Para guardar eso

715
00:36:55,920 --> 00:37:03,900
Podría haberse planteado este lenguaje y muchos otros sin la necesidad de este tipo de datos

716
00:37:03,900 --> 00:37:10,980
Y nosotros por programa codificar el que algo ha ocurrido, por ejemplo, con un char que diga S

717
00:37:10,980 --> 00:37:15,019
Y codificar el que algo no ha ocurrido con un char que diga N

718
00:37:15,019 --> 00:37:19,800
Podríamos hacerlo así, nuestro programa tira y recogería así la información

719
00:37:19,800 --> 00:37:24,679
La información de si algo ha ocurrido sería una S y la información de si algo no ha ocurrido sería una N

720
00:37:24,679 --> 00:37:27,280
pero eso ya sería

721
00:37:27,280 --> 00:37:29,079
un convenio nuestro

722
00:37:29,079 --> 00:37:30,739
una decisión nuestra

723
00:37:30,739 --> 00:37:32,699
entonces es más

724
00:37:32,699 --> 00:37:35,800
es más generalizable todo

725
00:37:35,800 --> 00:37:38,059
si nos planteamos

726
00:37:38,059 --> 00:37:38,840
una variable

727
00:37:38,840 --> 00:37:40,300
que codifique

728
00:37:40,300 --> 00:37:42,900
si algo ha ocurrido o no

729
00:37:42,900 --> 00:37:45,059
y solo eso, y no codifique más cosas

730
00:37:45,059 --> 00:37:47,599
porque un char puede codificar aparte de la s y la n

731
00:37:47,599 --> 00:37:49,239
puede codificar la o, la p

732
00:37:49,239 --> 00:37:51,960
pues no, java ha hecho una variable

733
00:37:51,960 --> 00:37:53,619
que se llama boolean

734
00:37:53,619 --> 00:38:00,829
el tipo de dato

735
00:38:00,829 --> 00:38:02,590
porque es lo que estamos viendo

736
00:38:02,590 --> 00:38:04,909
el tipo de dato es boolean

737
00:38:04,909 --> 00:38:07,289
y esta variable

738
00:38:07,289 --> 00:38:12,309
sirve para guardar esa información

739
00:38:12,309 --> 00:38:29,719
la información de verdad

740
00:38:29,719 --> 00:38:32,739
o mentira

741
00:38:32,739 --> 00:38:38,320
esa es la información que guarda

742
00:38:38,320 --> 00:38:39,059
verdad o mentira

743
00:38:39,059 --> 00:38:41,760
y la guarda

744
00:38:41,760 --> 00:38:44,159
de esta manera

745
00:38:44,159 --> 00:38:45,539
según este convenio

746
00:38:45,539 --> 00:38:48,639
Cuando tenga true

747
00:38:48,639 --> 00:38:50,860
Cuando tenga true

748
00:38:50,860 --> 00:38:52,599
Y cuando digo true no digo la cadena true

749
00:38:52,599 --> 00:38:54,980
Sino la forma en la que Java guarda en binario

750
00:38:54,980 --> 00:38:55,920
Esa idea de true

751
00:38:55,920 --> 00:38:57,920
Cuando tenga esto

752
00:38:57,920 --> 00:38:59,400
Luego ya veremos en este programa

753
00:38:59,400 --> 00:39:01,039
Como ver si lo que ha guardado es esto

754
00:39:01,039 --> 00:39:04,320
Cuando tenga true será haber codificado verdad

755
00:39:04,320 --> 00:39:06,340
Y cuando tenga false

756
00:39:06,340 --> 00:39:09,300
Estará codificando

757
00:39:09,300 --> 00:39:10,920
O almacenando mentira

758
00:39:10,920 --> 00:39:12,880
Y solo puede tener estos dos valores

759
00:39:12,880 --> 00:39:15,079
No puede almacenar nada más que esto

760
00:39:15,079 --> 00:39:32,840
vale, pues las variables Boolean

761
00:39:32,840 --> 00:39:34,500
con estos dos posibles valores

762
00:39:34,500 --> 00:39:35,860
y solo estos dos posibles valores

763
00:39:35,860 --> 00:39:38,360
se usan en muchos lenguajes de programación

764
00:39:38,360 --> 00:39:40,800
y su existencia nos permite

765
00:39:40,800 --> 00:39:42,840
cosas como entender

766
00:39:42,840 --> 00:39:44,719
más fácilmente los códigos de otros

767
00:39:44,719 --> 00:39:46,840
¿no? porque si otros recogen

768
00:39:46,840 --> 00:39:48,820
la información de verdad o mentira

769
00:39:48,820 --> 00:39:50,000
con una S o con una N

770
00:39:50,000 --> 00:39:51,940
lo tengo que imaginar yo, que la recogen así

771
00:39:51,940 --> 00:39:53,519
o si la recogen con un 0 o con un 1

772
00:39:53,519 --> 00:39:56,840
lo tengo que interpretar yo, que la han recogido con un 0 y con un 1

773
00:39:56,840 --> 00:39:58,099
es un poquito más complicado

774
00:39:58,099 --> 00:40:00,920
pero que existan variables boolean para recoger

775
00:40:00,920 --> 00:40:03,199
pasa o no pasa, verdad o mentira

776
00:40:03,199 --> 00:40:04,079
y además

777
00:40:04,079 --> 00:40:06,460
con estos términos

778
00:40:06,460 --> 00:40:08,760
nos permite de alguna manera trabajar

779
00:40:08,760 --> 00:40:10,380
de forma más homogénea a todo el mundo

780
00:40:10,380 --> 00:40:12,099
y entender más los códigos de otros

781
00:40:12,099 --> 00:40:14,059
pero eso nos iría a dejar en el diario

782
00:40:14,059 --> 00:40:16,960
podríamos guardar

783
00:40:16,960 --> 00:40:17,780
esta misma información

784
00:40:17,780 --> 00:40:19,760
con las variables que ya tenemos

785
00:40:19,760 --> 00:40:22,059
pero claro, estableciendo un convenio

786
00:40:22,059 --> 00:40:24,119
que sería un convenio del programador

787
00:40:24,119 --> 00:40:26,019
no un convenio general

788
00:40:29,360 --> 00:40:31,360
Bueno, estos son los tipos de datos que existen en Java.

789
00:40:32,559 --> 00:40:36,360
Y estos tipos de datos se llaman primitivos.

790
00:40:42,699 --> 00:40:44,719
Tipos de datos primitivos en Java.

791
00:40:44,860 --> 00:40:50,300
Son los que hemos dicho, los primitivos, porque son los originales, los que trae de serie.

792
00:40:54,820 --> 00:40:57,320
Y todo esto, de nuevo, pues os lo vais creando en la cabeza.

793
00:40:58,440 --> 00:41:02,059
Los tipos de datos primitivos son estos que hemos mencionado, pero no se va a ver a ninguno.

794
00:41:02,059 --> 00:41:06,480
y cualquier otra información que queramos

795
00:41:06,480 --> 00:41:08,800
guardar y con la que queramos trabajar

796
00:41:08,800 --> 00:41:10,820
tiene que ser

797
00:41:10,820 --> 00:41:12,380
con muchos de estos

798
00:41:12,380 --> 00:41:14,320
con muchos de estos, no hay otro

799
00:41:14,320 --> 00:41:15,739
con muchos de estos

800
00:41:15,739 --> 00:41:18,840
luego ves que claro, muchos de estos es un rollo

801
00:41:18,840 --> 00:41:20,179
por ejemplo, si yo quiero trabajar

802
00:41:20,179 --> 00:41:22,440
con páginas de un libro

803
00:41:22,440 --> 00:41:25,139
pues cada página tiene muchos caracteres

804
00:41:25,139 --> 00:41:26,440
cada página son un montón de chat

805
00:41:26,440 --> 00:41:29,139
entonces es un rollo trabajar con un montón de chat

806
00:41:29,139 --> 00:41:30,739
pues hay que trabajar con un montón de chat

807
00:41:30,739 --> 00:41:32,199
lo que pasa es que claro

808
00:41:32,199 --> 00:41:34,579
lo que hace Java es ya darnos

809
00:41:34,579 --> 00:41:35,920
software hecho

810
00:41:35,920 --> 00:41:38,920
para trabajar de golpe con un montón de chat

811
00:41:38,920 --> 00:41:41,079
pero lo hace él, trabaja con un montón de chat

812
00:41:41,079 --> 00:41:41,860
y yo lo uso

813
00:41:41,860 --> 00:41:45,179
y eso es lo que se llaman las clases

814
00:41:45,179 --> 00:41:46,519
ese concepto de clases

815
00:41:46,519 --> 00:41:49,059
las clases son

816
00:41:49,059 --> 00:41:50,820
código ya hecho

817
00:41:50,820 --> 00:41:52,880
que me permite a mí

818
00:41:52,880 --> 00:41:55,880
abstraerme de ciertas tareas

819
00:41:55,880 --> 00:41:57,099
lo uso

820
00:41:57,099 --> 00:41:58,239
y se acabó

821
00:41:58,239 --> 00:42:01,260
Bueno, pues en este caso

822
00:42:01,260 --> 00:42:04,219
Si yo quiero trabajar con datos

823
00:42:04,219 --> 00:42:06,219
Que no sean exactamente de estos tipos

824
00:42:06,219 --> 00:42:07,800
Sino que sean muchos de ellos

825
00:42:07,800 --> 00:42:09,860
Combinaciones

826
00:42:09,860 --> 00:42:12,920
Pues un tipo de datos que me interesa

827
00:42:12,920 --> 00:42:15,599
Quiero que sean números y luego letras después

828
00:42:15,599 --> 00:42:17,599
Ese tipo de datos no se recoge en ningún dato primitivo

829
00:42:17,599 --> 00:42:21,260
Pues tengo que combinar estas variables

830
00:42:21,260 --> 00:42:23,940
O las combino yo y las trabajo yo

831
00:42:23,940 --> 00:42:26,280
Combinándolas y usando varias de ellas

832
00:42:26,280 --> 00:42:29,139
o a lo mejor si hay una clase

833
00:42:29,139 --> 00:42:29,960
me lo hace estupendo

834
00:42:29,960 --> 00:42:31,260
o si no la puedo hacer bien

835
00:42:31,260 --> 00:42:33,300
pero los tipos de datos primitivos que hay son estos

836
00:42:33,300 --> 00:42:34,440
y no hay más que estos

837
00:42:34,440 --> 00:42:37,300
cualquier dato que yo quiera almacenar

838
00:42:37,300 --> 00:42:39,559
tiene que ser con muchos de esos

839
00:42:39,559 --> 00:42:40,119
con muchos

840
00:42:40,119 --> 00:42:43,179
y como normalmente trabajamos con muchos

841
00:42:43,179 --> 00:42:45,559
pues entonces existe ya código hecho

842
00:42:45,559 --> 00:42:47,179
para trabajar con muchos de estos

843
00:42:47,179 --> 00:42:50,199
como son los arrays, las colecciones, etc

844
00:42:50,199 --> 00:42:52,039
que forman parte de todo lo que tenemos que ver

845
00:42:52,039 --> 00:42:53,980
pero ahora mismo tenemos que

846
00:42:53,980 --> 00:42:56,079
saber usar tipos primitivos de datos

847
00:42:56,079 --> 00:42:58,340
y trabajar con ellos

848
00:42:58,340 --> 00:43:00,860
vale

849
00:43:00,860 --> 00:43:03,119
relajamos un poquito

850
00:43:03,119 --> 00:43:04,340
pero mientras paso lista

851
00:43:04,340 --> 00:43:06,179
y así para las dos últimas horas

852
00:43:06,179 --> 00:43:07,920
y así descansáis un poco