1
00:00:01,520 --> 00:00:07,740
Vale, pues en lo que estábamos, lo que no incorporamos el otro día, las cadenas de caracteres, ¿las podemos leer por teclado?

2
00:00:08,140 --> 00:00:13,160
Hombre, claro, si no pudiéramos leerlas por teclado y tuviéramos que ponerlas siempre ahí en el código, ¿de qué nos sirve?

3
00:00:13,339 --> 00:00:17,420
Es como un programa para sumar dos números.

4
00:00:17,739 --> 00:00:24,660
Si los dos números yo no se los puedo meter por teclado, sino que tienen que ser siempre los dos números que yo ponga en el código, ¿para qué me vale esa aplicación?

5
00:00:25,420 --> 00:00:29,839
Bueno, pues las cadenas de caracteres también las podemos leer por teclado, lógicamente.

6
00:00:29,839 --> 00:00:32,640
Y lo mismo para leer por teclado

7
00:00:32,640 --> 00:00:34,859
Disponemos de este objeto

8
00:00:34,859 --> 00:00:35,740
Que ya hemos usado

9
00:00:35,740 --> 00:00:37,880
Para leer numeritos

10
00:00:37,880 --> 00:00:40,380
Que ya sabemos que

11
00:00:40,380 --> 00:00:42,880
Aunque no lo entendamos

12
00:00:42,880 --> 00:00:44,880
Del todo o del nada

13
00:00:44,880 --> 00:00:46,960
Ya sabemos que lo tenemos que

14
00:00:46,960 --> 00:00:49,799
Que asignar así

15
00:00:49,799 --> 00:00:52,280
Lo declaramos, es este tipo

16
00:00:52,280 --> 00:00:54,759
Objeto raro, escáner

17
00:00:54,759 --> 00:00:57,240
Y así le tenemos que asignar

18
00:00:57,240 --> 00:00:58,359
Una vez que hemos hecho esto

19
00:00:58,359 --> 00:00:59,659
Este objeto ya puede

20
00:00:59,659 --> 00:01:02,020
Leer una y otra vez lo que a mí me dé la gana

21
00:01:02,020 --> 00:01:02,859
Una y otra vez

22
00:01:02,859 --> 00:01:06,079
Por ejemplo, aquí en lugar de asignarle el nombre directamente

23
00:01:06,079 --> 00:01:07,640
Podríamos

24
00:01:07,640 --> 00:01:09,760
Dárselo

25
00:01:09,760 --> 00:01:13,730
¿Vale?

26
00:01:16,459 --> 00:01:17,359
Por teclado

27
00:01:17,359 --> 00:01:19,939
Por ejemplo

28
00:01:19,939 --> 00:01:23,260
Introduzca nombre

29
00:01:23,260 --> 00:01:27,709
Y ahora

30
00:01:27,709 --> 00:01:30,849
¿A quién le vamos a asignar lo que leamos por teclado?

31
00:01:31,129 --> 00:01:32,469
Venga, pues a esta misma variable

32
00:01:32,469 --> 00:01:33,489
A nombre

33
00:01:33,489 --> 00:01:35,870
¿Vale?

34
00:01:36,870 --> 00:01:37,590
A nombre

35
00:01:37,590 --> 00:01:39,349
¿Qué le vamos a asignar?

36
00:01:39,609 --> 00:01:41,909
El resultado de leer por teclado

37
00:01:41,909 --> 00:01:43,569
Pero ahora ya no es un int

38
00:01:43,569 --> 00:01:45,310
Con lo cual no hacemos next int

39
00:01:45,310 --> 00:01:47,829
No es un double, con lo cual no hacemos next double

40
00:01:47,829 --> 00:01:50,549
No es un boolean, con lo cual no hacemos next boolean

41
00:01:50,549 --> 00:01:51,189
Es un string

42
00:01:51,189 --> 00:01:54,230
Entonces no es next string

43
00:01:54,230 --> 00:01:55,590
Una pena

44
00:01:55,590 --> 00:01:57,069
Porque si no sería todo igualito, pero no

45
00:01:57,069 --> 00:01:59,370
Es algo también muy intuitivo

46
00:01:59,370 --> 00:02:00,430
Next line

47
00:02:00,430 --> 00:02:02,530
¿Vale? Es next line

48
00:02:02,530 --> 00:02:05,250
Pues ya está, next line ¿qué es lo que hace?

49
00:02:06,129 --> 00:02:07,370
Es una acción

50
00:02:07,370 --> 00:02:09,810
Del escáner, que cuando yo la invoco

51
00:02:09,810 --> 00:02:11,490
Cuando yo invoco esa acción

52
00:02:11,490 --> 00:02:12,590
Se queda esperando

53
00:02:12,590 --> 00:02:14,810
Que yo meta lo que sea

54
00:02:14,810 --> 00:02:16,169
Hasta un enter

55
00:02:16,169 --> 00:02:19,430
Y cuando ya he llegado al enter, coge todo eso

56
00:02:19,430 --> 00:02:21,569
Que son caracteres así, números, espacios

57
00:02:21,569 --> 00:02:23,669
Letras, lo que sea, coge todo hasta el enter

58
00:02:23,669 --> 00:02:24,550
¿Vale?

59
00:02:25,090 --> 00:02:26,330
Esto es lo que hace el next line

60
00:02:26,330 --> 00:02:38,620
Coge del teclado todo lo que metamos

61
00:02:38,620 --> 00:02:44,490
Hasta un

62
00:02:44,490 --> 00:02:45,289
Salto de línea

63
00:02:45,289 --> 00:02:49,930
Para hacerlo más corto

64
00:02:49,930 --> 00:02:50,650
Sea lo que sea

65
00:02:50,650 --> 00:02:52,509
y ahora ya pues con ese nombre

66
00:02:52,509 --> 00:02:53,969
uno ya podría hacer lo que quiera

67
00:02:53,969 --> 00:02:56,449
concatenarlo, aquí lo hemos concatenado dos veces

68
00:02:56,449 --> 00:02:58,689
y lo mostramos, pues nos aparecería

69
00:02:58,689 --> 00:03:00,669
dos veces, mostramos el carácter en la posición

70
00:03:00,669 --> 00:03:01,569
tres

71
00:03:01,569 --> 00:03:04,689
vamos a ponerlo

72
00:03:04,689 --> 00:03:06,729
para U, para ejecutarlo

73
00:03:06,729 --> 00:03:08,189
y ver que se hace bien

74
00:03:08,189 --> 00:03:21,120
posición tres

75
00:03:21,120 --> 00:03:23,280
carácter en posición

76
00:03:23,280 --> 00:03:24,919
tres, lo mostramos aquí

77
00:03:24,919 --> 00:03:27,379
ahora vamos a poner el tamaño

78
00:03:27,379 --> 00:03:33,750
longitud

79
00:03:33,750 --> 00:03:35,889
de la cadena

80
00:03:35,889 --> 00:03:40,090
mostramos la longitud de la cadena

81
00:03:40,090 --> 00:03:41,810
que hemos leído aquí, le damos

82
00:03:41,810 --> 00:03:43,949
asignado a esta variable, mostramos la variable

83
00:03:43,949 --> 00:03:45,949
y ahora vamos a ver

84
00:03:45,949 --> 00:03:47,569
si la cadena es igual

85
00:03:47,569 --> 00:03:49,210
a esto, me va a decir

86
00:03:49,210 --> 00:03:51,610
falso, vale, obviamente

87
00:03:51,610 --> 00:03:53,889
me va a decir falso, a menos que yo le meta esto directamente

88
00:03:53,889 --> 00:03:54,310
claro

89
00:03:54,310 --> 00:03:57,689
vale, pues si probamos

90
00:03:57,689 --> 00:03:59,909
a ejecutar esto

91
00:03:59,909 --> 00:04:01,830
vale

92
00:04:01,830 --> 00:04:03,189
introduzca nombre

93
00:04:03,189 --> 00:04:06,189
vale, pues primero me ha mostrado

94
00:04:06,189 --> 00:04:08,330
la concatenación de los dos, que era lo primero que yo había

95
00:04:08,330 --> 00:04:10,050
hecho en mi código, concatenar

96
00:04:10,050 --> 00:04:12,449
nombre más nombre, asignarlo a nombre dos

97
00:04:12,449 --> 00:04:14,250
y mostrarlo

98
00:04:14,250 --> 00:04:15,870
carácter en posición tres, la E

99
00:04:15,870 --> 00:04:18,269
efectivamente, porque cero es la P

100
00:04:18,269 --> 00:04:20,310
uno es la E, dos es

101
00:04:20,310 --> 00:04:22,490
la P y tres es la E, pues justo

102
00:04:22,490 --> 00:04:24,329
me lo ha mostrado bien, longitud de la

103
00:04:24,329 --> 00:04:26,209
cadena, cuatro, efectivamente, tiene cuatro

104
00:04:26,209 --> 00:04:28,329
caracteres, es igual a

105
00:04:28,329 --> 00:04:30,089
la bla bla bla que yo he puesto ahí

106
00:04:30,089 --> 00:04:32,189
no, no es igual, por eso me sale

107
00:04:32,189 --> 00:04:52,430
falso vale si metiéramos la bla bla bla está pues obviamente me daría true vale me da la

108
00:04:52,430 --> 00:04:57,829
concatenación carácter en posición 3 la efe longitud de la cadena esta vez 5 bueno pues

109
00:04:57,829 --> 00:05:07,310
con este uso básico de cadenas ya podemos hacer muchas cosas que necesitamos entonces a lo que

110
00:05:07,310 --> 00:05:14,810
íbamos aún así está este listado de ejercicios es para ver que con los objetos string se pueden

111
00:05:14,810 --> 00:05:21,230
hacer más cosas porque pueden hacer muchas más acciones que estas tres que hemos visto vale esto

