1
00:00:00,000 --> 00:00:05,639
voy a grabar esta clase por lo tanto si habláis y hacéis preguntas me autoriza jce a que vuestra

2
00:00:05,639 --> 00:00:16,600
voz sea grabada vale lo que vamos a ver hoy son algunas pinceladas sobre dos tipos que hemos visto

3
00:00:16,600 --> 00:00:22,239
pero que hemos dejado un poquito así en la niebla que son por un lado string y por otro lado char

4
00:00:22,239 --> 00:00:25,640
Entonces, empezamos por string

5
00:00:25,640 --> 00:00:33,320
Nosotros hemos visto que Java tiene varios tipos primitivos

6
00:00:33,320 --> 00:00:37,659
Que son todos los que cuando se escriben aquí salen en azul

7
00:00:37,659 --> 00:00:46,920
Tipo int, char, float, doble, etc

8
00:00:46,920 --> 00:00:49,299
Todo esto se llaman tipos primitivos

9
00:00:49,299 --> 00:00:52,740
Son tipos que Java define

10
00:00:52,740 --> 00:00:57,140
Hay tipos numéricos, hay tipos de letras, hay tipos booleanos

11
00:00:57,140 --> 00:00:59,020
Hay varios tipos que tenemos

12
00:00:59,020 --> 00:01:03,539
De los tipos que hemos utilizado nosotros y que utilizamos normalmente

13
00:01:03,539 --> 00:01:06,540
Y que hacemos variables, que por ahora son estos

14
00:01:06,540 --> 00:01:09,719
Más uno, que es una pizca distinto

15
00:01:09,719 --> 00:01:11,500
Porque cuando yo pongo string

16
00:01:11,500 --> 00:01:14,879
No sale como palabra reservada

17
00:01:14,879 --> 00:01:17,560
String no es un tipo primitivo

18
00:01:17,560 --> 00:01:20,319
String es algo distinto

19
00:01:20,319 --> 00:01:23,579
Si os fijáis, funciona

20
00:01:23,579 --> 00:01:25,859
Funciona como una variable, puedo crearla así

21
00:01:25,859 --> 00:01:27,640
Pero esta cosa de aquí

22
00:01:27,640 --> 00:01:29,739
No es un tipo primitivo, es una cosa distinta

23
00:01:29,739 --> 00:01:32,060
Algo parecido

24
00:01:32,060 --> 00:01:35,180
Lo hemos visto con Scanner

25
00:01:35,180 --> 00:01:44,959
Hemos visto que

26
00:01:44,959 --> 00:01:47,719
Aquí también estamos creando una cosa

27
00:01:47,719 --> 00:01:49,500
Que desde una perspectiva

28
00:01:49,500 --> 00:01:51,480
Sintáctica

29
00:01:51,480 --> 00:01:55,620
es una variable, porque hay un algo

30
00:01:55,620 --> 00:01:58,939
un nombre igual y un valor

31
00:01:58,939 --> 00:02:03,599
punto y coma, es la misma sintaxis de las variables

32
00:02:03,599 --> 00:02:07,519
entonces podemos asumir que esta es una variable

33
00:02:07,519 --> 00:02:11,500
pero no tiene, esto es un pogonar

34
00:02:11,500 --> 00:02:12,259
duda

35
00:02:12,259 --> 00:02:21,599
d

36
00:02:21,599 --> 00:02:24,400
d

37
00:02:24,400 --> 00:02:26,639
d

38
00:02:26,639 --> 00:02:45,460
Entonces, la razón es que estos señores de aquí no son tipos primitivos, son objetos.

39
00:02:45,460 --> 00:02:50,060
Estos señores de aquí son clases

40
00:02:50,060 --> 00:02:55,539
Y de estas clases yo creo un objeto

41
00:02:55,539 --> 00:03:00,460
Cosa que nosotros no sabemos porque todavía no hemos visto programación de objetos y cosas por el estilo

42
00:03:00,460 --> 00:03:11,159
Pero string, por ejemplo, es un objeto tan cómodo, tan útil, tan normalmente utilizado

43
00:03:11,159 --> 00:03:17,780
que hasta el mismo Java lo usa en una forma un poquito distinta

44
00:03:17,780 --> 00:03:20,740
con respecto a como se usan normalmente los objetos

45
00:03:20,740 --> 00:03:23,500
los objetos se usan así normalmente

46
00:03:23,500 --> 00:03:27,800
declaro una variable que se llama scan

47
00:03:27,800 --> 00:03:34,039
un lugar de memoria donde dentro creo algo que es un objeto de tipo scanner

48
00:03:34,039 --> 00:03:39,460
y para crear este objeto tengo que utilizar el new

49
00:03:39,460 --> 00:03:42,240
El new es una operación que me dice

50
00:03:42,240 --> 00:03:43,719
Crear un nuevo objeto

51
00:03:43,719 --> 00:03:45,080
De este tipo

52
00:03:45,080 --> 00:03:47,460
Si os fijáis aquí no lo estoy haciendo

53
00:03:47,460 --> 00:03:48,960
¿Vale?

54
00:03:49,639 --> 00:03:51,639
String es talmente tan utilizada

55
00:03:51,639 --> 00:03:53,560
Se puede hacer, si se puede hacer

56
00:03:53,560 --> 00:03:56,180
Yo puedo hacer new string

57
00:03:56,180 --> 00:03:57,180
De hola

58
00:03:57,180 --> 00:03:58,919
Esto funciona

59
00:03:58,919 --> 00:04:01,599
Esto se parece mucho más a este de aquí

60
00:04:01,599 --> 00:04:04,020
¿Si? Pero como string es tan

61
00:04:04,020 --> 00:04:05,979
Utilizado, estamos constantemente haciendo

62
00:04:05,979 --> 00:04:07,740
Palabras para escribirla por pantalla

63
00:04:07,740 --> 00:04:10,020
para guardarla, para meter un fichero, cosas por el estilo

64
00:04:10,020 --> 00:04:13,800
las tiras de caracteres, las secuencias de caracteres

65
00:04:13,800 --> 00:04:15,819
son algo que se utiliza muchísimo en Java

66
00:04:15,819 --> 00:04:19,079
pues entonces Java ha evolucionado hasta un cierto momento

67
00:04:19,079 --> 00:04:21,339
diciendo, vale, sí, es verdad, esto es un tipo

68
00:04:21,339 --> 00:04:26,459
pero lo voy a hacer un poquito más fácil de utilizar

69
00:04:26,459 --> 00:04:29,259
para que como lo tienes que utilizar muchas veces

70
00:04:29,259 --> 00:04:32,459
pues te doy una sintaxis alternativa

71
00:04:32,459 --> 00:04:34,540
que igualmente yo voy a entender

72
00:04:34,540 --> 00:04:36,819
y cuando me encuentro esta cosa de aquí

73
00:04:36,819 --> 00:04:40,040
en automático por debajo, estaré haciendo esto

74
00:04:40,040 --> 00:04:46,660
esto hace que string sea un poco distinto

75
00:04:46,660 --> 00:04:50,139
de los otros objetos y de cómo se utiliza string

76
00:04:50,139 --> 00:04:53,579
es más, string se utiliza talmente tanto

77
00:04:53,579 --> 00:04:56,779
así de mucho

78
00:04:56,779 --> 00:05:02,300
que además tiene sus propias particularidades de cómo funciona

79
00:05:02,300 --> 00:05:06,500
en memoria, o sea, todo lo que veremos de los objetos

80
00:05:06,500 --> 00:05:10,040
y de cómo se guardan los objetos y de cómo se crean los objetos

81
00:05:10,040 --> 00:05:14,060
para string no vale exactamente

82
00:05:14,060 --> 00:05:16,220
string es un objeto especial

83
00:05:16,220 --> 00:05:20,259
veremos cuando veremos los objetos y los utilizaremos

84
00:05:20,259 --> 00:05:23,980
que de hecho cuando quiero probar algo que funciona con objetos

85
00:05:23,980 --> 00:05:27,540
probarlo con string siempre es peligroso

86
00:05:27,540 --> 00:05:30,680
porque a veces string funciona de una forma distinta

87
00:05:30,680 --> 00:05:34,079
con respecto a otros objetos para optimizar

88
00:05:34,079 --> 00:05:39,339
Para que sea más rápido y más fácil de utilizar

89
00:05:39,339 --> 00:05:45,100
Pero esta cosa aquí a veces comporta características y comportamientos de string

90
00:05:45,100 --> 00:05:51,759
Que no son muy, muy, muy, muy, muy algo

91
00:05:51,759 --> 00:05:54,470
¿Vale?

92
00:05:54,470 --> 00:06:01,170
Entonces, lo que vamos a hacer es ahora olvidarnos que es un objeto

93
00:06:01,170 --> 00:06:04,129
Olvidarnos que es más o menos

94
00:06:04,129 --> 00:06:06,490
Esta parte no nos interesa