112
00:05:21,230 --> 00:05:28,550
de aquí es para mostrar el igual si eso ya lo conocemos este de aquí es para mostrar es la

113
00:05:28,550 --> 00:05:35,649
acción to upper case por nombre ya lo podemos deducir le das una cadena y te devuelve la

114
00:05:35,649 --> 00:05:37,829
cadena en mayúscula, vale

115
00:05:37,829 --> 00:05:39,810
es decir, si

116
00:05:39,810 --> 00:05:41,870
lo pongo solo

117
00:05:41,870 --> 00:05:43,810
como ejemplito, pero repito, estos métodos

118
00:05:43,810 --> 00:05:45,730
bueno, que nos suene, que los objetos

119
00:05:45,730 --> 00:05:47,269
string pueden hacer muchas cosas

120
00:05:47,269 --> 00:05:49,230
pero no hace falta que nos sepamos de memoria

121
00:05:49,230 --> 00:05:51,589
cuantas y como son

122
00:05:51,589 --> 00:05:53,529
vale, por ejemplo, si a la cadena

123
00:05:53,529 --> 00:05:55,810
esta nombre, yo le

124
00:05:55,810 --> 00:05:57,889
llamo a ese método

125
00:05:57,889 --> 00:05:59,750
me va a devolver la

126
00:05:59,750 --> 00:06:01,709
cadena en mayúscula

127
00:06:01,709 --> 00:06:05,269
por ejemplo, si la guardo aquí

128
00:06:05,269 --> 00:06:09,250
vale, si yo mostrara esto

129
00:06:09,250 --> 00:06:21,089
si yo mostrara esto

130
00:06:21,089 --> 00:06:22,930
me devolvería la variable

131
00:06:22,930 --> 00:06:24,329
en mayúsculas

132
00:06:24,329 --> 00:06:25,649
cualquier cosa

133
00:06:25,649 --> 00:06:29,339
y me la darán, vale

134
00:06:29,339 --> 00:06:31,920
entonces estos ejercicios son solamente para eso

135
00:06:31,920 --> 00:06:34,480
son ejercicios de una línea para probar esos métodos

136
00:06:34,480 --> 00:06:35,720
lo que hacen para ganar

137
00:06:35,720 --> 00:06:38,500
pero nada más, no espero ahora mismo

138
00:06:38,500 --> 00:06:39,639
que os sepáis

139
00:06:39,639 --> 00:06:42,560
que esos métodos existen y de memoria

140
00:06:42,560 --> 00:06:44,579
además, cuál es su

141
00:06:44,579 --> 00:06:46,000
sintaxis, vale

142
00:06:46,000 --> 00:06:48,319
este es para el led que lo conocemos

143
00:06:48,319 --> 00:06:50,560
este para probar el operador

144
00:06:50,560 --> 00:06:51,959
más que también lo conocemos

145
00:06:51,959 --> 00:06:54,459
que se puede concatenar también

146
00:06:54,459 --> 00:06:56,379
con esta acción pero si ya

147
00:06:56,379 --> 00:06:58,399
tenemos esta pues para que complica el código

148
00:06:58,399 --> 00:07:01,339
esta es para sacar

149
00:07:01,339 --> 00:07:03,680
la subcadena de una cadena

150
00:07:03,680 --> 00:07:06,660
esta es interesante muchas veces

151
00:07:06,660 --> 00:07:08,160
entonces tenemos

152
00:07:08,160 --> 00:07:09,699
una cadena

153
00:07:09,699 --> 00:07:12,060
y queremos sacar solo una parte

154
00:07:12,060 --> 00:07:14,180
pues se llama este método

155
00:07:14,180 --> 00:07:16,939
Substream pasándole un índice

156
00:07:16,939 --> 00:07:18,480
Y te saca la cadena que hay

157
00:07:18,480 --> 00:07:19,699
A partir de ese índice

158
00:07:19,699 --> 00:07:22,100
Solo quiero que os suenen que se pueden hacer muchas cosas

159
00:07:22,100 --> 00:07:23,959
Con las cadenas para operar con ellas

160
00:07:23,959 --> 00:07:26,300
Substream pues eso es un poco más complicado

161
00:07:26,300 --> 00:07:28,439
Este, reemplazar

162
00:07:28,439 --> 00:07:29,980
Le pasas un carácter

163
00:07:29,980 --> 00:07:32,839
Y de la cadena que llama a esta acción

164
00:07:32,839 --> 00:07:34,540
De la cadena que llama a esta acción

165
00:07:34,540 --> 00:07:36,720
Sustituye un carácter por el otro

166
00:07:36,720 --> 00:07:38,819
Y ya está

167
00:07:38,819 --> 00:07:40,860
Si empieza con o termina con

168
00:07:40,860 --> 00:07:41,779
Te devuelve un boolean

169
00:07:41,779 --> 00:07:43,759
Y el charlat que ya lo hemos visto

170
00:07:43,759 --> 00:07:45,699
Y así muchos más métodos

171
00:07:45,699 --> 00:07:46,699
Aparte de estos, ¿vale?

172
00:07:47,379 --> 00:07:49,279
Bueno, pues si uno los quiere hacer

173
00:07:49,279 --> 00:07:51,220
Es poner esa línea para probar el método

174
00:07:51,220 --> 00:07:53,379
Como funciona, ya está, pues fenomenal

175
00:07:53,379 --> 00:07:54,300
¿Vale?

176
00:07:56,160 --> 00:07:56,600
Vale

177
00:07:56,600 --> 00:07:58,819
Y

178
00:07:58,819 --> 00:08:01,360
Y ya está, esto es lo que tenemos aquí

179
00:08:01,360 --> 00:08:05,819
Vale, antes de pasar

180
00:08:05,819 --> 00:08:07,800
A esto de aquí, que ya lo estaréis

181
00:08:07,800 --> 00:08:09,720
Deseando, porque estamos ya haciendo lo mismo

182
00:08:09,720 --> 00:08:10,339
Una y otra vez

183
00:08:10,339 --> 00:08:12,339
Pues antes de pasar esto de aquí

184
00:08:12,339 --> 00:08:16,000
Vamos a hacer una pequeña tontería

185
00:08:16,000 --> 00:08:17,920
¿Vale?

186
00:08:19,060 --> 00:08:19,740
Os he dicho

187
00:08:19,740 --> 00:08:21,540
Por Dios nunca jamás

188
00:08:21,540 --> 00:08:23,800
Porque os suspendo este curso

189
00:08:23,800 --> 00:08:25,800
Y el módulo de segundo

190
00:08:25,800 --> 00:08:26,620
Ya crédito

191
00:08:26,620 --> 00:08:29,120
Pues lo digo ahora

192
00:08:29,120 --> 00:08:31,680
A lo mejor estabas dormido hablando con

193
00:08:31,680 --> 00:08:32,779
Jesús

194
00:08:32,779 --> 00:08:39,059
Bueno, pues entonces lo digo ahora

195
00:08:39,059 --> 00:08:42,059
Yo os he dicho por Dios santo bendito

196
00:08:42,059 --> 00:08:44,059
Cuando comparéis dos variables string

197
00:08:44,059 --> 00:08:45,860
A ver si vais a poner el doble igual

198
00:08:45,860 --> 00:08:47,240
Eso nunca jamás

199
00:08:47,240 --> 00:08:49,779
Porque si ponéis el doble igual

200
00:08:49,779 --> 00:08:51,399
Que era lo que ocurría

201
00:08:51,399 --> 00:08:54,039
Recordáis que estábamos en ese caso

202
00:08:54,039 --> 00:08:55,700
Justo

203
00:08:55,700 --> 00:08:57,480
Justo

204
00:08:57,480 --> 00:08:58,559
Si yo pongo

205
00:08:58,559 --> 00:09:00,519
Vamos a hacerlo aquí con

206
00:09:00,519 --> 00:09:02,220
String

207
00:09:02,220 --> 00:09:04,620
Cadena 1

208
00:09:04,620 --> 00:09:07,720
Igual a

209
00:09:07,720 --> 00:09:10,419
Hola

210
00:09:10,419 --> 00:09:17,960
y ahora pongo aquí otra cadena 2

211
00:09:17,960 --> 00:09:20,840
en líneas separadas para que se vea mejor

212
00:09:20,840 --> 00:09:27,789
igual a hola

213
00:09:27,789 --> 00:09:29,730
vale, entonces

214
00:09:29,730 --> 00:09:33,029
vamos a mostrar a ver si son iguales

215
00:09:33,029 --> 00:09:34,769
vale, entonces

216
00:09:34,769 --> 00:09:40,250
1, ya he dicho

217
00:09:40,250 --> 00:09:43,309
debemos mostrar como son cadenas de caracteres

218
00:09:43,309 --> 00:09:47,330
nunca haríamos esto, cadena 1 igual a cadena 2

219
00:09:47,330 --> 00:09:53,000
Esto lo hacemos si queremos ver

220
00:09:53,000 --> 00:09:55,039
Obtener el boolean resultante

221
00:09:55,039 --> 00:09:57,019
De ver si esta variable

222
00:09:57,019 --> 00:09:58,559
Es igual a esta otra

223
00:09:58,559 --> 00:10:00,080
Pero siendo estas variables

224
00:10:00,080 --> 00:10:01,899
Cualquiera de los tipos primitivos

225
00:10:01,899 --> 00:10:05,679
By, short, in, long, flow, double, char y boolean

226
00:10:05,679 --> 00:10:07,860
Para cualquiera de esos tipos primitivos

227
00:10:07,860 --> 00:10:10,039
Si yo quiero ver si el contenido de una variable

228
00:10:10,039 --> 00:10:11,639
Es igual al de otra, doble igual

229
00:10:11,639 --> 00:10:13,259
Ahí está clarísimo

230
00:10:13,259 --> 00:10:15,639
Vale, pero este es el primer tipo

231
00:10:15,639 --> 00:10:17,600
No primitivo objeto que introducimos