95
00:06:06,490 --> 00:06:07,529
Endagar sobre eso

96
00:06:07,529 --> 00:06:10,050
Pero ya que nos proporciona

97
00:06:10,050 --> 00:06:11,550
Algunas cosas interesantes

98
00:06:11,550 --> 00:06:13,350
Pues vamos a decirla o vamos a utilizar

99
00:06:13,350 --> 00:06:15,870
Y vamos a ver que pasa

100
00:06:15,870 --> 00:06:18,170
Entonces esto nos lo olvidamos

101
00:06:18,170 --> 00:06:19,610
Estamos utilizando objetos

102
00:06:19,610 --> 00:06:21,769
Estamos haciendo todo orientado a objetos

103
00:06:21,769 --> 00:06:24,069
Ejemplos

104
00:06:24,069 --> 00:06:25,149
String

105
00:06:25,149 --> 00:06:25,850
X

106
00:06:25,850 --> 00:06:29,389
Es igual

107
00:06:29,389 --> 00:06:30,629
A new

108
00:06:30,629 --> 00:06:38,300
Estoy haciendo un objeto

109
00:06:38,300 --> 00:06:40,180
De esta clase

110
00:06:40,180 --> 00:06:42,740
Pero vosotros no lo sabéis hacer

111
00:06:42,740 --> 00:06:44,560
Lo veremos en un futuro

112
00:06:44,560 --> 00:06:49,189
Vamos a hacer pruebas

113
00:06:49,189 --> 00:06:51,629
Con string a ver que pasa

114
00:06:51,629 --> 00:06:52,269
¿Vale?

115
00:06:53,310 --> 00:06:54,970
Ok, empezamos

116
00:06:54,970 --> 00:06:57,649
Tengo un string que se llama hola

117
00:06:57,649 --> 00:06:59,709
¿Si? Fenomenal

118
00:06:59,709 --> 00:07:00,970
Pregunta

119
00:07:00,970 --> 00:07:03,269
Si yo digo escribe

120
00:07:03,269 --> 00:07:07,189
X es igual a ola

121
00:07:07,189 --> 00:07:11,180
¿Qué me escribe?

122
00:07:15,550 --> 00:07:17,350
¿Qué es este operador de aquí?

123
00:07:20,180 --> 00:07:21,540
¿Y qué tipo de operador es?

124
00:07:22,399 --> 00:07:25,000
Entonces el resultado de esta expresión será un

125
00:07:25,000 --> 00:07:27,000
True o False

126
00:07:27,000 --> 00:07:28,879
¿Estamos de acuerdo con esto?

127
00:07:28,879 --> 00:07:31,139
50% de probabilidad

128
00:07:31,139 --> 00:07:33,040
¿Esto me da True o False?

129
00:07:33,500 --> 00:07:38,310
True

130
00:07:38,310 --> 00:07:40,509
Fenomenal

131
00:07:40,509 --> 00:07:42,670
String

132
00:07:42,670 --> 00:07:43,670
Y

133
00:07:43,670 --> 00:07:49,120
es igual a hola

134
00:07:49,120 --> 00:07:52,379
x igual a igual a y

135
00:07:52,379 --> 00:07:55,120
true o false

136
00:07:55,120 --> 00:08:03,759
string k

137
00:08:03,759 --> 00:08:05,060
es igual a

138
00:08:05,060 --> 00:08:09,660
k es igual

139
00:08:09,660 --> 00:08:11,120
a lo que hay en k

140
00:08:11,120 --> 00:08:12,240
más la

141
00:08:12,240 --> 00:08:15,879
que hay ahora mismo

142
00:08:15,879 --> 00:08:16,519
dentro k

143
00:08:16,519 --> 00:08:21,660
hola

144
00:08:21,660 --> 00:08:29,769
x igual a igual a k

145
00:08:29,769 --> 00:08:39,620
ah claro

146
00:08:39,620 --> 00:08:42,100
No, claro no, claro nada

147
00:08:42,100 --> 00:08:45,299
Porque me esperaría que fuera true

148
00:08:45,299 --> 00:08:47,000
Tiene dentro lo mismo

149
00:08:47,000 --> 00:08:48,899
¿No estáis convencidos que dentro tiene lo mismo?

150
00:08:49,600 --> 00:08:57,059
Si, so, x, si, so, k

151
00:08:57,059 --> 00:09:03,450
¿Veis que es lo mismo?

152
00:09:07,330 --> 00:09:08,889
¿Por qué pasa esto?

153
00:09:09,490 --> 00:09:09,690
¿Vale?

154
00:09:10,070 --> 00:09:11,669
Y esto es relativamente complejo

155
00:09:11,669 --> 00:09:14,409
Vamos a pintar

156
00:09:14,409 --> 00:09:53,759
Ahora, cuando tú creas un tipo primitivo, una variable de tipo primitivo, un int, lo que pasa en la memoria, esta es la memoria, es que por ejemplo int x es igual a 3 o int a es igual a 3, me crea un trocito de memoria referenciado con el nombre a que tiene dentro enteros y como valor dentro.

157
00:09:53,759 --> 00:09:54,940
Tiene un 3

158
00:09:54,940 --> 00:09:57,679
¿Estamos de acuerdo?

159
00:09:58,759 --> 00:09:59,000
Vale

160
00:09:59,000 --> 00:10:01,559
¿Cuándo creo un objeto?

161
00:10:01,820 --> 00:10:04,940
Esto vale para todos los tipos primitivos

162
00:10:04,940 --> 00:10:06,320
¿Sí?

163
00:10:06,779 --> 00:10:08,519
¿Cuándo creo un objeto?

164
00:10:09,100 --> 00:10:11,440
Como scanner, como cosa por estilo

165
00:10:11,440 --> 00:10:13,360
La cosa es un poquito distinta

166
00:10:13,360 --> 00:10:14,899
Pensamos en un scanner, por ejemplo

167
00:10:14,899 --> 00:10:18,539
Cuando yo hago scanner, scan es igual a new scanner, bla bla bla

168
00:10:18,539 --> 00:10:21,820
Lo que se está haciendo es creando un trocito de memoria

169
00:10:21,820 --> 00:10:25,480
referenciado con el nombre scan

170
00:10:25,480 --> 00:10:30,259
que tiene dentro un objeto scanner

171
00:10:30,259 --> 00:10:34,179
y hasta aquí es igual

172
00:10:34,179 --> 00:10:37,720
pero la operación new no sé qué

173
00:10:37,720 --> 00:10:40,539
lo que está haciendo es crearme el objeto

174
00:10:40,539 --> 00:10:42,600
en otro lado del mundo

175
00:10:42,600 --> 00:10:45,059
en una zona que se llama el heap

176
00:10:45,059 --> 00:10:51,980
montón en español

177
00:10:51,980 --> 00:10:55,720
un montón de cosas que están allí

178
00:10:55,720 --> 00:10:58,200
y luego aquí dentro

179
00:10:58,200 --> 00:11:00,039
no se pone el objeto

180
00:11:00,039 --> 00:11:03,399
aquí dentro se pone una referencia

181
00:11:03,399 --> 00:11:06,519
a donde se coloca el objeto

182
00:11:06,519 --> 00:11:17,370
ahora, si yo creo otro objeto scanner

183
00:11:17,370 --> 00:11:23,620
que se llama S2

184
00:11:23,620 --> 00:11:25,759
siempre tipo scanner

185
00:11:25,759 --> 00:11:29,259
lo que se hará es crear otro objeto por aquí

186
00:11:29,259 --> 00:11:33,179
y que esto referencia a esto

187
00:11:33,179 --> 00:11:38,200
Cuando hago scan es igual igual a S2

188
00:11:38,200 --> 00:11:43,299
No estoy comparando si estos dos objetos son iguales

189
00:11:43,299 --> 00:11:47,659
Mas estoy comparando si esta referencia es igual

190
00:11:47,659 --> 00:11:54,759
Entonces en este caso daría false

191
00:11:54,759 --> 00:11:59,000
Si yo esto hago que apunte aquí

192
00:11:59,000 --> 00:12:01,120
Sería true

193
00:12:01,120 --> 00:12:05,500
Es decir que el igual igual entre objetos

194
00:12:05,500 --> 00:12:08,139
solo es true

195
00:12:08,139 --> 00:12:12,519
si los dos objetos son el mismo objeto

196
00:12:12,519 --> 00:12:16,190
no que sean parecidos

197
00:12:16,190 --> 00:12:19,409
mas sean el mismo objeto en memoria

198
00:12:19,409 --> 00:12:24,200
vamos a hablar de esto en términos de string

199
00:12:24,200 --> 00:12:34,820
pensamos esto en string

200
00:12:34,820 --> 00:12:36,779
y hemos dicho que string es un objeto

201
00:12:36,779 --> 00:12:39,639
por lo tanto como debería funcionar string

202
00:12:39,639 --> 00:12:43,379
debería funcionar que si yo pongo aquí un objeto que es string

203
00:12:43,379 --> 00:12:45,100
que se llama x

204
00:12:45,100 --> 00:12:47,899
Y creo un objeto hola

205
00:12:47,899 --> 00:12:50,840
Por algún lado se creará el objeto hola

206
00:12:50,840 --> 00:13:00,299
Y aquí hay un puntero a este objeto hola

207
00:13:00,299 --> 00:13:04,100
Y que cuando me creo un objeto K

208
00:13:04,100 --> 00:13:07,600
Que es un objeto

209
00:13:07,600 --> 00:13:10,159
Que apunta a un objeto O

210
00:13:10,159 --> 00:13:18,000
Y luego lo modifico

211
00:13:18,000 --> 00:13:19,879
Añadiendo la aquí

212
00:13:19,879 --> 00:13:24,179
Que es lo que he hecho

213
00:13:24,179 --> 00:13:28,740
Ignorad por ahora esta parte de aquí

214
00:13:28,740 --> 00:13:42,799
¿Vale? He creado un objeto hola, este aquí, y luego he dicho, crea un objeto K con dentro solo HO, y luego después le pegas detrás la.

215
00:13:43,200 --> 00:13:51,179
¿Vale? Entonces lo que he hecho es crear este objeto K con solo dentro HO, y luego le he pegado el HO aquí.

216
00:13:51,179 --> 00:14:03,500
Estos son dos objetos distintos. Entonces, si yo hago x es igual a y, el resultado es falso.

217
00:14:04,980 --> 00:14:08,840
Acá. Está escrito acá, ¿no lo veis? Ahí, acá.

218
00:14:11,330 --> 00:14:22,230
El resultado será falso porque lo que está escrito aquí, que es como una dirección de memoria, imaginámonos así, es distinto de lo que está escrito aquí.

219
00:14:22,230 --> 00:14:24,210
Pero dentro tiene la misma cosa

220
00:14:24,210 --> 00:14:25,330
Tiene hola a los dos, sí

221
00:14:25,330 --> 00:14:28,669
Pero cuando lo hago con igual

222
00:14:28,669 --> 00:14:29,230
Igual

223
00:14:29,230 --> 00:14:32,629
No estoy comparando lo que contiene

224
00:14:32,629 --> 00:14:34,710
Estoy comparando

225
00:14:34,710 --> 00:14:36,210
Este dato de aquí

226
00:14:36,210 --> 00:14:39,009
Y como apunta a dos objetos distintos

227
00:14:39,009 --> 00:14:41,470
Es distinto

228
00:14:41,470 --> 00:14:45,250
Y esta es la razón de por qué aparece

229
00:14:45,250 --> 00:14:46,809
Este falso

230
00:14:46,809 --> 00:15:00,340
Y dice, ignorad esta parte

231
00:15:00,340 --> 00:15:01,820
¿La has ignorado?

232
00:15:02,580 --> 00:15:04,519
No, me has dicho una pregunta sobre esta parte

233
00:15:04,519 --> 00:15:06,879
No lo estás ignorando suficientemente

234
00:15:06,879 --> 00:15:07,919
Ignóralo más

235
00:15:07,919 --> 00:15:09,559
¿Vale?

236
00:15:09,759 --> 00:15:12,480
Cuando hemos entendido cómo debería funcionar

237
00:15:12,480 --> 00:15:14,080
Explicamos por qué no funciona aquí

238
00:15:14,080 --> 00:15:15,220
¿Sí?

239
00:15:16,279 --> 00:15:17,480
Que aclaro esto

240
00:15:17,480 --> 00:15:18,899
¿Sí?

241
00:15:28,139 --> 00:15:30,600
Si yo hago B siempre entero

242
00:15:30,600 --> 00:15:32,120
Con 3

243
00:15:32,120 --> 00:15:34,299
Cuando luego hago el igual igual

244
00:15:34,299 --> 00:15:37,059
Voy a comparar este 3 con este 3

245
00:15:37,059 --> 00:15:38,879
No es una referencia

246
00:15:38,879 --> 00:15:40,299
Es un valor allí dentro

247
00:15:40,299 --> 00:15:42,820
Mientras que cuando trabajo con objetos

248
00:15:42,820 --> 00:15:46,840
dentro de la variable no me encuentro el objeto, me encuentro una

249
00:15:46,840 --> 00:15:48,500
referencia donde está el objeto

250
00:15:48,500 --> 00:15:54,299
ahí está la jala, es lo que luego

251
00:15:54,299 --> 00:15:58,500
veremos que en un futuro cuando utilizamos los métodos

252
00:15:58,500 --> 00:16:02,940
y le tenemos que pasar parámetros a estos métodos, habrá pasos por

253
00:16:02,940 --> 00:16:06,799
valor o pasos por referencia

254
00:16:06,799 --> 00:16:10,899
lo veremos y volveremos sobre esto, por ahora me interesa

255
00:16:10,899 --> 00:16:12,899
solo a nivel de string, de entender

256
00:16:12,899 --> 00:16:14,480
por qué string funciona un poquito raro.

257
00:16:15,100 --> 00:16:16,720
¿Sí? Y por qué no

258
00:16:16,720 --> 00:16:18,740
puedo comparar dos

259
00:16:18,740 --> 00:16:20,799
string utilizando

260
00:16:20,799 --> 00:16:24,620
igual, igual. Entonces, ¿cómo

261
00:16:24,620 --> 00:16:25,779
comparo dos string?

262
00:16:28,090 --> 00:16:29,850
Pues string, no.

263
00:16:31,169 --> 00:16:32,110
Porque, cuidado,

264
00:16:33,570 --> 00:16:34,149
si yo comparo

265
00:16:34,149 --> 00:16:36,129
la referencia, estoy comparando si son

266
00:16:36,129 --> 00:16:38,250
el mismo objeto. Pero yo

267
00:16:38,250 --> 00:16:40,210
no quiero preguntarme si son el mismo objeto.

268
00:16:40,289 --> 00:16:42,230
Yo quiero preguntarme si tienen o la dentro igual.

269
00:16:43,149 --> 00:16:44,190
¿Sí? Que sería

270
00:16:44,190 --> 00:16:47,850
esto, que sería, no el valor de la diferencia, porque el valor de la diferencia

271
00:16:47,850 --> 00:16:52,309
de esto podría ser 37, vete a la posición 37, y esto 45

272
00:16:52,309 --> 00:16:56,070
que es, vete a la posición 45 de la memoria y encontrarás el objeto

273
00:16:56,070 --> 00:16:59,710
y estos son dos números distintos, y yo quiero comprobar si

274
00:16:59,710 --> 00:17:04,170
lo interior, el valor, lo que contiene este objeto es igual al valor

275
00:17:04,170 --> 00:17:07,069
de este objeto de aquí, o sea, si al fin y al cabo

276
00:17:07,069 --> 00:17:11,809
hay una H en los dos, hay una O en las dos, hay una L en las dos, hay una O en las dos

277
00:17:11,809 --> 00:17:14,210
Si eso es así, pues son iguales

278
00:17:14,210 --> 00:17:14,690
Si no, no

279
00:17:14,690 --> 00:17:17,869
Pero no lo puedo hacer con el igual-igual

280
00:17:17,869 --> 00:17:21,190
El igual-igual me va a mirar este valor y este valor

281
00:17:21,190 --> 00:17:23,970
Descubrirá que son distintos y me dirá que son distintos

282
00:17:23,970 --> 00:17:26,369
Pero yo no es lo que me estaba preguntando

283
00:17:26,369 --> 00:17:30,650
El igual-igual entre objetos no te pregunta si son iguales

284
00:17:30,650 --> 00:17:32,849
Te pregunta si son el mismo objeto

285
00:17:32,849 --> 00:17:42,599
Charra es un primitivo

286
00:17:42,599 --> 00:17:48,559
Cómo se hace no nos interesa

287
00:17:48,559 --> 00:17:50,500
Vale, por ahora, lo haremos

288
00:17:50,500 --> 00:18:00,920
En cada clase y objeto que tú crearás, el objeto alumno, tú definirás cuando dos alumnos son iguales

289
00:18:00,920 --> 00:18:04,079
Los alumnos iguales cuando son iguales, mejor cuando corresponde el nombre

290
00:18:04,079 --> 00:18:08,099
Y si dos alumnos se llaman igual, pues entonces cuando se corresponde el DNI, pues ya está

291
00:18:08,099 --> 00:18:10,599
Lo decides tú, pero ahora lo veremos

292
00:18:10,599 --> 00:18:16,180
La idea es que si yo uso el igual igual, compruebo el primer nivel

293
00:18:16,180 --> 00:18:20,680
Entonces si yo lo estoy usando entre variables de tipo primitivo

294
00:18:20,680 --> 00:18:24,079
Esto me funciona muy bien porque encuentro el valor directamente allí

295
00:18:24,079 --> 00:18:25,140
Y comparo los valores