232
00:10:17,600 --> 00:10:20,940
vale, efectivamente, entonces yo aún así

233
00:10:20,940 --> 00:10:22,960
en dos variables de tipo objeto

234
00:10:22,960 --> 00:10:24,980
también puedo necesitar saber

235
00:10:24,980 --> 00:10:26,159
si contienen lo mismo

236
00:10:26,159 --> 00:10:28,940
esta contiene hola

237
00:10:28,940 --> 00:10:30,940
en este caso concreto y esta otra también

238
00:10:30,940 --> 00:10:32,139
contiene en este caso concreto

239
00:10:32,139 --> 00:10:34,639
vale, entonces hemos dicho, no, nada de

240
00:10:34,639 --> 00:10:36,679
hacerlo así

241
00:10:36,679 --> 00:10:39,080
lo tenemos que hacer así

242
00:10:39,080 --> 00:10:43,960
vale, y de hecho

243
00:10:43,960 --> 00:10:45,860
probamos el equal, si vemos que funciona

244
00:10:45,860 --> 00:10:47,919
perfectamente, no, voy a

245
00:10:47,919 --> 00:10:49,580
cuando ejecute esto voy a poner aquí

246
00:10:49,580 --> 00:10:51,659
Una

247
00:10:51,659 --> 00:10:54,120
Barrita

248
00:10:54,120 --> 00:10:57,019
Para saber cuando hemos llegado

249
00:10:57,019 --> 00:10:58,639
A ese punto de la ejecución

250
00:10:58,639 --> 00:11:01,240
Vale, pues ejecutamos esto

251
00:11:01,240 --> 00:11:02,600
Aquí

252
00:11:02,600 --> 00:11:05,000
Vale

253
00:11:05,000 --> 00:11:07,659
Y después de la barrita

254
00:11:07,659 --> 00:11:09,100
True, false

255
00:11:09,100 --> 00:11:10,139
Le he puesto dos system out

256
00:11:10,139 --> 00:11:13,000
Ah, que me he dejado otro

257
00:11:13,000 --> 00:11:13,519
¿Dónde está?

258
00:11:17,779 --> 00:11:19,299
Ah, vale, que este iguales no sé dónde

259
00:11:19,299 --> 00:11:20,899
Ah, es que este iguales lo he cortado

260
00:11:20,899 --> 00:11:22,059
Era de arriba en realidad

261
00:11:22,059 --> 00:11:24,600
Este iguales venía de

262
00:11:24,600 --> 00:11:25,980
De por ahí arriba

263
00:11:25,980 --> 00:11:30,429
De por ahí

264
00:11:30,429 --> 00:11:37,070
Vale, entonces ahora ya sí

265
00:11:37,070 --> 00:11:38,269
Lo ejecutamos, bueno

266
00:11:38,269 --> 00:11:41,269
Vale, y me da true porque las dos cadenas

267
00:11:41,269 --> 00:11:43,210
Son iguales, eso está claro, es lo que esperamos

268
00:11:43,210 --> 00:11:44,889
¿No? Vale

269
00:11:44,889 --> 00:11:47,009
Si yo aquí cambiara y me

270
00:11:47,009 --> 00:11:48,309
Pusiera esta otra

271
00:11:48,309 --> 00:11:51,049
O si las estoy introduciendo por teclado e introdujera dos

272
00:11:51,049 --> 00:11:52,169
Distintas, da igual

273
00:11:52,169 --> 00:11:54,330
Pues ejecutamos esto

274
00:11:54,330 --> 00:11:57,090
Falso

275
00:11:57,090 --> 00:12:01,909
¿Vale? Pues el igual funciona exactamente como nosotros esperamos y es lo que tiene que hacer, ¿vale?

276
00:12:02,549 --> 00:12:16,649
Bueno, pues ¿qué he dicho yo? Cuidado a ver si uno va a escribir así deprisa a toda velocidad y compara cadena 1 con cadena 2 así, ¿vale?

277
00:12:16,649 --> 00:12:19,090
cuidado

278
00:12:19,090 --> 00:12:21,809
porque si compara cadena 1

279
00:12:21,809 --> 00:12:22,970
con cadena 2 así

280
00:12:22,970 --> 00:12:26,070
vale, acordaos

281
00:12:26,070 --> 00:12:28,110
rápidamente de lo que estábamos haciendo

282
00:12:28,110 --> 00:12:30,309
que nadie se le olvide

283
00:12:30,309 --> 00:12:32,029
que entonces

284
00:12:32,029 --> 00:12:33,409
tenemos, esta es la cadena

285
00:12:33,409 --> 00:12:34,809
este es

286
00:12:34,809 --> 00:12:36,470
el

287
00:12:36,470 --> 00:12:42,289
vale, que sí, que sí

288
00:12:42,289 --> 00:12:48,309
vale, esta es la cadena 1

289
00:12:48,309 --> 00:12:49,870
se llame como se llame

290
00:12:49,870 --> 00:12:55,679
vale

291
00:12:55,679 --> 00:12:59,379
Esta es

292
00:12:59,379 --> 00:13:07,779
La cadena 2

293
00:13:07,779 --> 00:13:13,220
Y entonces sabemos que cadena 1

294
00:13:13,220 --> 00:13:15,600
En realidad es una dirección de memoria

295
00:13:15,600 --> 00:13:17,539
Con lo cual cadena 1 lo que tiene dentro

296
00:13:17,539 --> 00:13:19,080
En realidad es una dirección de memoria

297
00:13:19,080 --> 00:13:21,820
Que me lleva a un espacio en memoria RAM

298
00:13:21,820 --> 00:13:23,580
Donde ahora ya

299
00:13:23,580 --> 00:13:25,100
Si que está

300
00:13:25,100 --> 00:13:27,059
El hola dentro

301
00:13:27,059 --> 00:13:28,820
Ahí si que está el hola

302
00:13:28,820 --> 00:13:31,259
Y cadena 2

303
00:13:31,259 --> 00:13:32,840
Es otra dirección de memoria

304
00:13:32,840 --> 00:13:33,940
que me lleva

305
00:13:33,940 --> 00:13:36,519
a otro espacio

306
00:13:36,519 --> 00:13:38,419
donde ahora ya sí que está el contenido

307
00:13:38,419 --> 00:13:46,139
¿vale? todo el mundo

308
00:13:46,139 --> 00:13:48,500
aunque no lo tenemos que tener presente

309
00:13:48,500 --> 00:13:50,360
todo el rato, todo el mundo

310
00:13:50,360 --> 00:13:51,519
entiende que

311
00:13:51,519 --> 00:13:54,460
esto es lo que físicamente hay en memoria

312
00:13:54,460 --> 00:13:56,039
cuando declaramos dos variables objeto

313
00:13:56,039 --> 00:13:58,700
cadena 1 en realidad es una dirección

314
00:13:58,700 --> 00:13:59,740
y esa dirección

315
00:13:59,740 --> 00:14:02,500
de donde es, es la dirección de una porción

316
00:14:02,500 --> 00:14:04,179
de RAM donde ahora ya sí que está el valor

317
00:14:04,179 --> 00:14:06,539
y cadena 2

318
00:14:06,539 --> 00:14:07,759
es una dirección de memoria

319
00:14:07,759 --> 00:14:10,899
que de dónde es esa dirección, de otra porción de RAM

320
00:14:10,899 --> 00:14:11,960
donde ya sí que está el valor

321
00:14:11,960 --> 00:14:14,639
si esta variable fuera primitiva

322
00:14:14,639 --> 00:14:16,080
cadena1 fuera un int

323
00:14:16,080 --> 00:14:17,580
esto no existiría

324
00:14:17,580 --> 00:14:21,159
cadena1 sería ya directamente

325
00:14:21,159 --> 00:14:22,919
el valor de la variable

326
00:14:22,919 --> 00:14:24,720
el 3, el 7

327
00:14:24,720 --> 00:14:25,899
esta parte no existiría

328
00:14:25,899 --> 00:14:28,480
pero como es un tipo objeto

329
00:14:28,480 --> 00:14:30,580
es una dirección que lleva una

330
00:14:30,580 --> 00:14:32,519
porción de memoria donde está el contenido

331
00:14:32,519 --> 00:14:34,799
pues por eso es por lo que nos ha quedado

332
00:14:34,799 --> 00:14:36,759
ya clarísimo y no se nos puede olvidar

333
00:14:36,759 --> 00:14:39,379
Que si nosotros tratamos de comparar

334
00:14:39,379 --> 00:14:41,539
La igualdad de esas dos cadenas de ahí

335
00:14:41,539 --> 00:14:43,440
Este hola y este hola

336
00:14:43,440 --> 00:14:45,059
Tratamos de compararlo

337
00:14:45,059 --> 00:14:47,419
Con esto, me va a decir

338
00:14:47,419 --> 00:14:48,919
False

339
00:14:48,919 --> 00:14:51,100
Porque esta dirección

340
00:14:51,100 --> 00:14:53,159
Es una y esta dirección es otra

341
00:14:53,159 --> 00:14:55,799
Otra, que contienen lo mismo

342
00:14:55,799 --> 00:14:56,820
Sí, contienen lo mismo

343
00:14:56,820 --> 00:14:58,320
Pero son diferentes

344
00:14:58,320 --> 00:15:00,240
Y el equals precisamente

345
00:15:00,240 --> 00:15:02,059
Lo que te hace es

346
00:15:02,059 --> 00:15:04,279
Comparar el contenido

347
00:15:04,279 --> 00:15:06,059
El equals es el que hace ese trabajo

348
00:15:06,059 --> 00:15:07,799
Puedo irse aquí, mirar el contenido

349
00:15:07,799 --> 00:15:09,100
Irse aquí, mirar el contenido, etc

350
00:15:09,100 --> 00:15:11,940
Bueno, pues si uno se olvida y escribe así