296
00:18:25,140 --> 00:18:31,740
Pero si lo utilizo en objetos o en variables que no son de tipo primitivo

297
00:18:31,740 --> 00:18:35,059
No estoy comparando el valor real de este objeto

298
00:18:35,059 --> 00:18:39,059
Si no estoy comparando la referencia de ese objeto

299
00:18:39,059 --> 00:18:40,880
La posición, no es exactamente así

300
00:18:40,880 --> 00:18:43,500
Pero la posición de memoria en la que están

301
00:18:43,500 --> 00:18:46,359
Entonces si la posición de memoria es la misma

302
00:18:46,359 --> 00:18:49,720
Apuntarán al mismo objeto y son lo mismo

303
00:18:49,720 --> 00:18:50,440
Muy bien

304
00:18:50,440 --> 00:18:53,819
Pero si la posición no es la misma

305
00:18:53,819 --> 00:18:56,880
Estará apuntando a dos objetos distintos

306
00:18:56,880 --> 00:19:00,319
Que pero podrían contener lo mismo

307
00:19:00,319 --> 00:19:01,420
Ola y ola

308
00:19:01,420 --> 00:19:03,299
Entonces podrían ser iguales

309
00:19:03,299 --> 00:19:09,420
Desde mi definición de igualdad

310
00:19:09,420 --> 00:19:16,750
Es que con los tipos primitivos no hay problemas

311
00:19:16,750 --> 00:19:19,769
Con los tipos objeto, los tipos no primitivos

312
00:19:19,769 --> 00:19:22,150
Yo puedo preguntarme dos cosas

313
00:19:22,150 --> 00:19:26,450
Puedo preguntarme si son el mismo objeto o si el objeto vale lo mismo

314
00:19:26,450 --> 00:19:28,089
Y son dos cosas distintas

315
00:19:28,089 --> 00:19:32,609
Aquí no son el mismo objeto, pero el objeto vale lo mismo

316
00:19:32,609 --> 00:19:36,470
En una situación en la que creo Y

317
00:19:36,470 --> 00:19:40,289
No, Y no lo he usado ya

318
00:19:40,289 --> 00:19:41,509
Que creo W

319
00:19:41,509 --> 00:19:44,890
Que tiene la misma

320
00:19:44,890 --> 00:19:48,019
Cosa

321
00:19:48,019 --> 00:19:50,059
Aquí se corresponden

322
00:19:50,059 --> 00:19:51,980
Esto

323
00:19:51,980 --> 00:19:55,160
Y se corresponde también en valor

324
00:19:55,160 --> 00:19:57,059
¿Lo veis la diferencia?

325
00:19:57,480 --> 00:19:58,680
¿Cómo lo hago esto en código?

326
00:19:59,059 --> 00:20:00,299
En código sería una cosa así

327
00:20:00,299 --> 00:20:06,509
String

328
00:20:06,509 --> 00:20:09,150
W

329
00:20:09,150 --> 00:20:10,549
Es igual a X

330
00:20:10,549 --> 00:20:22,190
Esto en un cierto sentido me está creando

331
00:20:22,190 --> 00:20:23,630
Una nueva variable

332
00:20:23,630 --> 00:20:27,450
Y está copiando esta cosa de aquí a aquí

333
00:20:27,450 --> 00:20:30,289
Entonces apuntan al mismo objeto

334
00:20:30,289 --> 00:20:31,990
No son dos objetos distintos

335
00:20:31,990 --> 00:20:34,259
¿Dudas?

336
00:20:36,980 --> 00:20:37,740
Vamos hasta aquí

337
00:20:37,740 --> 00:20:40,160
Todo esto para deciros que

338
00:20:40,160 --> 00:20:43,220
No se puede comparar dos strings con igual a igual

339
00:20:43,220 --> 00:20:45,480
Si queréis saber si

340
00:20:45,480 --> 00:20:47,839
Este es un nombre que te ha dado el usuario

341
00:20:47,839 --> 00:20:50,220
Y queréis saber si el nombre que te ha dado el usuario es Estefano

342
00:20:50,220 --> 00:20:52,619
No lo podéis comparar con igual a igual

343
00:20:52,619 --> 00:20:56,019
Lo tenéis que comparar de otra forma

344
00:20:56,019 --> 00:21:03,450
¿Cómo? Nuestro amigo String es una clase

345
00:21:03,450 --> 00:21:10,990
Si vosotros buscáis String API Java, os viene por algún lado la documentación de Java

346
00:21:10,990 --> 00:21:15,069
Donde os sale, por ejemplo, la clase String

347
00:21:15,069 --> 00:21:22,730
Ahora, si os acordáis cuando vimos y hablamos del concepto de programar por objetos

348
00:21:22,730 --> 00:21:24,170
De programación orientada a objetos

349
00:21:24,170 --> 00:21:33,849
La idea era pillar un concepto y juntarlo con las características de este objeto y todo lo que puede hacer este objeto.

350
00:21:34,150 --> 00:21:44,230
Hacer un package, un paquete, en el que dentro pongo lo que es este objeto, sus características, sus valores relacionados,

351
00:21:44,529 --> 00:21:48,029
por ejemplo, las caracteres que tiene dentro si es un string,

352
00:21:48,029 --> 00:21:57,829
y además le añado un montón de funciones, de métodos, que yo puedo utilizar sobre este string, sobre este objeto.

353
00:21:58,769 --> 00:22:11,970
En particular, la clase string me proporciona todos estos métodos que veis aquí para poder trabajar sobre string.

354
00:22:11,970 --> 00:22:26,220
Entre todos estos métodos, del que alguno veremos, está el método equals

355
00:22:26,220 --> 00:22:35,049
Que me permite hacer un igual entre un objeto y otro

356
00:22:35,049 --> 00:22:37,549
Entre un string y otro string

357
00:22:37,549 --> 00:22:46,980
Es decir que cuando quiero comprobar si estos dos señores son iguales

358
00:22:46,980 --> 00:22:49,740
Porque son iguales

359
00:22:49,740 --> 00:23:00,420
no le voy a decir x es igual o igual a k, porque no son el mismo objeto y me diría falso,

360
00:23:00,420 --> 00:23:17,869
porque son dos referencias distintas, sino que le voy a decir x.equals,

361
00:23:17,869 --> 00:23:31,259
.equals, llamo un método de la clase string sobre el objeto x.

362
00:23:32,359 --> 00:23:36,140
Lo veremos en un futuro, por ahora lo asimiláis como podáis.

363
00:23:36,900 --> 00:23:43,720
Cuando quiero hacer esto entre dos strings, en vez de utilizar el .igual, tengo que escribir .equals.

364
00:23:45,119 --> 00:23:45,200
Sí.

365
00:23:53,440 --> 00:23:54,440
Lo veremos en un futuro.

366
00:23:55,059 --> 00:23:55,200
Sí.

367
00:24:00,680 --> 00:24:02,279
No, y no lo hemos visto todavía.

368
00:24:02,279 --> 00:24:06,380
Lo veremos en la segunda evaluación

369
00:24:06,380 --> 00:24:07,460
Por lo tanto, por ahora

370
00:24:07,460 --> 00:24:14,859
No lo sé, lo veremos en la segunda evaluación

371
00:24:14,859 --> 00:24:19,099
Sé solo que sobre string puedo utilizar

372
00:24:19,099 --> 00:24:20,099
Magia

373
00:24:20,099 --> 00:24:22,720
Y la magia se invoca con un punto

374
00:24:22,720 --> 00:24:31,230
Algunos

375
00:24:31,230 --> 00:24:32,349
Veremos

376
00:24:32,349 --> 00:24:33,730
¿Vale?

377
00:24:34,710 --> 00:24:36,809
Entonces, este de aquí, ¿ahora qué me da?

378
00:24:43,670 --> 00:24:44,230
False

379
00:24:44,230 --> 00:24:45,269
¿Es esto?

380
00:24:46,609 --> 00:24:47,730
Si queréis lo ponga aquí

381
00:24:47,730 --> 00:24:49,009
Igual, igual

382
00:24:49,009 --> 00:25:03,650
Y .equals

383
00:25:03,650 --> 00:25:17,210
El

384
00:25:17,210 --> 00:25:34,019
El igual igual

385
00:25:34,019 --> 00:25:35,279
Me da false

386
00:25:35,279 --> 00:25:38,079
El .equals me da true

387
00:25:38,079 --> 00:25:40,079
¿Lo veis?

388
00:25:41,160 --> 00:25:41,319
¿Si?

389
00:25:45,630 --> 00:25:50,079
Entonces os he puesto

390
00:25:50,079 --> 00:25:52,200
Pinceladas de programación a objetos

391
00:25:52,200 --> 00:25:54,079
Por favor, olvidáosla por ahora

392
00:25:54,079 --> 00:25:56,680
¿Vale? Os estoy explicando por qué pasa esto

393
00:25:56,680 --> 00:25:58,359
Por si estáis interesados

394
00:25:58,359 --> 00:25:59,839
Pero sobre esto

395
00:25:59,839 --> 00:26:02,240
Volveremos otras veces y volveremos

396
00:26:02,240 --> 00:26:04,079
Más en detalle cuando veremos los objetos

397
00:26:04,079 --> 00:26:06,519
Ahora, el resumen de esto

398
00:26:06,519 --> 00:26:09,480
Es que no comparéis string con igual igual

399
00:26:09,480 --> 00:26:12,500
Cada vez que queréis preguntaros

400
00:26:12,500 --> 00:26:13,980
Si una string que habéis leído

401
00:26:13,980 --> 00:26:15,900
O que tenéis por ahí es igual a otra string

402
00:26:15,900 --> 00:26:17,740
Lo comparáis con .equals

403
00:26:17,740 --> 00:26:20,470
¿Sí?

404
00:26:21,529 --> 00:26:21,930
¿Lo das?

405
00:26:22,970 --> 00:26:23,250
Vale

406
00:26:23,250 --> 00:26:26,089
Siempre de cara a...

407
00:26:26,089 --> 00:26:26,930
Ok

408
00:26:26,930 --> 00:26:31,609
¿Por qué entonces esto sí funciona?

409
00:26:34,880 --> 00:26:35,059
¿Vale?

410
00:26:35,299 --> 00:26:36,420
Porque si os fijáis

411
00:26:36,420 --> 00:26:38,619
Este de aquí

412
00:26:38,619 --> 00:26:41,660
Hasta este

413
00:26:41,660 --> 00:26:43,119
¿Por qué este funciona?

414
00:26:44,420 --> 00:26:46,299
Este tampoco debería funcionar

415
00:26:46,299 --> 00:26:47,519
Este y este

416
00:26:47,519 --> 00:26:50,220
No deberían funcionar

417
00:26:50,220 --> 00:26:53,559
Por como hemos dicho que funcionan las cosas

418
00:26:53,559 --> 00:26:56,099
Y explico por qué no deberían funcionar

419
00:26:56,099 --> 00:26:59,250
Según lo que hemos entendido

420
00:26:59,250 --> 00:27:01,890
Cuando yo hago

421
00:27:01,890 --> 00:27:07,069
Esta primera cosa aquí

422
00:27:07,069 --> 00:27:09,210
Lo que estoy haciendo es crear

423
00:27:09,210 --> 00:27:14,789
crear un objeto x

424
00:27:14,789 --> 00:27:19,490
que tiene una referencia a un objeto real

425
00:27:19,490 --> 00:27:20,630
donde está escrito hola

426
00:27:20,630 --> 00:27:26,440
cuando hago esto, x es igual a hola

427
00:27:26,440 --> 00:27:29,920
esta cosa de aquí no es este objeto x

428
00:27:29,920 --> 00:27:35,259
debería ser otro valor por algún lado que pone hola

429
00:27:35,259 --> 00:27:37,880
referenciado no sé cómo

430
00:27:37,880 --> 00:27:40,700
porque no tengo una variable para referenciarla

431
00:27:40,700 --> 00:27:43,299
Y estaría comprobando esto con esto

432
00:27:43,299 --> 00:27:45,980
Pero como esto no es esto

433
00:27:45,980 --> 00:27:47,500
Porque es este de aquí

434
00:27:47,500 --> 00:27:48,740
Me debería dar falso

435
00:27:48,740 --> 00:27:50,980
El problema

436
00:27:50,980 --> 00:27:53,400
Es que como se usan

437
00:27:53,400 --> 00:27:54,099
Muchas

438
00:27:54,099 --> 00:27:56,480
Muchas

439
00:27:56,480 --> 00:27:57,859
Strings

440
00:27:57,859 --> 00:28:00,079
Y como los strings se usan mucho

441
00:28:00,079 --> 00:28:03,539
Y como Java quiere ser eficiente

442
00:28:03,539 --> 00:28:05,240
Con los strings

443
00:28:05,240 --> 00:28:06,240
Y solo con los strings

444
00:28:06,240 --> 00:28:08,539
Pero en particular con los strings

445
00:28:08,539 --> 00:28:19,500
Cuando yo hago esta cosa de aquí, en realidad el objeto hola que se crea es un objeto especial que se queda allí

446
00:28:19,500 --> 00:28:27,640
Y cuando yo lo reutilizo otra vez, él va a utilizar el mismo objeto, no va a crear uno nuevo

447
00:28:27,640 --> 00:28:31,480
Es como si en vez de crear un nuevo objeto cada vez que lo uso

448
00:28:31,480 --> 00:28:35,819
Él se hiciera un índice

449
00:28:35,819 --> 00:28:41,079
Un vocabulario, un diccionario, no sé cómo llamarlo

450
00:28:41,079 --> 00:28:43,380
En que dice, vale, aquí me creo hola

451
00:28:43,380 --> 00:28:46,740
Y ahora todas las veces que usas el string hola, pues usa esto

452
00:28:46,740 --> 00:28:49,740
¿Por qué? Porque es más fácil

453
00:28:49,740 --> 00:28:51,880
No tengo que crear 50 veces hola

454
00:28:51,880 --> 00:28:53,519
Lo tengo aquí, es hola, ya está

455
00:28:53,519 --> 00:29:00,759
Y entonces cuando uso esto o cuando uso esto

456
00:29:00,759 --> 00:29:04,059
En realidad está utilizando el mismo objeto

457
00:29:04,059 --> 00:29:07,920
Y cuando hago Y, en realidad me dice

458
00:29:07,920 --> 00:29:10,359
Uy, hola, ya existe mi índice

459
00:29:10,359 --> 00:29:15,079
Y por lo tanto en vez de crear un nuevo hola y gastar memoria

460
00:29:15,079 --> 00:29:20,000
Voy a pillar y hacerte referenciar el mismo objeto que antes

461
00:29:20,000 --> 00:29:22,960
Por eso cuando hago son iguales

462
00:29:22,960 --> 00:29:26,119
Sí, porque son la misma referencia

463
00:29:26,119 --> 00:29:29,140
Para que me dé false

464
00:29:29,140 --> 00:29:32,160
Si os fijáis, yo voy a crear una cosa distinta

465
00:29:32,160 --> 00:29:34,240
Cuando le digo esto

466
00:29:34,240 --> 00:29:36,180
Entonces él no puede decir

467
00:29:36,180 --> 00:29:37,539
Oye, mira acá, va aquí

468
00:29:37,539 --> 00:29:40,839
Porque HO no es lo mismo que hola

469
00:29:40,839 --> 00:29:43,940
Está forzado a crearme otro objeto HO

470
00:29:43,940 --> 00:29:51,359
Que luego yo lo modifique, le añade el A detrás

471
00:29:51,359 --> 00:29:53,559
Pues no me lo hace igual a esto

472
00:29:53,559 --> 00:29:57,180
no se da cuenta que son lo mismo

473
00:29:57,180 --> 00:29:57,920
al final

474
00:29:57,920 --> 00:30:00,000
y entonces ahora tengo dos objetos

475
00:30:00,000 --> 00:30:02,859
y entonces cuando intento hacer x igual a k

476
00:30:02,859 --> 00:30:03,839
me dice no

477
00:30:03,839 --> 00:30:07,259
porque son dos objetos reales

478
00:30:07,259 --> 00:30:08,079
aún así

479
00:30:08,079 --> 00:30:10,240
¿os interesa saberlo, haberlo entendido?

480
00:30:10,700 --> 00:30:12,380
no, ¿qué os interesa?

481
00:30:19,640 --> 00:30:21,039
para comprobar

482
00:30:21,039 --> 00:30:22,960
dos strings

483
00:30:22,960 --> 00:30:24,640
se usa el punto equals

484
00:30:24,640 --> 00:30:27,119
siempre, cada vez que yo tenga

485
00:30:27,119 --> 00:30:29,059
que hacer comparaciones entre dos strings

486
00:30:29,059 --> 00:30:32,559
haré string1.equals

487
00:30:32,559 --> 00:30:34,619
y entre paréntesis pongo la string2

488
00:30:34,619 --> 00:30:37,180
se acabó, eso es lo que tengo que hacer

489
00:30:37,180 --> 00:30:43,079
sí, sí, espérate, espérate, no te vayas adelante

490
00:30:43,079 --> 00:30:45,200
¿has entendido esto? sí, pues ahora

491
00:30:45,200 --> 00:30:47,480
déjame tiempo

492
00:30:47,480 --> 00:30:50,240
que sí, que sí, que voy a dar más

493
00:30:50,240 --> 00:30:53,619
pero, equals, equals

494
00:30:53,619 --> 00:30:57,759
¿sí? ¿se ha entendido? vale

495
00:30:57,759 --> 00:31:00,240
Otros metoditos mágicos

496
00:31:00,240 --> 00:31:01,299
Ya que estamos aquí

497
00:31:01,299 --> 00:31:04,740
Que son muy útiles de string