351
00:15:11,940 --> 00:15:12,580
Rápidamente

352
00:15:12,580 --> 00:15:14,740
Y lo vuelve a hacer

353
00:15:14,740 --> 00:15:17,940
Vale

354
00:15:17,940 --> 00:15:21,779
Esta vez ha salido bien

355
00:15:21,779 --> 00:15:23,159
Vale, ha salido falso

356
00:15:23,159 --> 00:15:25,360
No, no, no, perdón, perdón

357
00:15:25,360 --> 00:15:26,740
Ha salido falso pero lo he cambiado

358
00:15:26,740 --> 00:15:28,860
Vale

359
00:15:28,860 --> 00:15:31,940
Olvidaos de esta ejecución, esta ejecución no ha existido

360
00:15:31,940 --> 00:15:32,759
Vale

361
00:15:32,759 --> 00:15:35,320
Es que no me había dado cuenta que lo había

362
00:15:35,320 --> 00:15:37,980
Vale, yo he puesto hola y he puesto hola

363
00:15:37,980 --> 00:15:40,460
Y ahora me he equivocado y he puesto esto mal.

364
00:15:41,159 --> 00:15:41,360
¿Vale?

365
00:15:41,379 --> 00:15:42,620
Me he equivocado y he puesto esto mal.

366
00:15:43,960 --> 00:15:46,059
Venga, pues ahora ya sí lo volvemos a ejecutar.

367
00:15:47,120 --> 00:15:48,639
Lo volvemos a ejecutar.

368
00:15:51,039 --> 00:15:51,399
¡Ostras!

369
00:15:51,879 --> 00:15:52,759
Y sale true.

370
00:15:54,000 --> 00:15:56,539
Y entonces decís, pues me han mentido.

371
00:15:57,320 --> 00:15:58,360
Me han mentido.

372
00:15:58,360 --> 00:16:01,799
Y entonces llegáis a la conclusión errónea.

373
00:16:02,200 --> 00:16:05,379
Anda, pues entonces los tipos objeto, entre ellos los string.

374
00:16:05,379 --> 00:16:08,240
vaya rollo moruno que me han contado

375
00:16:08,240 --> 00:16:09,980
los puedo comparar

376
00:16:09,980 --> 00:16:11,519
con doble igual, ¿no?

377
00:16:11,580 --> 00:16:13,860
porque es que he hecho la ejecución y ha salido

378
00:16:13,860 --> 00:16:15,860
que son iguales, y no es verdad

379
00:16:15,860 --> 00:16:17,379
con lo que me han contado, no es verdad

380
00:16:17,379 --> 00:16:18,700
¿vale?

381
00:16:19,820 --> 00:16:21,580
pero es que esto es, bueno

382
00:16:21,580 --> 00:16:23,720
uno de los montón de

383
00:16:23,720 --> 00:16:25,940
pequeñas cosas que hace Java

384
00:16:25,940 --> 00:16:27,340
por dentro para evitarse la vida

385
00:16:27,340 --> 00:16:30,179
que se puede manifestar a veces, y esta en particular

386
00:16:30,179 --> 00:16:31,700
os la cuento como anécdota

387
00:16:31,700 --> 00:16:33,379
os la cuento como anécdota

388
00:16:33,379 --> 00:16:49,220
A ver, ¿qué hace Java por dentro en realidad? Tú declaras una cadena de buenas a primeras y le asignas un valor. Y luego de repente declaras otra y le asignas el mismo de la de arriba. Esa es una situación muy concreta, ¿no? Muy concreta.

389
00:16:49,220 --> 00:16:51,960
Pues entonces lo que hace es

390
00:16:51,960 --> 00:16:54,059
Dice, oye, pues mira

391
00:16:54,059 --> 00:16:55,659
En lugar de hacer otro espacio de memoria

392
00:16:55,659 --> 00:16:56,639
Y poner el hola

393
00:16:56,639 --> 00:17:00,019
Voy a hacer que esta dirección de memoria

394
00:17:00,019 --> 00:17:02,139
Voy a hacer que esta cadena 2

395
00:17:02,139 --> 00:17:04,019
En lugar de crearle un espacio de memoria

396
00:17:04,019 --> 00:17:05,359
Pues no lo creo

397
00:17:05,359 --> 00:17:07,019
¿Dónde tengo el borra por ahí?

398
00:17:08,119 --> 00:17:08,559
Claro

399
00:17:08,559 --> 00:17:11,420
Bueno, no sé dónde está el borrador

400
00:17:11,420 --> 00:17:13,220
Pero da igual

401
00:17:13,220 --> 00:17:14,000
Esto

402
00:17:14,000 --> 00:17:16,839
Dice, ¿para qué voy a hacer?

403
00:17:17,500 --> 00:17:18,859
¿Para qué voy a hacer una esta?

404
00:17:19,220 --> 00:17:29,319
Bueno, no hago una de estas, me hago otra cadena 2, porque tengo dos variables string, pero la hago que apunte al mismo sitio, ¿vale?

405
00:17:30,660 --> 00:17:38,900
Entonces, claro, entonces él gestiona una especie de buffer interno hasta cierta cantidad, que no sé si son 2048, no sé qué son.

406
00:17:39,279 --> 00:17:45,539
Si empezáramos a hacer un montón de string, hola, hola, hola, hola, llegaría un momento en que ya no, ¿vale?

407
00:17:45,539 --> 00:17:50,180
Y eso lo he hecho así porque hemos inicializado la variable string de esta manera.

408
00:17:51,059 --> 00:17:51,920
Y esto es un atajo.

409
00:17:52,380 --> 00:17:57,440
En realidad, cuando uno crea un tipo objeto, no lo hace así.

410
00:17:57,980 --> 00:17:59,299
Fijaos cómo hemos hecho el escáner.

411
00:17:59,720 --> 00:18:05,119
Yo he dicho, lector es una variable tipo objeto, por eso tiene este tipo de dato.

412
00:18:06,500 --> 00:18:09,319
Y mirad cómo le hemos dado valor, con new scanner.

413
00:18:10,019 --> 00:18:12,839
Pues a string también podríamos hacerlo hecho, podríamos haberlo hecho.

414
00:18:13,420 --> 00:18:15,279
Podríamos haber hecho new.

415
00:18:15,539 --> 00:18:17,319
string

416
00:18:17,319 --> 00:18:20,160
hola. Y así es como

417
00:18:20,160 --> 00:18:21,500
originalmente

418
00:18:21,500 --> 00:18:24,660
se declaraban. Como es un objeto

419
00:18:24,660 --> 00:18:26,200
yo tengo que hacer new string

420
00:18:26,200 --> 00:18:28,480
y le doy su valor. Pero claro,

421
00:18:28,599 --> 00:18:30,380
como la variable string se usa tantísimo,

422
00:18:31,240 --> 00:18:32,720
la sintaxis de Java te permite

423
00:18:32,720 --> 00:18:33,319
un atajo

424
00:18:33,319 --> 00:18:36,279
y en ese atajo pues tú le pones

425
00:18:36,279 --> 00:18:38,599
directamente hola. Y para otros es muy cómodo

426
00:18:38,599 --> 00:18:40,200
porque es como si fuera una variable primitiva.

427
00:18:40,319 --> 00:18:42,400
Es muy cómodo. ¿Vale? Bueno, pero

428
00:18:42,400 --> 00:18:43,859
asumimos que no hacemos ese atajo,

429
00:18:43,859 --> 00:18:46,019
sino que creamos esta variable objeto

430
00:18:46,019 --> 00:18:48,160
como se crean las variables objeto que ya veremos en el futuro

431
00:18:48,160 --> 00:18:49,740
esto lo estoy contando solo

432
00:18:49,740 --> 00:18:51,359
como anécdota de que

433
00:18:51,359 --> 00:18:54,359
porque me ha salido mal el doble igual

434
00:18:54,359 --> 00:18:56,160
vale, pues entonces

435
00:18:56,160 --> 00:18:57,740
imaginaos que no usamos ese atajo

436
00:18:57,740 --> 00:19:00,380
y que lo hacemos creando el objeto

437
00:19:00,380 --> 00:19:02,359
new string, un nuevo objeto

438
00:19:02,359 --> 00:19:04,279
string, dale este valor

439
00:19:04,279 --> 00:19:05,380
de inicio, etc

440
00:19:05,380 --> 00:19:07,500
pues lo hacemos así

441
00:19:07,500 --> 00:19:09,599
y ahora volvemos a ejecutar esto

442
00:19:09,599 --> 00:19:11,339
y

443
00:19:11,339 --> 00:19:16,269
Y ahora me da false

444
00:19:16,269 --> 00:19:18,210
Y ahora me da false, ¿por qué?

445
00:19:18,809 --> 00:19:20,150
Porque cuando lo hacemos así

446
00:19:20,150 --> 00:19:22,230
Java no se hace este invento

447
00:19:22,230 --> 00:19:24,269
El new dice que me obligas con new

448
00:19:24,269 --> 00:19:26,390
Pues me hago otro espacio de memoria, con otra dirección

449
00:19:26,390 --> 00:19:28,589
Entonces si creamos el objeto string

450
00:19:28,589 --> 00:19:30,750
Con new, esto que yo he dicho

451
00:19:30,750 --> 00:19:32,289
De hacer la trampilla y decir

452
00:19:32,289 --> 00:19:33,809
¿Para qué me voy a hacer otro espacio de memoria?

453
00:19:34,269 --> 00:19:36,150
Uso este y lo hago apuntar

454
00:19:36,150 --> 00:19:37,210
¿Vale?

455
00:19:37,869 --> 00:19:38,789
Pues no lo hace

456
00:19:38,789 --> 00:19:42,170
Conclusión, es imposible

457
00:19:42,170 --> 00:19:43,809
Todas estas cosas tenerlas bajo control

458
00:19:43,809 --> 00:19:46,029
Es imposible, porque en matices