498
00:31:04,740 --> 00:31:06,119
Uno lo hemos visto

499
00:31:06,119 --> 00:31:08,460
Ayer

500
00:31:08,460 --> 00:31:12,549
Charat

501
00:31:12,549 --> 00:31:15,269
Imaginaos que tengo un string

502
00:31:15,269 --> 00:31:18,789
String S es igual a

503
00:31:18,789 --> 00:31:21,950
A, B, C, D, E, F, G

504
00:31:21,950 --> 00:31:26,339
Lo que puedo hacer

505
00:31:26,339 --> 00:31:29,420
Es pillar uno solo de estos caracteres

506
00:31:29,420 --> 00:31:31,559
Por ejemplo, haciendo que char

507
00:31:31,559 --> 00:31:33,279
C1

508
00:31:33,279 --> 00:31:36,759
Es igual, o le llamo c0

509
00:31:36,759 --> 00:31:40,460
Es igual a s

510
00:31:40,460 --> 00:31:42,980
Pillo la string

511
00:31:42,980 --> 00:31:44,740
Le aplico magia

512
00:31:44,740 --> 00:31:46,259
Char at

513
00:31:46,259 --> 00:31:49,819
Y la posición del carácter que quiero

514
00:31:49,819 --> 00:31:54,819
Tened en cuenta que los índices de los carácteres empiezan de 0

515
00:31:54,819 --> 00:31:57,460
Este es el carácter 0

516
00:31:57,460 --> 00:31:59,480
1

517
00:31:59,480 --> 00:32:01,240
2

518
00:32:01,240 --> 00:32:02,779
3

519
00:32:02,779 --> 00:32:06,859
4, 5, 6

520
00:32:06,859 --> 00:32:12,039
entonces si ahora hago, si hizo

521
00:32:12,039 --> 00:32:16,519
c0, que me escribirá

522
00:32:16,519 --> 00:32:32,150
y si en vez de c0 pillo c3

523
00:32:32,150 --> 00:32:41,759
0, 1, 2

524
00:32:41,759 --> 00:32:45,019
3, que me pilla

525
00:32:45,019 --> 00:32:56,079
d, se entiende, esto es

526
00:32:56,079 --> 00:32:58,579
De este string

527
00:32:58,579 --> 00:33:00,500
Pilla el carácter

528
00:33:00,500 --> 00:33:02,359
En la posición

529
00:33:02,359 --> 00:33:04,079
Esta

530
00:33:04,079 --> 00:33:05,839
Acordaos que empieza por 0

531
00:33:05,839 --> 00:33:18,069
¿Dónde está el primitivo?

532
00:33:18,150 --> 00:33:19,869
Yo estoy usando un método sobre que

533
00:33:19,869 --> 00:33:22,809
¿Y ese qué es?

534
00:33:28,740 --> 00:33:32,240
El primitivo es el resultado de esto

535
00:33:32,240 --> 00:33:33,839
Pero yo el método

536
00:33:33,839 --> 00:33:35,980
Lo estoy usando sobre un

537
00:33:35,980 --> 00:33:39,869
Char

538
00:33:39,869 --> 00:33:42,190
No es un objeto, no tiene métodos

539
00:33:42,190 --> 00:33:44,130
S es un string

540
00:33:44,130 --> 00:33:46,230
Si tiene método, tiene el método equals

541
00:33:46,230 --> 00:33:48,470
Tiene el método charAt

542
00:33:48,470 --> 00:33:56,180
Pero siempre lo estoy usando sobre algo

543
00:33:56,180 --> 00:33:57,480
Que es un string

544
00:33:57,480 --> 00:34:00,279
Todos los métodos que vamos a ver

545
00:34:00,279 --> 00:34:02,680
En este momento se están utilizando

546
00:34:02,680 --> 00:34:04,460
Sobre un objeto

547
00:34:04,460 --> 00:34:05,980
Que no es de tipo primitivo

548
00:34:05,980 --> 00:34:07,480
No puede hacer

549
00:34:07,480 --> 00:34:10,079
C0 punto

550
00:34:10,079 --> 00:34:12,039
Nada

551
00:34:12,039 --> 00:34:14,639
Fijaos que si yo hago ese punto

552
00:34:14,639 --> 00:34:16,019
El

553
00:34:16,019 --> 00:34:18,579
me dice, uy, puedes hacer todas estas cosas

554
00:34:18,579 --> 00:34:22,719
de aquí, que fíjate tú

555
00:34:22,719 --> 00:34:23,599
son

556
00:34:23,599 --> 00:34:27,489
estas cosas de aquí

557
00:34:27,489 --> 00:34:30,469
sin embargo, si hago

558
00:34:30,469 --> 00:34:32,769
c0

559
00:34:32,769 --> 00:34:34,809
que no es un objeto

560
00:34:34,809 --> 00:34:38,820
punto, no hay nada

561
00:34:38,820 --> 00:34:41,420
porque no es un objeto, no tiene asociado

562
00:34:41,420 --> 00:34:42,019
métodos

563
00:34:42,019 --> 00:34:44,539
solo ese, punto

564
00:34:44,539 --> 00:34:47,059
solo lo metido scan

565
00:34:47,059 --> 00:34:47,880
le borramos

566
00:34:47,880 --> 00:34:50,039
scanner

567
00:34:50,039 --> 00:34:52,420
scan es igual a new

568
00:34:52,420 --> 00:34:53,960
scanner de

569
00:34:53,960 --> 00:34:56,480
system.int

570
00:34:56,480 --> 00:34:58,599
que es el otro objeto que nosotros estamos

571
00:34:58,599 --> 00:35:00,380
manejando, vale

572
00:35:00,380 --> 00:35:01,480
scan.

573
00:35:02,260 --> 00:35:04,420
Y esto es todo lo que puede hacer con scan.

574
00:35:05,340 --> 00:35:05,940
Incluido

575
00:35:05,940 --> 00:35:07,760
next

576
00:35:07,760 --> 00:35:09,900
int, por ejemplo.

577
00:35:10,760 --> 00:35:11,860
Que es el que uso yo.

578
00:35:12,320 --> 00:35:14,699
Porque cuando yo he usado scan.next

579
00:35:14,699 --> 00:35:16,019
int nadie me ha dicho nada.

580
00:35:18,039 --> 00:35:20,460
Nadie se ha bajurado. ¿Qué es eso del punto?

581
00:35:20,460 --> 00:35:22,860
Pero estabais usando un objeto

582
00:35:22,860 --> 00:35:24,920
O estabais usando un objeto

583
00:35:24,920 --> 00:35:26,699
Y estabais usando un método

584
00:35:26,699 --> 00:35:29,400
Pues misma cosa, estoy usando un objeto

585
00:35:29,400 --> 00:35:31,940
Y estoy usando un método

586
00:35:31,940 --> 00:35:33,480
Estoy usando un objeto

587
00:35:33,480 --> 00:35:34,940
Y estoy usando un método

588
00:35:34,940 --> 00:35:37,860
Y es lo que decíamos al principio

589
00:35:37,860 --> 00:35:39,719
¿Estamos usando nosotros

590
00:35:39,719 --> 00:35:41,860
Programación estructurada básica?

591
00:35:41,940 --> 00:35:43,699
No, estamos usando programación de un objeto

592
00:35:43,699 --> 00:35:44,539
Solo que no lo sabéis

593
00:35:44,539 --> 00:35:59,730
Lo que podéis hacer es pillar

594
00:35:59,730 --> 00:36:01,929
Al fin y al cabo, lo que es un string

595
00:36:01,929 --> 00:36:04,289
es un objeto que representa una secuencia

596
00:36:04,289 --> 00:36:06,309
de char, en vez de utilizar carácter

597
00:36:06,309 --> 00:36:08,210
por carácter, tú podrías no usar

598
00:36:08,210 --> 00:36:10,190
los string, nunca, y trabajar

599
00:36:10,190 --> 00:36:12,170
todo con char, pero sería un infierno

600
00:36:12,170 --> 00:36:16,130
para escribir hola, necesitas 4 char

601
00:36:16,130 --> 00:36:28,389
entonces, aquí hemos

602
00:36:28,389 --> 00:36:29,389
visto equals

603
00:36:29,389 --> 00:36:33,670
aquí hemos visto charat

604
00:36:33,670 --> 00:36:37,179
¿están de acuerdo?

605
00:36:38,000 --> 00:36:39,179
tercer método

606
00:36:39,179 --> 00:36:41,059
que nos mola

607
00:36:41,059 --> 00:36:42,719
de string

608
00:36:42,719 --> 00:36:44,659
lengt

609
00:36:44,659 --> 00:36:48,119
¿Qué hará LENGTH?

610
00:37:03,190 --> 00:37:07,650
Me dice cuántos caracteres hay en este string

611
00:37:07,650 --> 00:37:11,289
Por ejemplo, pillo este de aquí

612
00:37:11,289 --> 00:37:16,050
Le digo SISO S.LENGTH