459
00:19:46,029 --> 00:19:47,009
Como esto hay mil

460
00:19:47,009 --> 00:19:48,549
¿Qué es lo más fácil?

461
00:19:49,470 --> 00:19:50,750
Pues siempre con equals

462
00:19:50,750 --> 00:19:52,750
Siempre con equals, ¿vale?

463
00:19:53,089 --> 00:19:55,049
Siempre con equals cuando se comparan dos objetos

464
00:19:55,049 --> 00:19:57,130
Y en este caso nosotros solo tenemos

465
00:19:57,130 --> 00:20:00,450
El string, pues los strings siempre con equals

466
00:20:00,450 --> 00:20:00,789
¿Vale?

467
00:20:02,950 --> 00:20:03,470
Vale

468
00:20:03,470 --> 00:20:07,549
Claro, vosotros ahora también

469
00:20:07,549 --> 00:20:09,230
Después del rollo este que os he contado

470
00:20:09,230 --> 00:20:12,329
Si me hubierais escuchado, que sí, que ya se lo habéis escuchado

471
00:20:12,329 --> 00:20:17,420
Después del rollo este que os he contado

472
00:20:17,420 --> 00:20:18,259
Me diríais

473
00:20:18,259 --> 00:20:20,339
Hombre, pero en este código

474
00:20:20,339 --> 00:20:22,039
String cadena 1, string cadena 2

475
00:20:22,039 --> 00:20:23,559
Yo ahora puedo hacer

476
00:20:23,559 --> 00:20:25,940
Cadena 2 igual a

477
00:20:25,940 --> 00:20:27,079
Adiós

478
00:20:27,079 --> 00:20:29,660
Y significa eso

479
00:20:29,660 --> 00:20:31,700
Que entonces cadena 1 también cambia

480
00:20:31,700 --> 00:20:34,359
Porque claro, con lo que yo os he dicho antes

481
00:20:34,359 --> 00:20:36,019
Con esta declaración

482
00:20:36,019 --> 00:20:37,539
Él ha dicho

483
00:20:37,539 --> 00:20:38,859
¿Declaras cadena 2?

484
00:20:39,299 --> 00:20:40,500
No me hago un espacio nuevo

485
00:20:40,500 --> 00:20:42,920
Cuando ve que haces eso

486
00:20:42,920 --> 00:20:44,480
Entonces ya le he dado un espacio a ella

487
00:20:44,480 --> 00:20:45,859
Ya le he dado un espacio a ella

488
00:20:45,859 --> 00:20:46,859
¿Vale?

489
00:20:47,859 --> 00:20:50,359
Claro, porque entonces el programa perdería

490
00:20:50,359 --> 00:20:52,019
Todo el sentido, uno declara dos variables

491
00:20:52,019 --> 00:20:53,000
Para tener ahí dos cadenas

492
00:20:53,000 --> 00:20:55,920
Si las hace siempre la misma

493
00:20:55,920 --> 00:20:57,180
¿Vale?

494
00:20:59,220 --> 00:21:00,859
Bueno, conclusión

495
00:21:00,859 --> 00:21:03,180
Que cuando

496
00:21:03,180 --> 00:21:05,480
Hay que ver si dos cadenas son iguales

497
00:21:05,480 --> 00:21:07,039
Esto, horrible, horroroso

498
00:21:07,039 --> 00:21:09,880
Aunque casualmente en algunas situaciones concretas

499
00:21:09,880 --> 00:21:11,559
Pueda funcionar, pero por esto

500
00:21:11,559 --> 00:21:13,339
Todo que os digo de fondo

501
00:21:13,339 --> 00:21:16,180
Pero como esto

502
00:21:16,180 --> 00:21:17,960
Uno no tiene por qué tenerlo presente

503
00:21:17,960 --> 00:21:20,279
Pues

504
00:21:20,279 --> 00:21:21,880
Se usa siempre el equals

505
00:21:21,880 --> 00:21:22,859
Mucho mejor

506
00:21:22,859 --> 00:21:27,289
Siempre equals

507
00:21:27,289 --> 00:21:28,569
Bueno

508
00:21:28,569 --> 00:21:33,940
¿Dudas? ¿Preguntas?

509
00:21:34,000 --> 00:21:34,940
Algo de

510
00:21:34,940 --> 00:21:42,960
Como un objeto puede contener dentro varios valores

511
00:21:42,960 --> 00:21:43,539
Si

512
00:21:43,539 --> 00:21:47,019
Tú puedes usar el igual igual para comparar

513
00:21:47,019 --> 00:21:49,960
Hay dos valores del mismo objeto

514
00:21:49,960 --> 00:21:50,940
Sí, claro

515
00:21:50,940 --> 00:21:52,400
Y que te diga que sí que pertenece

516
00:21:52,400 --> 00:21:54,819
Claro, a ver, un objeto podría tener dentro

517
00:21:54,819 --> 00:21:55,920
Un int y un char

518
00:21:55,920 --> 00:21:58,359
Entonces, si tú quieres comparar

519
00:21:58,359 --> 00:22:00,980
Tú puedes querer comparar los dos objetos enteros

520
00:22:00,980 --> 00:22:02,960
Y eso significa que todo lo que contiene sea igual

521
00:22:02,960 --> 00:22:04,140
O puedes querer comparar

522
00:22:04,140 --> 00:22:05,920
Solo el int que contiene cada uno

523
00:22:05,920 --> 00:22:08,380
Entonces, accederías a él y ya veremos cómo

524
00:22:08,380 --> 00:22:09,819
Y ese ya sí que con doble igual

525
00:22:09,819 --> 00:22:11,240
Porque son int

526
00:22:11,240 --> 00:22:12,099
Vale

527
00:22:12,099 --> 00:22:16,859
Venga, pues entonces

528
00:22:16,859 --> 00:22:19,440
Nos vamos aquí

529
00:22:19,440 --> 00:22:23,700
Un momento, espera, vamos a abrir el este de operadores

530
00:22:23,700 --> 00:22:25,380
Porque en el este de operadores

531
00:22:25,380 --> 00:22:28,400
Después de los

532
00:22:28,400 --> 00:22:31,299
De los buleanos

533
00:22:31,299 --> 00:22:34,539
Ya nos hemos puesto a hacer ejercicio

534
00:22:34,539 --> 00:22:36,059
Si se han quedado cosas por ahí debajo

535
00:22:36,059 --> 00:22:39,039
Pero vamos, esto solo mencionarlo

536
00:22:39,039 --> 00:22:39,740
Y poco más

537
00:22:39,740 --> 00:22:42,440
Vale, nos habíamos quedado

538
00:22:42,440 --> 00:22:43,960
No, esto era esto de aquí

539
00:22:43,960 --> 00:22:54,680
Los relacionales

540
00:22:54,680 --> 00:22:56,440
que ya nos lo sabemos

541
00:22:56,440 --> 00:22:58,259
y aquí era

542
00:22:58,259 --> 00:23:00,279
lo último que habíamos visto y a partir de aquí

543
00:23:00,279 --> 00:23:02,640
ya nos habíamos puesto a hacer ejercicios para practicar todo esto

544
00:23:02,640 --> 00:23:03,240
¿vale?

545
00:23:05,200 --> 00:23:05,680
entonces

546
00:23:05,680 --> 00:23:08,519
el AND, el OR y el NOT

547
00:23:08,519 --> 00:23:10,279
y la versión de AND y OR

548
00:23:10,279 --> 00:23:12,160
con una símbolo y dos, ya lo sabemos

549
00:23:12,160 --> 00:23:12,759
y sabemos por qué

550
00:23:12,759 --> 00:23:16,220
este, bueno, queda aquí

551
00:23:16,220 --> 00:23:18,000
ya puesto y simplemente

552
00:23:18,000 --> 00:23:20,160
que sepáis que hay una operación

553
00:23:20,160 --> 00:23:22,279
booleana, normalmente es más

554
00:23:22,279 --> 00:23:24,299
raro que haya necesidad de usarla porque expresa

555
00:23:24,299 --> 00:23:26,440
una idea muy extraña, pero que sepáis

556
00:23:26,440 --> 00:23:28,500
que hay una acción booleana que es el

557
00:23:28,500 --> 00:23:29,579
OR exclusivo

558
00:23:29,579 --> 00:23:32,519
el OR exclusivo

559
00:23:32,519 --> 00:23:33,559
este, el XOR

560
00:23:33,559 --> 00:23:36,400
es, funciona

561
00:23:36,400 --> 00:23:38,720
A, OR exclusivo

562
00:23:38,720 --> 00:23:40,740
B, es cierto

563
00:23:40,740 --> 00:23:42,259
¿vale? si

564
00:23:42,259 --> 00:23:44,440
una de las dos es cierto y la otra

565
00:23:44,440 --> 00:23:45,019
falsa

566
00:23:45,019 --> 00:23:48,180
¿vale? pero si las dos son ciertas, no

567
00:23:48,180 --> 00:23:50,480
o sea, es una diferencia con el OR normal, porque el OR

568
00:23:50,480 --> 00:23:52,279
normal, las dos ciertas

569
00:23:52,279 --> 00:23:53,740
una cierta y una falsa

570
00:23:53,740 --> 00:23:56,640
todo eso hace cierto, es esta o esta

571
00:23:56,640 --> 00:23:58,720
las dos ciertas o solo una de las dos

572
00:23:58,720 --> 00:24:00,900
y luego ya sería falso si las dos son falsas

573
00:24:00,900 --> 00:24:01,779
pero el oro exclusivo

574
00:24:01,779 --> 00:24:04,980
es cierto solo si es cierta

575
00:24:04,980 --> 00:24:06,660
una de las dos solamente

576
00:24:06,660 --> 00:24:07,619
una de las dos

577
00:24:07,619 --> 00:24:09,900
si las dos son ciertas es falso

578
00:24:09,900 --> 00:24:11,980
entonces el oro exclusivo es