613
00:37:16,050 --> 00:37:21,460
Me contestará 7

614
00:37:21,460 --> 00:37:26,739
¿Por qué? ¿Cuántos caracteres hay aquí?

615
00:37:32,440 --> 00:37:33,000
Cuidado

616
00:37:33,000 --> 00:37:37,659
Siete caracteres

617
00:37:37,659 --> 00:37:41,239
Que van de la posición cero a la posición seis

618
00:37:41,239 --> 00:37:45,659
¿Sí?

619
00:37:46,800 --> 00:37:47,559
No, son siete

620
00:37:47,559 --> 00:37:51,280
ABCDEFG, contala, son siete

621
00:37:51,280 --> 00:37:53,940
Pero el problema es que van de cero a seis

622
00:37:53,940 --> 00:37:58,880
La posición es uno menos

623
00:37:58,880 --> 00:38:02,760
No obstante sean siete caracteres

624
00:38:02,760 --> 00:38:04,760
Nunca habrá un charat de siete

625
00:38:04,760 --> 00:38:07,440
No existe el charat de siete

626
00:38:07,440 --> 00:38:08,920
Porque va de cero a seis

627
00:38:08,920 --> 00:38:12,019
Si tengo una string de 52

628
00:38:12,019 --> 00:38:13,900
Irá de 0 a 51

629
00:38:13,900 --> 00:38:16,619
Nunca habrá el carácter en posición 52

630
00:38:16,619 --> 00:38:19,300
¿Se entiende?

631
00:38:20,300 --> 00:38:20,780
¿Dudas?

632
00:38:22,000 --> 00:38:22,760
¿Preguntas?

633
00:38:23,440 --> 00:38:24,880
Y pregunta para vosotros

634
00:38:24,880 --> 00:38:27,920
¿Qué pasa si aquí yo le pongo

635
00:38:27,920 --> 00:38:36,619
Su...

636
00:38:36,619 --> 00:38:37,420
Error

637
00:38:37,420 --> 00:38:42,420
String index

638
00:38:42,420 --> 00:38:43,800
Out of bounds

639
00:38:43,800 --> 00:38:44,719
Exception

640
00:38:44,719 --> 00:38:47,519
Índice del string

641
00:38:47,519 --> 00:38:51,559
fuera de los límites, índice de los

642
00:38:51,559 --> 00:38:55,039
string, fuera de los límites, de 0 a 6

643
00:38:55,039 --> 00:39:02,619
¿se entiende? y ¿qué pasa si le digo, jaja, yo soy listo

644
00:39:02,619 --> 00:39:05,199
le pongo menos 3, o menos 2

645
00:39:05,199 --> 00:39:10,519
error, mismo error, ¿vale? es el mismo, siempre

646
00:39:10,519 --> 00:39:14,420
fuera de los límites, los límites son de 0 a 6, de 0

647
00:39:14,420 --> 00:39:23,449
a length menos 1, ¿ok? de 0

648
00:39:23,449 --> 00:39:25,090
que es el primero

649
00:39:25,090 --> 00:39:27,030
a length

650
00:39:27,030 --> 00:39:28,989
menos uno

651
00:39:28,989 --> 00:39:31,710
length sería siete, menos uno es seis

652
00:39:31,710 --> 00:39:37,500
estos tres señores

653
00:39:37,500 --> 00:39:39,519
equals, charat

654
00:39:39,519 --> 00:39:41,860
y length se usan mucho

655
00:39:41,860 --> 00:39:44,239
son de los tres

656
00:39:44,239 --> 00:39:45,500
métodos de string

657
00:39:45,500 --> 00:39:47,039
que más se usan

658
00:39:47,039 --> 00:39:51,349
para programar

659
00:39:51,349 --> 00:39:54,820
está programado muchas veces

660
00:39:54,820 --> 00:39:56,219
lo veréis

661
00:39:56,219 --> 00:39:58,559
son cosas que se utilizan

662
00:39:58,559 --> 00:40:01,239
por ejemplo, con esto

663
00:40:01,239 --> 00:40:03,059
ahora ya podéis

664
00:40:03,059 --> 00:40:05,340
darme un char solo

665
00:40:05,340 --> 00:40:08,179
es un string y luego pillas el primer carácter

666
00:40:08,179 --> 00:40:08,699
y ya está

667
00:40:08,699 --> 00:40:11,280
luego veremos para qué sirve en un futuro

668
00:40:11,280 --> 00:40:12,820
fijaos también que

669
00:40:12,820 --> 00:40:13,980
equals

670
00:40:13,980 --> 00:40:16,420
pilla como parámetro

671
00:40:16,420 --> 00:40:17,920
entre paréntesis

672
00:40:17,920 --> 00:40:19,179
otro string

673
00:40:19,179 --> 00:40:21,739
x es un string

674
00:40:21,739 --> 00:40:22,960
punto equals

675
00:40:22,960 --> 00:40:24,960
k que es el otro string

676
00:40:24,960 --> 00:40:26,659
porque tiene que comparar dos

677
00:40:26,659 --> 00:40:29,460
compara el objeto x

678
00:40:29,460 --> 00:40:31,500
Que estás llamando el equals

679
00:40:31,500 --> 00:40:33,460
Con el objeto k

680
00:40:33,460 --> 00:40:35,460
Que es el otro objeto que voy a comparar

681
00:40:35,460 --> 00:40:36,539
Comparo estos dos

682
00:40:36,539 --> 00:40:39,000
Charat

683
00:40:39,000 --> 00:40:40,980
Recibe como parámetro

684
00:40:40,980 --> 00:40:42,679
Cual es la posición

685
00:40:42,679 --> 00:40:45,079
Vale, tú dame un string

686
00:40:45,079 --> 00:40:45,619
S

687
00:40:45,619 --> 00:40:49,480
Te voy a sacar un carácter en una determinada posición

688
00:40:49,480 --> 00:40:51,239
Pero me tienes que decir

689
00:40:51,239 --> 00:40:52,579
Que posición es

690
00:40:52,579 --> 00:40:54,780
¿Entiende?

691
00:40:55,460 --> 00:40:57,500
Y finalmente length en vez

692
00:40:57,500 --> 00:40:59,300
No necesita ningún parámetro

693
00:40:59,300 --> 00:41:05,539
No depende de un parámetro decir cuánto es la larga de una cadena

694
00:41:05,539 --> 00:41:09,269
Cuántos carácter contiene un string

695
00:41:09,269 --> 00:41:11,349
No necesita ningún parámetro

696
00:41:11,349 --> 00:41:14,409
Necesita solo el string sobre el que lo llamo

697
00:41:14,409 --> 00:41:22,090
Entonces, acordaos que esto recibe otro string

698
00:41:22,090 --> 00:41:23,949
Esto recibe un entero

699
00:41:23,949 --> 00:41:26,530
Que tiene que estar entre 0

700
00:41:26,530 --> 00:41:30,389
Entre 0 y

701
00:41:30,389 --> 00:41:31,389
Length

702
00:41:31,389 --> 00:41:34,429
Menos 1

703
00:41:34,429 --> 00:41:36,710
Si no explota

704
00:41:36,710 --> 00:41:38,550
Y este de aquí

705
00:41:38,550 --> 00:41:42,530
No recibe ningún parámetro

706
00:41:42,530 --> 00:41:47,940
Tú das

707
00:41:47,940 --> 00:41:49,480
Sobre esto

708
00:41:49,480 --> 00:41:54,659
Y esto es un poquito de manejo de string

709
00:41:54,659 --> 00:42:01,750
Porque no le sirve

710
00:42:01,750 --> 00:42:03,929
¿Qué parámetro le vas a dar?

711
00:42:04,929 --> 00:42:06,909
Yo tengo esta palabra aquí

712
00:42:06,909 --> 00:42:07,369
Speaker

713
00:42:07,369 --> 00:42:09,369
¿Vale? Y tengo esta

714
00:42:09,369 --> 00:42:13,329
¿Qué te sirve más para contar cuántas letras hay?

715
00:42:14,289 --> 00:42:15,230
Pues te sirven solo speakers

716
00:42:15,230 --> 00:42:17,889
Ahora, si yo te digo, píllame una letra

717
00:42:17,889 --> 00:42:20,730
De speaker píllame una letra en una cierta posición

718
00:42:20,730 --> 00:42:22,849
¿Necesitas algo más de parámetro?

719
00:42:23,730 --> 00:42:25,309
Sí, necesitas saber qué posición

720
00:42:25,309 --> 00:42:27,070
Si no, ¿cómo te pillo esa cosa ahí?

721
00:42:27,289 --> 00:42:28,389
Pues entonces te lo doy aquí

722
00:42:28,389 --> 00:42:31,750
Y yo te digo, ahora compárame speaker con otra cosa

723
00:42:31,750 --> 00:42:34,829
¿Necesitarás otro parámetro? ¿Qué es el otro parámetro?