579
00:24:11,980 --> 00:24:15,099
¿verdad? si solo una de las dos

580
00:24:15,099 --> 00:24:16,359
y solo una es verdad

581
00:24:16,359 --> 00:24:18,640
entonces bueno, hay veces que podemos

582
00:24:18,640 --> 00:24:20,720
necesitar usarlo para expresar una condición

583
00:24:20,720 --> 00:24:22,859
pero bueno, es un caso más raro

584
00:24:22,859 --> 00:24:24,940
en la realidad es muy raro que tú quieras saber

585
00:24:24,940 --> 00:24:26,839
si ocurre esto o esto

586
00:24:26,839 --> 00:24:28,680
pero solo una de las dos

587
00:24:28,680 --> 00:24:31,079
no las dos, es una situación real

588
00:24:31,079 --> 00:24:33,000
rara, pero bueno aquí está y es este

589
00:24:33,000 --> 00:24:33,700
símbolo, vale

590
00:24:33,700 --> 00:24:36,740
vale, y luego aquí ya

591
00:24:36,740 --> 00:24:41,700
vendrán los operadores

592
00:24:41,700 --> 00:24:43,539
de bits, vale, esto pues

593
00:24:43,539 --> 00:24:45,599
otros años los contábamos

594
00:24:45,599 --> 00:24:47,500
pero es que esto no merece la pena porque

595
00:24:47,500 --> 00:24:48,740
prácticamente no se usan

596
00:24:48,740 --> 00:24:51,660
solamente que sepáis que hay

597
00:24:51,660 --> 00:24:53,799
operadores a nivel

598
00:24:53,799 --> 00:24:54,940
de bits que se llaman

599
00:24:54,940 --> 00:24:58,079
nosotros hasta ahora todos los operadores

600
00:24:58,079 --> 00:24:59,980
que estamos usando son como a nivel de variable

601
00:24:59,980 --> 00:25:02,339
en conjunto, sumo una variable

602
00:25:02,339 --> 00:25:03,900
a otra, las sumo enteritas

603
00:25:03,900 --> 00:25:05,779
o las resto, o concateno

604
00:25:05,779 --> 00:25:07,380
dos variables enteras

605
00:25:07,380 --> 00:25:09,900
o hago un and entre dos variables

606
00:25:09,900 --> 00:25:11,880
completas, hasta ahora todas las operaciones

607
00:25:11,880 --> 00:25:14,140
que hemos hecho es, involucran las variables

608
00:25:14,140 --> 00:25:16,220
enteras, sumarlas, restarlas

609
00:25:16,220 --> 00:25:17,680
lo que sea, vale

610
00:25:17,680 --> 00:25:19,700
las variables que son, ay esto de no tener

611
00:25:19,700 --> 00:25:21,180
rotulador, vale

612
00:25:21,180 --> 00:25:23,559
pues las variables que son

613
00:25:23,559 --> 00:25:25,880
La tableta gráfica

614
00:25:25,880 --> 00:25:27,920
Ya, lo que pasa es que

615
00:25:27,920 --> 00:25:29,559
Si tengo que traer la tableta a ordenador

616
00:25:29,559 --> 00:25:31,980
Me traigo un Serpa

617
00:25:31,980 --> 00:25:32,900
A ver

618
00:25:32,900 --> 00:25:36,200
Vamos a ver

619
00:25:36,200 --> 00:25:37,900
Ah, si ya tenía el Word

620
00:25:37,900 --> 00:25:39,619
Ese preparado, vale

621
00:25:39,619 --> 00:25:45,829
Vale, una variable en realidad

622
00:25:45,829 --> 00:25:47,589
¿Qué es? Ya sabemos lo que tiene dentro

623
00:25:47,589 --> 00:25:49,609
Es una cosa, son ceros y unos

624
00:25:49,609 --> 00:25:51,650
¿Vale? Es lo único que tiene una variable

625
00:25:51,650 --> 00:25:53,289
Lo distinto

626
00:25:53,289 --> 00:25:55,609
Lo que varía respecto a C-Synchor

627
00:25:55,609 --> 00:25:57,849
es cómo se interpretan esos ceros y unos

628
00:25:57,849 --> 00:25:59,289
si es un número entero

629
00:25:59,289 --> 00:26:01,809
sabemos que se interpreta como el número entero

630
00:26:01,809 --> 00:26:03,769
que en binario

631
00:26:03,769 --> 00:26:05,230
se correspondería con esto

632
00:26:05,230 --> 00:26:07,690
si es un float o un double

633
00:26:07,690 --> 00:26:09,789
pues esto representa la codificación

634
00:26:09,789 --> 00:26:11,329
double que no la conocemos

635
00:26:11,329 --> 00:26:13,529
pero tiene sus matices por la parte decimal, patatín

636
00:26:13,529 --> 00:26:15,390
la codificación double de ese número de double

637
00:26:15,390 --> 00:26:16,670
si es un char

638
00:26:16,670 --> 00:26:18,730
sabemos que es el boolean

639
00:26:18,730 --> 00:26:21,569
el número de la tabla asti

640
00:26:21,569 --> 00:26:23,890
y si es un boolean

641
00:26:23,890 --> 00:26:25,230
pues un boolean true y false

642
00:26:25,230 --> 00:26:28,369
Imagino que el false

643
00:26:28,369 --> 00:26:29,410
Será todo ceros

644
00:26:29,410 --> 00:26:30,789
Los 8 todo ceros

645
00:26:30,789 --> 00:26:33,150
Y el true será cualquier otra cosa

646
00:26:33,150 --> 00:26:35,410
Imagino, pero no sé exactamente cómo se codifica

647
00:26:35,410 --> 00:26:37,269
El true y el false internamente

648
00:26:37,269 --> 00:26:38,009
En los 8 bits

649
00:26:38,009 --> 00:26:39,990
Seguramente el 0, false

650
00:26:39,990 --> 00:26:42,750
Y cualquier otra combinación que no sea todo ceros

651
00:26:42,750 --> 00:26:43,369
True

652
00:26:43,369 --> 00:26:46,369
En definitiva, las variables

653
00:26:46,369 --> 00:26:48,009
Lo que tienen dentro son ceros y unos

654
00:26:48,009 --> 00:26:51,150
Pero nosotros trabajamos con su significado en conjunto

655
00:26:51,150 --> 00:26:53,710
El número, el char, lo que sea que represente

656
00:26:53,710 --> 00:26:56,309
Bueno, pues puede haber algunas aplicaciones

657
00:26:56,309 --> 00:26:59,069
Que necesiten bits sueltos

658
00:26:59,069 --> 00:27:00,789
Que necesiten bits sueltos

659
00:27:00,789 --> 00:27:02,230
Pues yo que sé

660
00:27:02,230 --> 00:27:03,809
Una operación de control

661
00:27:03,809 --> 00:27:06,569
Que cada bit se asocia a un sensor

662
00:27:06,569 --> 00:27:08,769
El sensor está activo

663
00:27:08,769 --> 00:27:10,450
No está activo según si hay 0.1

664
00:27:10,450 --> 00:27:11,490
Yo creo que el Boolean

665
00:27:11,490 --> 00:27:14,529
No, porque

666
00:27:14,529 --> 00:27:16,309
La capacidad, o sea

667
00:27:16,309 --> 00:27:18,910
El almacenamiento mínimo de una variable es en 8 bits

668
00:27:18,910 --> 00:27:22,549
No lo sé

669
00:27:22,549 --> 00:27:31,009
Claro, pero como hay 8 bits

670
00:27:31,009 --> 00:27:32,789
A ver, eso se podría comprobar fácilmente

671
00:27:32,789 --> 00:27:34,410
Haciendo un casting de un int a boolean

672
00:27:34,410 --> 00:27:35,970
Pero bueno, vamos a dejarlo

673
00:27:35,970 --> 00:27:37,650
Nos da igual

674
00:27:37,650 --> 00:27:41,089
Una variable boolean, le asignamos true o false

675
00:27:41,089 --> 00:27:42,549
Como lo codifique por dentro

676
00:27:42,549 --> 00:27:44,990
Nos da igual, usa 8 bits

677
00:27:44,990 --> 00:27:45,809
Como los usa

678
00:27:45,809 --> 00:27:47,990
No nos metemos en ello

679
00:27:47,990 --> 00:27:49,710
Vale

680
00:27:49,710 --> 00:27:52,329
Pero bueno, cuando uno tiene una variable

681
00:27:52,329 --> 00:27:53,890
del tipo que sea

682
00:27:53,890 --> 00:27:56,470
una variable del tipo que sea, sabe que lo que tiene son bits

683
00:27:56,470 --> 00:27:58,470
ceros y unos, en el caso más

684
00:27:58,470 --> 00:28:00,569
pequeño, en el caso de tener una variable

685
00:28:00,569 --> 00:28:02,190
byte, o tener una variable char

686
00:28:02,190 --> 00:28:03,390
o tener una variable, no char no

687
00:28:03,390 --> 00:28:06,130
tener una variable byte o boolean, pues son 8

688
00:28:06,130 --> 00:28:08,470
si tiene short, pues son 16

689
00:28:08,470 --> 00:28:10,309
si tiene, vale, pero en cualquier caso

690
00:28:10,309 --> 00:28:12,430
es un conjunto como mínimo

691
00:28:12,430 --> 00:28:14,250
de 8 bits, como mínimo

692
00:28:14,250 --> 00:28:16,650
vale, bueno, pues hay aplicaciones

693
00:28:16,650 --> 00:28:18,069
que a lo mejor les interesa

694
00:28:18,069 --> 00:28:20,089
trabajar con bits sueltos

695
00:28:20,089 --> 00:28:22,410
con bits sueltos, para eso no tenemos

696
00:28:22,410 --> 00:28:24,369
variables que nos permitan trabajar

697
00:28:24,369 --> 00:28:26,029
con bits sueltos, lo mínimo son 8 bits

698
00:28:26,029 --> 00:28:28,369
¿qué aplicaciones les puede

699
00:28:28,369 --> 00:28:30,430
interesar trabajar con bits sueltos? aplicaciones muy

700
00:28:30,430 --> 00:28:32,549
raras, aplicaciones pues eso

701
00:28:32,549 --> 00:28:34,250
que sean diferentes sensores, yo tengo

702
00:28:34,250 --> 00:28:36,470
8 sensores y tengo una única variable

703
00:28:36,470 --> 00:28:38,410
de 8, un byte, una variable

704
00:28:38,410 --> 00:28:40,410
byte y cada bit de la

705
00:28:40,410 --> 00:28:42,130
variable byte pues

706
00:28:42,130 --> 00:28:43,529
controla un sensor por ejemplo

707
00:28:43,529 --> 00:28:46,069
en ese caso yo necesito poder

708
00:28:46,069 --> 00:28:47,890
modificar los bits

709
00:28:47,890 --> 00:28:48,910
uno a uno

710
00:28:48,910 --> 00:28:52,170
necesitaría poderlos leer

711
00:28:52,170 --> 00:28:53,630
uno a uno, modificar uno a uno

712
00:28:53,630 --> 00:28:55,490
bueno, pues para eso

713
00:28:55,490 --> 00:28:58,390
hay operadores

714
00:28:58,390 --> 00:28:59,809
de estos de nivel de bits

715
00:28:59,809 --> 00:29:02,509
que te hacen estas cositas

716
00:29:02,509 --> 00:29:04,190
te permiten desplazar a la izquierda

717
00:29:04,190 --> 00:29:06,329
a la derecha, entonces tú coges el que te sale

718
00:29:06,329 --> 00:29:07,869
no sé qué, bueno, cosas

719
00:29:07,869 --> 00:29:09,809
muy específicas a nivel de bits

720
00:29:09,809 --> 00:29:11,950
no las vamos a contar

721
00:29:11,950 --> 00:29:14,210
ni vamos a examinar de ellas

722
00:29:14,210 --> 00:29:16,150
pero que sepáis que existen operadores

723
00:29:16,150 --> 00:29:18,750
Para trabajar a nivel de bit de uno en uno

724
00:29:18,750 --> 00:29:20,730
¿Vale? Por si una aplicación lo necesita

725
00:29:20,730 --> 00:29:22,289
¿Alguna vez lo vais a usar?

726
00:29:22,410 --> 00:29:23,609
Seguramente nunca jamás en la vida

727
00:29:23,609 --> 00:29:26,190
Pero que sepáis que está ahí

728
00:29:26,190 --> 00:29:27,990
Yo creo que no, pero bueno

729
00:29:27,990 --> 00:29:31,029
Vale, pues ahora ya sí que sí

730
00:29:31,029 --> 00:29:32,549
Hemos terminado este fichero

731
00:29:32,549 --> 00:29:33,730
A falta de

732
00:29:33,730 --> 00:29:35,750
Este

733
00:29:35,750 --> 00:29:40,059
Cuadrito final

734
00:29:40,059 --> 00:29:42,640
Que recoge la precedencia de los operadores en general

735
00:29:42,640 --> 00:29:44,519
¿Vale?

736
00:29:45,279 --> 00:29:46,599
Que recoge la preferencia

737
00:29:46,599 --> 00:29:49,259
Bueno, pues ya está

738
00:29:49,259 --> 00:29:50,880
Aquí está la precedencia de operadores

739
00:29:50,880 --> 00:29:51,940
Pero bueno, más o menos

740
00:29:51,940 --> 00:29:55,279
La regla general es multiplicaciones y divisiones

741
00:29:55,279 --> 00:29:56,720
Antes que sumas y restas

742
00:29:56,720 --> 00:30:01,140
Y los aritméticos

743
00:30:01,140 --> 00:30:03,240
Antes que los relacionales

744
00:30:03,240 --> 00:30:05,140
Cuando tenemos menor o igual

745
00:30:05,140 --> 00:30:06,859
O sea, a más b, menor o igual

746
00:30:06,859 --> 00:30:08,380
Pues primero hacemos el a más b

747
00:30:08,380 --> 00:30:09,740
Luego menor o igual, en general

748
00:30:09,740 --> 00:30:13,019
Y ya está, y luego todos esos

749
00:30:13,019 --> 00:30:14,099
Antes que los booleanos

750
00:30:14,099 --> 00:30:16,200
Y luego ya la asignación

751
00:30:16,200 --> 00:30:20,329
Vale, tampoco hay que liarse con esto

752
00:30:20,329 --> 00:30:21,630
Porque es lo que estamos haciendo

753
00:30:21,630 --> 00:30:23,109
Y es lo intuitivo

754
00:30:23,109 --> 00:30:26,109
Bueno, pues nada, damos ya ese fichero

755
00:30:26,109 --> 00:30:27,910
De operadores, los operadores por cerrado

756
00:30:27,910 --> 00:30:30,210
A falta de seguirlos practicando con el uso

757
00:30:30,210 --> 00:30:32,410
Y ahora ya

758
00:30:32,410 --> 00:30:33,490
Sí que sí

759
00:30:33,490 --> 00:30:38,000
Vale, nos vamos a esto

760
00:30:38,000 --> 00:30:40,440
Vale, incorporar otra sentencia más

761
00:30:40,440 --> 00:30:42,539
Bueno

762
00:30:42,539 --> 00:30:46,180
Pues entonces, hasta ahora hemos hecho

763
00:30:46,180 --> 00:30:47,539
Simplemente programas

764
00:30:47,539 --> 00:30:48,779
Que leen valores

765
00:30:48,779 --> 00:30:51,140
operan

766
00:30:51,140 --> 00:30:53,160
con los operadores que conocemos

767
00:30:53,160 --> 00:30:55,259
operan, esos resultados van

768
00:30:55,259 --> 00:30:55,759
a variables

769
00:30:55,759 --> 00:30:59,019
y luego ya con esas variables los mostramos

770
00:30:59,019 --> 00:31:01,299
o sea hemos hecho, hemos formado

771
00:31:01,299 --> 00:31:03,279
expresiones para conseguir valores

772
00:31:03,279 --> 00:31:05,220
y asignar esos valores a las variables

773
00:31:05,220 --> 00:31:07,200
y la única

774
00:31:07,200 --> 00:31:09,119
cosa que ha complicado

775
00:31:09,119 --> 00:31:10,420
es un pelín

776
00:31:10,420 --> 00:31:13,000
es que el valor que yo asigno

777
00:31:13,000 --> 00:31:14,099
a una variable

778
00:31:14,099 --> 00:31:16,619
pues lo puedo hacer depender de una condición

779
00:31:16,619 --> 00:31:18,599
Lo puedo hacer dependiendo de las condiciones

780
00:31:18,599 --> 00:31:21,079
Es la única modificación a eso que hemos visto

781
00:31:21,079 --> 00:31:21,680
¿Vale?

782
00:31:22,279 --> 00:31:24,920
Bueno, pues si solo pudiéramos hacer ese tipo de sentencias

783
00:31:24,920 --> 00:31:26,240
No podríamos hacer

784
00:31:26,240 --> 00:31:27,839
Ningún programa

785
00:31:27,839 --> 00:31:30,900
Que haga algo mínimamente más complicado

786
00:31:30,900 --> 00:31:32,299
Y sofisticado

787
00:31:32,299 --> 00:31:33,339
¿Vale?

788
00:31:33,859 --> 00:31:36,819
¿Entonces significa eso que hay que introducir tropecientas mil

789
00:31:36,819 --> 00:31:37,700
Sentencias más?

790
00:31:37,920 --> 00:31:40,259
No, hay que introducir dos más y se acabó

791
00:31:40,259 --> 00:31:41,420
¿Vale?

792
00:31:41,420 --> 00:31:43,279
Y para esas dos más solamente necesitáis

793
00:31:43,279 --> 00:31:44,839
Pues tres o cuatro años más de estudio

794
00:31:44,839 --> 00:31:46,240
Claro

795
00:31:46,240 --> 00:31:49,619
Vale, entonces

796
00:31:49,619 --> 00:31:52,779
Que solo hace falta introducir dos más

797
00:31:52,779 --> 00:31:53,799
¿Quién lo dice?

798
00:31:54,160 --> 00:31:55,480
¿Lo digo yo? Pues no

799
00:31:55,480 --> 00:31:58,819
Yo lo digo ahora

800
00:31:58,819 --> 00:32:00,539
Pero yo emulo a mis mayores

801
00:32:00,539 --> 00:32:01,960
Y

802
00:32:01,960 --> 00:32:06,339
Vale, bueno

803
00:32:06,339 --> 00:32:07,920
Esto es un resumencillo que repito

804
00:32:07,920 --> 00:32:09,259
Esto no son apuntes de estudiar

805
00:32:09,259 --> 00:32:12,339
Es un resumen para situaros

806
00:32:12,339 --> 00:32:14,859
Sobre que estamos viendo en cada momento

807
00:32:14,859 --> 00:32:18,789
Vale, pues esto de que

808
00:32:18,789 --> 00:32:20,009
Hacen falta solo dos más

809
00:32:20,009 --> 00:32:22,089
No lo, ábrete, o ya se ha abierto

810
00:32:22,089 --> 00:32:22,930
Así

811
00:32:22,930 --> 00:32:24,789
No lo digo yo

812
00:32:24,789 --> 00:32:26,630
¿Vale?

813
00:32:27,509 --> 00:32:28,390
Lo dice quién

814
00:32:28,390 --> 00:32:30,329
Este

815
00:32:30,329 --> 00:32:34,960
¿Vale?

816
00:32:36,259 --> 00:32:38,259
Vamos a verlo en Wikipedia

817
00:32:38,259 --> 00:32:39,319
Que es muy lista