724
00:42:35,329 --> 00:42:35,989
La otra cosa

725
00:42:35,989 --> 00:42:36,929
¿Vale?

726
00:42:37,309 --> 00:42:40,010
Con esta cosa aquí, speaker con esta

727
00:42:40,010 --> 00:42:42,010
Posición de memoria, speaker con esta cosa

728
00:42:42,010 --> 00:42:44,030
Que leo de teclado, pero necesito

729
00:42:44,030 --> 00:42:46,329
Otra cosa para poder comparar

730
00:42:46,329 --> 00:42:47,329
Por eso le paso los parámetros

731
00:42:47,329 --> 00:42:49,710
¿Sí? Ahora, esto

732
00:42:49,710 --> 00:42:52,090
Con calma

733
00:42:52,090 --> 00:42:53,030
Hay que

734
00:42:53,030 --> 00:42:56,230
Asimilarlo

735
00:42:56,230 --> 00:42:58,110
¿Vale? Es un pasito porque

736
00:42:58,110 --> 00:43:00,170
Usa métodos, vosotros estáis

737
00:43:00,170 --> 00:43:01,650
Usando métodos desde el primer

738
00:43:01,650 --> 00:43:03,670
Programa que habéis hecho

739
00:43:03,670 --> 00:43:06,050
Porque esto sabéis vosotros que es

740
00:43:06,050 --> 00:43:08,150
Y esto que será

741
00:43:08,150 --> 00:43:18,989
Este es un objeto

742
00:43:18,989 --> 00:43:23,820
System.out será un objeto

743
00:43:23,820 --> 00:43:26,280
De tipo printwriter

744
00:43:26,280 --> 00:43:26,659
Creo

745
00:43:26,659 --> 00:43:29,800
Que si vosotros lo buscáis aquí

746
00:43:29,800 --> 00:43:32,690
En esta cosa aquí

747
00:43:32,690 --> 00:43:34,469
Encontráis un objeto printwriter

748
00:43:34,469 --> 00:43:36,590
Que tiene la posibilidad de hacer

749
00:43:36,590 --> 00:43:38,190
El método println

750
00:43:38,190 --> 00:43:39,469
Este

751
00:43:39,469 --> 00:43:42,349
Y lo habéis estado utilizando sin problemas

752
00:43:42,349 --> 00:43:43,110
Desde el primer día

753
00:43:43,110 --> 00:43:46,030
Habéis utilizado el escáner

754
00:43:46,030 --> 00:43:48,349
cuántas veces os ha dado la gana desde el primer día

755
00:43:48,349 --> 00:43:49,769
ahora

756
00:43:49,769 --> 00:43:51,969
hemos entendido un poquito más

757
00:43:51,969 --> 00:43:52,929
de cómo van las cosas

758
00:43:52,929 --> 00:43:55,429
y hemos entendido que string

759
00:43:55,429 --> 00:43:57,590
no es un carácter primitivo

760
00:43:57,590 --> 00:43:59,750
un tipo primitivo

761
00:43:59,750 --> 00:44:02,130
es un tipo avanzado

762
00:44:02,130 --> 00:44:04,130
porque en realidad

763
00:44:04,130 --> 00:44:05,789
es una clase

764
00:44:05,789 --> 00:44:08,210
alguien ha hecho public class string

765
00:44:08,210 --> 00:44:09,969
ha abierto paréntesis

766
00:44:09,969 --> 00:44:12,090
y ha escrito todos los métodos

767
00:44:12,090 --> 00:44:13,730
que vemos aquí en esta cosa aquí

768
00:44:13,730 --> 00:44:15,409
y los ha implementado

769
00:44:15,409 --> 00:44:17,730
y ahora yo los puedo usar

770
00:44:17,730 --> 00:44:20,570
entre todos estos hay tres

771
00:44:20,570 --> 00:44:24,530
que son equals, charAt y length

772
00:44:24,530 --> 00:44:36,809
esto aquí, y ahora os pongo

773
00:44:36,809 --> 00:44:40,250
aquí hay, para que practiquéis estos conceptos

774
00:44:40,250 --> 00:44:45,150
hay una tanda de ejercicios sobre string

775
00:44:45,150 --> 00:44:49,710
que sustancialmente os hace utilizar estos métodos

776
00:44:49,710 --> 00:44:51,829
como por ejemplo, compararás dos cadenas

777
00:44:51,829 --> 00:44:55,429
Y te dice, utiliza el método equals, ¿vale?

778
00:44:55,510 --> 00:44:57,769
O no, o no, para ver si son iguales o no.

779
00:44:58,670 --> 00:45:00,269
¿Sí? Y te dice de hacer este ejercicio.

780
00:45:00,369 --> 00:45:03,469
Luego te dice, convertir mayúsculas a minúsculas.

781
00:45:04,610 --> 00:45:09,829
Entonces, hay un método de string que tú le das una cadena en minúsculas,

782
00:45:10,630 --> 00:45:13,409
le dices, haz tu magia y se transforma en mayúsculas.

783
00:45:14,090 --> 00:45:16,469
Como por ejemplo el toUpperCase.

784
00:45:16,469 --> 00:45:26,869
Y hay otro método que me da una cadena y te transforma todas las letras en minúsculas, que es toLowerCase.

785
00:45:27,829 --> 00:45:30,409
Y esto ya está hecho, es solo utilizarlo.

786
00:45:31,050 --> 00:45:42,630
Entonces, te dice, entrada está de aquí, la salida esperada que te ponga o todo en minúsculas, si has usado el toLowerCase, o todo mayúsculas si has usado el toUpperCase.

787
00:45:42,630 --> 00:45:46,750
obtener la longitud de una cadena

788
00:45:46,750 --> 00:45:48,769
pues aquí tendrás que utilizar el método length

789
00:45:48,769 --> 00:45:51,349
concatenar dos cadenas

790
00:45:51,349 --> 00:45:52,610
el operador más

791
00:45:52,610 --> 00:45:54,409
y existe también otra forma

792
00:45:54,409 --> 00:45:55,909
que es el método concat

793
00:45:55,909 --> 00:45:58,429
¿vale? hace lo mismo

794
00:45:58,429 --> 00:46:00,429
extraer subcadenas

795
00:46:00,429 --> 00:46:02,750
pues entonces está el método substring

796
00:46:02,750 --> 00:46:06,710
reemplazar cadenas

797
00:46:06,710 --> 00:46:07,969
el método replace

798
00:46:07,969 --> 00:46:15,090
Comprobar si una cadena empieza o termina con una cadena

799
00:46:15,090 --> 00:46:17,429
Starts with o ends with

800
00:46:17,429 --> 00:46:20,929
Etcétera, etcétera, etcétera

801
00:46:20,929 --> 00:46:21,190
¿Vale?

802
00:46:28,190 --> 00:46:28,409
Sí

803
00:46:28,409 --> 00:46:30,010
Es lo mismo que el más

804
00:46:30,010 --> 00:46:35,110
Pero a lo mejor en ciertos casos necesitas este método

805
00:46:35,110 --> 00:46:36,329
Sí

806
00:46:36,329 --> 00:46:40,329
Entonces, la idea es que luego pilléis estas cosas de aquí

807
00:46:40,329 --> 00:46:42,630
Intentáis hacerla y utilizarla

808
00:46:42,630 --> 00:46:49,170
Veréis que algunos de estos métodos necesitan poner valores y algunos no

809
00:46:49,170 --> 00:46:58,099
Por ejemplo, el método toUpperCase

810
00:46:58,099 --> 00:47:03,019
¿Creéis que va a pillar algún parámetro o no?

811
00:47:03,860 --> 00:47:06,440
No, tienes una cadena, hazla en mayúscula

812
00:47:06,440 --> 00:47:07,960
Ya está, no necesito nada más

813
00:47:07,960 --> 00:47:12,500
Ahora, el método cambia

814
00:47:12,500 --> 00:47:15,940
que lo que hace es pillar

815
00:47:15,940 --> 00:47:17,940
por ejemplo

816
00:47:17,940 --> 00:47:21,250
reemplazar las aporo

817
00:47:21,250 --> 00:47:23,250
tendré que decirle

818
00:47:23,250 --> 00:47:29,320
cuántos parámetros, al menos dos

819
00:47:29,320 --> 00:47:31,320
lo que quiero reemplazar

820
00:47:31,320 --> 00:47:33,320
y a qué

821
00:47:33,320 --> 00:47:39,829
quiero reemplazar

822
00:47:39,829 --> 00:47:41,829
dímelo tú

823
00:47:41,829 --> 00:47:43,829
y si vosotros

824
00:47:43,829 --> 00:47:45,829
buscáis el string

825
00:47:45,829 --> 00:47:47,829
aquí os viene más información

826
00:47:47,829 --> 00:47:49,829
vais al método replace

827
00:47:49,829 --> 00:47:53,139
replace

828
00:47:53,139 --> 00:47:55,059
y te dice que