818
00:32:39,319 --> 00:33:07,549
Ah, teorema del programa

819
00:33:07,549 --> 00:33:08,109
Claro

820
00:33:08,109 --> 00:33:10,490
no, no es lo mismo

821
00:33:10,490 --> 00:33:12,009
lo que pasa es que yo en los apuntes

822
00:33:12,009 --> 00:33:12,670
lo he reducido

823
00:33:12,670 --> 00:33:14,369
ah, que era otro

824
00:33:14,369 --> 00:33:17,529
bueno, pues el teorema ese

825
00:33:17,529 --> 00:33:19,609
como vosotros sois aficionados a las matemáticas

826
00:33:19,609 --> 00:33:20,309
pues por eso

827
00:33:20,309 --> 00:33:24,369
pues lo que yo he llamado

828
00:33:24,369 --> 00:33:26,049
el teorema de la estructura

829
00:33:26,049 --> 00:33:27,690
pues bueno, Wikipedia lo llama

830
00:33:27,690 --> 00:33:29,349
el teorema del programa estructural

831
00:33:29,349 --> 00:33:31,529
¿de cuándo es este teorema?

832
00:33:31,809 --> 00:33:32,890
que es el cual

833
00:33:32,890 --> 00:33:35,230
nace todo

834
00:33:35,230 --> 00:33:37,509
la programación tal y como la conocemos ahora

835
00:33:37,509 --> 00:33:40,190
Pues de hace un huevo de tiempo

836
00:33:40,190 --> 00:33:43,250
¿Vale?

837
00:33:43,609 --> 00:33:46,069
Dice, lo acreditan a un artículo

838
00:33:46,069 --> 00:33:47,309
Del 66

839
00:33:47,309 --> 00:33:50,069
Fijaos, no había nacido ni yo

840
00:33:50,069 --> 00:33:54,309
¿Y quién es estos tíos que no los conoce nadie?

841
00:33:55,930 --> 00:33:56,450
¿Vale?

842
00:33:57,009 --> 00:33:58,470
Pero bueno, no está muy claro

843
00:33:58,470 --> 00:34:00,410
Porque desde la arquitectura de Von Neumann

844
00:34:00,410 --> 00:34:01,950
Que es así que la contamos

845
00:34:01,950 --> 00:34:04,170
Pues más o menos se ha venido a

846
00:34:04,170 --> 00:34:06,210
Concluir este teorema

847
00:34:06,210 --> 00:34:27,730
¿Y qué dice este teorema? Dice que cualquier algoritmo, cualquier acción, cualquier problema que uno necesite resolver mediante un ordenador como lo conocemos con la arquitectura de Von Neumann, un procesador, le pasas operaciones, le haces sumas y restas y te lo devuelve.

848
00:34:27,730 --> 00:34:30,409
vale, pues cualquier algoritmo que queramos programar

849
00:34:30,409 --> 00:34:32,489
cualquiera, solo necesita

850
00:34:32,489 --> 00:34:33,730
tres tipos de instrucciones

851
00:34:33,730 --> 00:34:36,690
las asignaciones, que ya las hemos visto

852
00:34:36,690 --> 00:34:38,409
bueno, el tema de la estructura dice dos

853
00:34:38,409 --> 00:34:40,289
porque las asignaciones las da por sentado

854
00:34:40,289 --> 00:34:42,409
yo lo incorporo para que nos situemos mejor

855
00:34:42,409 --> 00:34:43,889
¿qué tendremos?

856
00:34:44,449 --> 00:34:46,090
que dar valores a variables, está claro

857
00:34:46,090 --> 00:34:47,630
dar valores a variables, si no, no tenemos datos

858
00:34:47,630 --> 00:34:50,369
y luego, a partir de ahí, una vez que ya tenemos valores

859
00:34:50,369 --> 00:34:51,690
en los variables, contener

860
00:34:51,690 --> 00:34:54,170
decisiones y bucles

861
00:34:54,170 --> 00:34:56,449
todo eso tantas veces

862
00:34:56,449 --> 00:34:58,449
es como haga falta. Cuatro decisiones, tres

863
00:34:58,449 --> 00:35:00,389
bucles. Pues con tener decisiones

864
00:35:00,389 --> 00:35:02,130
y bucles se puede construir

865
00:35:02,130 --> 00:35:04,389
cualquier algoritmo. Se puede

866
00:35:04,389 --> 00:35:06,469
programar cualquiera. No hace falta

867
00:35:06,469 --> 00:35:07,690
absolutamente ninguna sentencia más.

868
00:35:08,469 --> 00:35:10,250
Por eso la programación estructurada tiene

869
00:35:10,250 --> 00:35:12,469
exclusivamente, aparte de asignaciones

870
00:35:12,469 --> 00:35:14,110
de datos a variables,

871
00:35:14,469 --> 00:35:16,210
porque eso es inevitable, aparte de eso

872
00:35:16,210 --> 00:35:18,349
tiene decisiones y bucles. Y no tiene absolutamente

873
00:35:18,349 --> 00:35:20,349
nada más. Nada más.

874
00:35:20,469 --> 00:35:21,570
A partir de ahí, ¿qué es lo que tiene?

875
00:35:22,230 --> 00:35:24,469
¿Cómo coloco el código? Punto pelota.

876
00:35:24,469 --> 00:35:26,590
no tiene nada más que eso, cualquier

877
00:35:26,590 --> 00:35:28,590
lenguaje de programación al que podáis

878
00:35:28,590 --> 00:35:30,750
acudir, siempre y cuando

879
00:35:30,750 --> 00:35:32,670
nos vayáis a redes neuronales, a sistemas

880
00:35:32,670 --> 00:35:34,449
de computación de inteligencia artificial, pero es que estos

881
00:35:34,449 --> 00:35:36,750
son todos modelos, no tienen nada que ver con un ordenador

882
00:35:36,750 --> 00:35:37,829
de esos, vale

883
00:35:37,829 --> 00:35:40,289
estamos hablando de cualquier

884
00:35:40,289 --> 00:35:42,869
programa de ordenadores

885
00:35:42,869 --> 00:35:45,090
de tablets, de móviles, de dispositivos

886
00:35:45,090 --> 00:35:46,190
normales y corrientes

887
00:35:46,190 --> 00:35:48,269
pues cualquiera de esos

888
00:35:48,269 --> 00:35:50,510
solamente tiene

889
00:35:50,510 --> 00:35:52,789
leo datos y van a variables

890
00:35:52,789 --> 00:35:54,849
Decisiones y bucles y ya está, no tiene nada más

891
00:35:54,849 --> 00:35:56,690
Que lo tengamos colocado de una manera o de otra

892
00:35:56,690 --> 00:35:58,610
Lo tenemos colocado de una manera u otra, pero no tiene nada más

893
00:35:58,610 --> 00:36:01,070
¿Vale? Entonces menos mal

894
00:36:01,070 --> 00:36:03,090
Porque así no tenemos que hacer programas muy raros

895
00:36:03,090 --> 00:36:04,409
Porque antiguamente

896
00:36:04,409 --> 00:36:07,030
Se usaba mucho el famoso

897
00:36:07,030 --> 00:36:07,530
Go to

898
00:36:07,530 --> 00:36:11,110
Que bueno, los programas de muchos lenguajes

899
00:36:11,110 --> 00:36:12,130
Los siguen incorporando

900
00:36:12,130 --> 00:36:13,349
Para

901
00:36:13,349 --> 00:36:15,389
Por comodidad

902
00:36:15,389 --> 00:36:18,690
Que es, vete a esta línea, punto y pelota

903
00:36:18,690 --> 00:36:19,929
Y te mandaba esa línea

904
00:36:19,929 --> 00:36:21,210
y lo que había antes, ¿qué?

905
00:36:21,730 --> 00:36:23,630
O sea, eso hacía programas que se llamaban

906
00:36:23,630 --> 00:36:25,329
desestructurados completamente

907
00:36:25,329 --> 00:36:27,789
porque se perdía el flujo

908
00:36:27,789 --> 00:36:29,289
del hilo. Me voy aquí

909
00:36:29,289 --> 00:36:31,789
en virtud de que me voy aquí por una condición

910
00:36:31,789 --> 00:36:33,429
o porque te da la gana, entonces

911
00:36:33,429 --> 00:36:35,210
es una forma de programar cómoda

912
00:36:35,210 --> 00:36:37,210
porque yo hacía un chorizo, luego cambiaba de idea

913
00:36:37,210 --> 00:36:39,250
Ah, no, quiero seguir por aquí, pues go to potatín

914
00:36:39,250 --> 00:36:41,250
Programas desestructurados completamente

915
00:36:41,250 --> 00:36:43,929
Entonces se dijo, vamos a quitar todo lo que no haga falta

916
00:36:43,929 --> 00:36:46,230
Y quitando todo lo que no haga falta

917
00:36:46,230 --> 00:36:47,469
se quitó todo

918
00:36:47,469 --> 00:36:49,230
salvo las decisiones y los bucles

919
00:36:49,230 --> 00:36:52,150
Y ya está, y a partir de ahí vamos a hacer lenguajes de programación

920
00:36:52,150 --> 00:36:54,929
Que solamente usen de sesiones y bucles

921
00:36:54,929 --> 00:36:58,789
Aunque incorporen el GoTo o algo parecido

922
00:36:58,789 --> 00:37:01,030
Que Java también lo incorpora por comodidad

923
00:37:01,030 --> 00:37:03,949
Pero si no lo usamos, mejor, porque no es necesario

924
00:37:03,949 --> 00:37:09,550
Bueno, pues entonces nosotros vamos a empezar ahora con esto

925
00:37:09,550 --> 00:37:11,530
¿Vale? Venga, paramos

926
00:37:11,530 --> 00:37:14,829
Qué pena, ¿verdad?

927
00:37:14,829 --> 00:37:15,010
¿Verdad?