Saltar navegación

Clase 23-04-24 - 1 - Contenido educativo

Ajuste de pantalla

El ajuste de pantalla se aprecia al ver el vídeo en pantalla completa. Elige la presentación que más te guste:

Subido el 6 de mayo de 2024 por Raquel G.

9 visualizaciones

Más información Transcripción

Descargar la transcripción

Bueno, ayer corregimos este ejercicio que era una chorrada, el primero, que era esta interfaz gráfica de ahí y ya está con tres componentes. 00:00:00
Entonces, esta interfaz gráfica tenía dos botones que podían recibir evento, dos. 00:00:14
A diferencia de nuestro primer ejemplo con el que hicimos la explicación, que solo tenía un botón que podía recibir evento. 00:00:20
el botón de Sbis y esto, no Sbis y esto 00:00:27
este tiene dos botones que pueden recibir 00:00:28
evento, este 00:00:31
para convertir de dólares a euros 00:00:32
y este otro para convertir 00:00:35
de euros a dólares 00:00:37
entonces, como son dos 00:00:38
componentes distintos 00:00:41
los que pueden recibir una acción 00:00:42
son dos eventos que capturar 00:00:45
y entonces, según eso 00:00:47
hicimos dos clases internas 00:00:49
ActionListener, ¿verdad? 00:00:51
hicimos esta clase 00:00:53
interna, que tan grande 00:00:55
apenas se ve. Esta clase 00:00:59
interna, ActionListener, 00:01:01
que era para convertir 00:01:03
dólares 00:01:06
a euros, esta clase 00:01:09
interna. Y esta 00:01:11
otra clase interna, que era para 00:01:13
convertir de euros a dólares, 00:01:15
dos clases internas. Y ahora 00:01:17
en el constructor, donde se construía 00:01:19
la interfaz, a este botoncito 00:01:21
le asociamos un 00:01:23
objeto de una de las capturadoras 00:01:25
y al otro botoncito, a este otro 00:01:26
le asociamos un objeto de la otra 00:01:29
bueno, pues 00:01:31
extendido esto, generalizado 00:01:33
esto, podríamos llegar 00:01:35
a una situación en la cual 00:01:37
si yo voy a capturar eventos de un montón 00:01:39
de botones, tengo ahí un chorro 00:01:41
cientos de clases internas 00:01:43
lo cual es un poco pesado 00:01:45
manejar un montón de clases internas 00:01:47
en realidad no es que sea pesado manejarlas, sino escribir 00:01:48
entonces 00:01:51
¿qué podemos hacer? 00:01:53
Pues a lo mejor podemos hacer una sola clase interna y esa clase interna que capture varios eventos. Esa cosa tan rara como. Bueno, pues vamos a mirar ahora este método que hemos pasado por alto por él muy alegremente. Vamos a mirar este método. 00:01:56
este método hemos dicho 00:02:11
que es el método 00:02:14
¡Silencio! 00:02:15
este es el método que tiene que 00:02:19
sobreescribir 00:02:21
una clase que quiera ser 00:02:22
clase capaz de estar pendiente 00:02:25
de si en la interfaz pasan cosas o no 00:02:27
¿no? 00:02:29
es decir, una clase que implementa ActionListener 00:02:31
por el hecho de implementar ActionListener 00:02:33
se convierte ya en clase 00:02:36
que es capaz de estar pendiente 00:02:38
de si pasan cosas en la interfaz o no 00:02:40
¿vale? 00:02:42
Entonces, al implementar una interfaz, ya sabemos que tenemos que sobrescribir los métodos que esa interfaz tenga vacíos. 00:02:43
En el caso de ActionListener, el único que tiene vacío es este, que es el que hemos sobrescrito sin prestar atención a su cabecera en ningún momento. 00:02:50
Es esa la cabecera, porque yo no puedo cambiarla, es la de ActionListener, no la puedo cambiar, y la hemos sobrescrito sin prestar atención a ella. 00:02:59
Y lo que sí que hemos sabido, obviamente, lo que sí que sabemos es que el código que pongamos aquí, corto, largo, de una línea o mil líneas, el código que sea, es el código que se va a ejecutar cuando este evento al cual hemos asociado esta clase se genere. 00:03:05
bueno, pues vamos a prestar atención 00:03:29
a esta cabecera de aquí, a este método 00:03:31
el nombrecito 00:03:33
no tiene 00:03:36
mayor interés, la acción realizada 00:03:37
vale, la acción realizada 00:03:40
lo que vas a realizar cuando ocurra 00:03:41
el evento, acción realizada, muy bien 00:03:43
y ahora, este parámetro 00:03:45
que se pasa, decimos 00:03:48
uy, este parámetro, ¿de dónde ha salido? 00:03:49
¿quién se lo pasa? ¿este parámetro de quién es? 00:03:51
es que además 00:03:54
es un parámetro que hemos ignorado, ni siquiera hemos 00:03:55
usado aquí en ningún momento 00:03:57
y podríamos usarlo porque es un parámetro 00:03:58
para el método, ¿verdad? Es un parámetro para el método 00:04:01
podríamos usarlo. Bueno, pues 00:04:03
¿Perdón? 00:04:05
Claro, pues muy bien, buena pregunta 00:04:07
Entonces la pregunta es, ¿este quién es? 00:04:09
Y lo puedo, una vez que 00:04:11
sepa lo que es, lo puedo usar para algo, pues seguramente 00:04:13
lo puedo usar para algo 00:04:15
ya que está, lo puedo usar para algo. Pues ese, ¿quién es? 00:04:16
Ese es 00:04:20
el objeto 00:04:20
el objeto, o sea, más que el objeto es 00:04:22
información sobre 00:04:24
el evento y el objeto 00:04:27
que recibió ese evento, es una información 00:04:29
que se empaqueta ahí, es decir 00:04:31
nosotros tenemos 00:04:33
esta 00:04:35
aplicación de aquí, vale 00:04:35
bueno, pues que está ocurriendo 00:04:41
cuando le damos 00:04:49
a este botón, cuando yo hago click 00:04:50
en este botón 00:04:52
estoy forzando 00:04:53
que aparezca un evento, es lo que estoy forzando yo 00:04:56
desde fuera 00:04:58
es decir, no se está ejecutando ninguna sentencia 00:04:59
de código ni nada, o sea, soy yo la que 00:05:02
desde fuera estoy haciendo que pase 00:05:04
algo, vale 00:05:06
eso, hay un objeto 00:05:07
de una clase capturadora 00:05:10
que está ahí pendiente 00:05:12
de si eso ocurre 00:05:14
bueno, y ese objeto 00:05:15
recibe información 00:05:18
sobre qué tipo de evento 00:05:20
fue y qué botón fue el causante 00:05:22
mediante 00:05:25
este objeto 00:05:26
de aquí, luego 00:05:28
cuando 00:05:30
yo hago clic ahí 00:05:31
yo hago clic ahí 00:05:34
la máquina virtual genera un objeto 00:05:35
ActionEvent, lo genera ella solita 00:05:38
un objeto ActionEvent lo genera 00:05:40
y en ese objeto ActionEvent 00:05:42
mete dentro 00:05:45
información varia 00:05:46
la más importante por ejemplo 00:05:48
es cuál de los componentes que hay 00:05:50
es el que ha recibido la interfaz 00:05:52
luego ActionEvent es un objeto que genera 00:05:54
la máquina virtual cuando yo hago ese clic 00:05:56
¿vale? 00:05:58
es un objeto que genera la máquina virtual 00:05:59
cuando yo hago ese clic 00:06:02
ese objeto tiene 00:06:06
dentro información varia 00:06:08
sobre el evento que ha ocurrido 00:06:10
entre ellas la más importante 00:06:13
es que componente fue el que recibió 00:06:14
ese evento 00:06:17
vale, pues entonces cuando 00:06:19
yo he hecho clic ahí 00:06:20
cuando yo he hecho clic ahí 00:06:22
este objeto 00:06:26
este objeto action event 00:06:30
Se ha generado 00:06:32
Y ha llegado aquí dentro 00:06:34
Ha llegado ahí 00:06:35
Y tiene información que yo puedo usar 00:06:36
Por ejemplo, ¿qué información puedo usar? 00:06:39
Pues hombre, la que me ofrezca 00:06:43
A través de los métodos 00:06:44
Yo aquí ya puedo cotillear 00:06:45
Y ya a partir de aquí investigar y usarla 00:06:47
Para hacer todas las virguerías que yo quiera 00:06:50
Pero por ejemplo 00:06:52
Tiene un método, si uno mira los métodos que tiene 00:06:53
Que tampoco son tantos 00:06:56
Porque luego tiene variables estáticas 00:06:57
Tiene uno, por ejemplo, tiene 00:06:59
¿Cuándo? Este 00:07:03
te saca exactamente el tiempo, 00:07:05
el momento, el instante de reloj 00:07:07
de la máquina, del reloj de la CPU 00:07:09
en el que tú hiciste el click. 00:07:11
Pues quién sabe si puedes 00:07:14
a lo mejor esa información. 00:07:15
Y tiene 00:07:18
esta, que esta 00:07:19
sí que le podemos sacar partido. 00:07:21
Ese método te saca 00:07:23
el objeto componente que recibió 00:07:24
ese evento. Te lo saca. 00:07:27
Por si tú quieres usar eso para algo. 00:07:29
Por ejemplo, si yo 00:07:31
Imaginaos que yo modifico este método 00:07:33
Y digo 00:07:37
Voy a coger el objeto 00:07:38
Que me generó el evento 00:07:47
.getSource 00:07:51
A ver, yo sé que va a ser un botón 00:07:53
Yo sé que va a ser un botón 00:07:55
Luego nos vamos a hacer el casting 00:07:57
Al botón 00:07:59
Sin miedo 00:08:03
Porque va a ser un botón 00:08:06
si no lo fuera este casting me daría 00:08:07
una cosa un poco rara, pero bueno 00:08:11
vale 00:08:13
vale, pues que tengo en esta 00:08:15
referencia, en esta referencia tengo 00:08:18
el botón que ha recibido 00:08:19
el evento, vamos a mostrar de hecho 00:08:22
información sobre el 00:08:24
botón, se ha 00:08:25
pulsado 00:08:31
el botón 00:08:32
y vamos a poner ahí 00:08:36
botón punto 00:08:41
pues a ver 00:08:44
¿qué métodos tengo de JButton que me puedan 00:08:47
interesar para sacar información? 00:08:49
pues seguro que tenga un GetTest 00:08:51
mira, tengo un GetTest que seguramente 00:08:53
me saque el texto que yo he escrito 00:08:55
sobre el botón, tiene pinta que por el nombre 00:08:57
el GetTest me saca el texto 00:08:59
que yo he escrito sobre el botón 00:09:01
bueno, vamos a añadir este código 00:09:02
a este método de aquí 00:09:04
entonces cuando yo pulse el botón de 00:09:06
dólares a euros, cuando yo lo pulse 00:09:08
cuando yo pulse ese botón 00:09:10
se va a generar un objeto ActionEvent 00:09:12
ese objeto de acción event va a llegar aquí 00:09:14
y que estoy haciendo yo con ese objeto 00:09:17
de acción event, estoy sacando 00:09:19
el componente 00:09:20
que generó el evento y estoy 00:09:23
mostrando por consola el texto de ese 00:09:24
componente, vamos a ver 00:09:27
si realmente 00:09:28
me lo hace 00:09:29
entonces yo hago esto 00:09:32
y, ah bueno es que 00:09:34
no he puesto aquí 00:09:37
voy a limpiarla 00:09:37
no he puesto aquí un numerito con lo cual me sale 00:09:39
la excepción, tres no sé cuantos 00:09:42
veis, me sale 00:09:44
aquí, efectivamente 00:09:47
se ha pulsado este botón 00:09:48
se ha pulsado ese botón 00:09:50
¿vale? 00:09:52
que le vuelvo a dar 00:09:55
entonces, conclusión 00:09:56
este objeto E 00:10:01
es un objeto útil para algunas 00:10:05
cosas, sabiendo lo que es 00:10:08
uno ya puede en algún momento 00:10:10
decidir si le es útil para algo, que ahora no lo es 00:10:12
pero insisto 00:10:14
ahora ya tiene que estar claro a partir de ahora lo que es ese objeto 00:10:16
un objeto que crea la máquina virtual cuando generamos un evento 00:10:19
y tiene información sobre 00:10:23
lo asociado a ese evento 00:10:25
en qué momento ocurrió, sobre qué objeto 00:10:28
se realizó 00:10:32
bueno, pues entonces 00:10:33
bueno, a ver 00:10:34
te refieres que haga el casting aquí directamente, sí, lo que pasa es que yo voy 00:10:41
Haciendo las cosas muy lentamente 00:10:45
Pues para que vaya quedado todo muy claro 00:10:47
Pero si me da igual, cojo el objeto 00:10:48
Le hago un casting a JButton y pongo aquí JButton 00:10:50
¿Vale? 00:10:53
¿Vale? O sea en una línea en lugar de en dos 00:10:58
Pero bueno, es lo mismo 00:11:00
Este objeto le hago el casting y lo guardo ya en una referencia 00:11:01
A JButton directamente, como guste más 00:11:04
¿Vale? 00:11:06
No sé si te referías a esto 00:11:09
Vale 00:11:10
Vale, pues entonces, ¿para qué nos puede servir 00:11:11
Esto a nosotros ahora? Pues yo antes he dicho 00:11:14
Uy, yo tengo en mi interfaz dos botones. 00:11:16
Los dos pueden recibir eventos. 00:11:25
¿Me hago una clase interna por cada botón? 00:11:27
Pues a lo mejor podemos decidir. 00:11:30
Me voy a hacer una única clase interna. 00:11:32
Y esa clase interna que distinga cuál de los dos botones recibió el evento. 00:11:34
Y en función de eso ponga el factor de conversión a uno o a otro. 00:11:39
Y ya está. 00:11:43
Y entonces me queda una única clase interna. 00:11:44
porque fijaos aquí, la diferencia 00:11:46
entre el método de esta clase interna 00:11:47
y el método de esta otra, los dos hacen lo mismo 00:11:50
la única diferencia es este numerito 00:11:52
entonces estamos haciendo dos clases internas 00:11:54
enterita, cuando lo único 00:11:56
que cambia dentro del código, lo único que cambia 00:11:58
es este número 00:12:00
entonces vamos a hacernos una única clase interna 00:12:01
que esa clase interna distinga 00:12:04
que botón es el que fue pulsado 00:12:05
y ponga ese factor de conversión como le interese 00:12:07
y hombre, queda mucho mejor 00:12:10
Es decir, vamos a comentar estas dos clases internas 00:12:12
Y vamos a hacer una única clase interna 00:12:17
Que aglutine a las dos 00:12:20
Pues venga, class, captura, evento, botones 00:12:22
De los dos 00:12:32
Implement, actionListener 00:12:33
Vale, al implementar actionListener 00:12:48
Tiene que implementar este método 00:12:49
¡Hala! Pues ya está 00:12:51
ahora, aquí sabemos que lo que 00:12:54
tenemos que hacer es esta línea 00:12:56
simplemente, esto es lo único que hay que hacer aquí 00:12:58
esto 00:13:00
eso es lo único que hay que hacer aquí 00:13:01
pero claro, esto o es 00:13:07
1,07 o es otra cosa 00:13:09
vamos a poner una variable 00:13:11
factor 00:13:12
conversión, por ejemplo 00:13:14
y ahora esta variable 00:13:17
factor conversión 00:13:24
la que o es 1,07 00:13:32
o este era el 93 en función 00:13:35
de si este evento 00:13:38
procede de uno de los botones o del otro 00:13:39
¿vale? pues entonces 00:13:41
en una única clase interna 00:13:43
tengo ya 00:13:45
la clase que captura 00:13:47
para los dos botones igual 00:13:49
¿vale? pues esto como lo podríamos 00:13:51
hacer, por ejemplo, vamos a coger aquí el botón 00:13:53
que 00:13:56
ha capturado el evento 00:13:57
¿vale? ese es el botón que capturó 00:13:59
el evento, entonces aquí 00:14:10
podríamos hacer 00:14:12
o este botón 00:14:14
resulta 00:14:17
que es igual 00:14:18
a mi botón 00:14:20
¿cómo se llaman? 00:14:24
a mi botón dólares tu euros 00:14:25
entonces 00:14:27
que 00:14:37
que factor de conversión 00:14:39
aplicamos 00:14:41
pues para convertir de dólares 00:14:42
a euros 0.93 00:14:45
vamos a declarar 00:14:47
el factor de conversión, claro 00:14:51
Y si no, es que será el otro 00:14:52
Ah, que lo he declarado como indesdable 00:15:03
1,07 00:15:17
Creo que era, bueno, da igual 00:15:26
Ala, pues una única clase interna 00:15:27
Tengo un error por ahí de compilación 00:15:34
Ya lo buscaremos 00:15:36
Ah, claro, listo, vale, ya está 00:15:37
Entonces, esto es una única clase interna 00:15:40
Que hace este código 00:15:42
Y lo hace aplicando 00:15:44
Un factor de conversión 00:15:46
0,93 o 1,07 00:15:47
En función de el botón 00:15:50
que recibió ese evento 00:15:52
entonces me ahorro 00:15:55
hacer las dos clases gracias al objeto 00:15:57
E, entonces ese objeto E es un objeto 00:16:00
E que podemos usar si nos interesa 00:16:01
en algún momento, si nos interesa 00:16:03
vale 00:16:05
ahora que ocurre, que ahora 00:16:07
a los dos botones 00:16:09
hay que darle un objeto 00:16:10
de esta misma clase 00:16:13
porque esta clase 00:16:15
tiene que estar pendiente de los dos 00:16:18
de los dos 00:16:19
Ahora los dos botones 00:16:21
Hay que darle un objeto de esta 00:16:23
Entonces ahora 00:16:25
Esto de aquí en lugar de 00:16:26
Darle a cada uno la suya 00:16:29
En lugar de darle a cada uno 00:16:32
La suya pues 00:16:37
A los dos 00:16:38
Le daremos la misma 00:16:43
A dólares tu euros 00:16:44
Le daremos este 00:16:46
Y a este también le daremos este 00:16:49
Vale 00:17:00
A los dos 00:17:02
Los dos botones van a ser escuchados 00:17:03
Por la misma clase 00:17:05
Los dos botones por la misma 00:17:06
De hecho 00:17:09
En lugar de crear dos instancias con dos referencias 00:17:10
Pues uno podría hacer aquí 00:17:13
Una única instancia afuera y pasarle la instancia 00:17:15
Esto ya 00:17:17
Pues va en gustos 00:17:18
Hombre, siempre sería dentro de que 00:17:21
Bueno, tampoco es tan crítico 00:17:27
Un pelín más 00:17:28
Eficiente esto porque hay solo una única 00:17:30
Referencia 00:17:34
vale, yo me creo un objeto 00:17:35
de este tipo 00:17:42
y le paso ese objeto 00:17:43
a los dos, como lo queráis 00:17:46
hacer, da un poco igual 00:17:51
vale, pues ese es el 00:17:52
significado de este objeto 00:18:10
guarda información sobre el evento 00:18:11
que se ha desencadenado 00:18:13
y que ha hecho que lleguemos aquí 00:18:15
que queremos usar información sobre ese evento 00:18:17
estupendo, la usamos 00:18:21
nos puede ser útil 00:18:23
efectivamente para en un mismo action performance 00:18:25
en un mismo método de Action Performance 00:18:27
meter código de respuesta a diferentes componentes 00:18:29
yo meto ahí código de respuesta 00:18:32
a diferentes 00:18:34
y distingo a través de 00:18:34
qué componente fue el que generó el evento 00:18:37
y en función del componente que sea 00:18:40
yo ya dentro de la Action Performance 00:18:42
pues me hago, me puedo hacer un switch case 00:18:43
si el componente fue este case 00:18:46
hago este código de respuesta 00:18:48
que el componente que generó el evento 00:18:49
fue este otro, hago este otro código de respuesta 00:18:51
¿vale? 00:18:54
Y con las otras 00:18:55
Interfaces 00:19:06
MouseListener, KeyListener 00:19:07
Que hemos mencionado 00:19:10
También pasa lo mismo 00:19:11
Por ejemplo, en el primer ejemplo 00:19:12
El primer ejemplo que estuvimos 00:19:15
Viendo el otro día, que hicimos lo del 00:19:18
Ratón, ¿no? 00:19:20
Captura, pulsar botón 00:19:26
Pues aquí capturábamos el evento de que el 00:19:27
Ratón, no, captura, pulsar 00:19:30
Botón, este no era 00:19:32
Este tampoco, vista 3 00:19:33
Este, en el ejemplo 00:19:45
lo que hicimos ayer, que decidimos 00:19:52
que el evento que nos interesaba sobre el botón 00:19:54
es que el ratón pasara. 00:19:56
Pues entonces, como el 00:19:59
evento no es el por defecto de un botón, 00:20:00
no era el por defecto, sino era el evento 00:20:02
pasar ratón por encima, que no es el por defecto, 00:20:04
ese evento no lo podíamos capturar con el 00:20:06
ActionListener. Entonces, para eso 00:20:08
hicimos un MouseListener. 00:20:10
Hicimos un MouseListener 00:20:13
que me implica sobreescribir 00:20:14
métodos. Entonces, como el evento 00:20:16
que nos interesaba era 00:20:18
este, entrar en la zona 00:20:19
del botón, era entrar, pues 00:20:22
este fue al que le pusimos código, los demás 00:20:24
lo dejamos vacío 00:20:26
bueno, pues aquí tenemos mouseEvent 00:20:27
es lo mismo 00:20:29
mouseEvent es un objeto 00:20:31
que tiene información 00:20:33
sobre el evento 00:20:36
que ha hecho que lleguemos a este método 00:20:37
y lo mismo, pues la saca 00:20:40
el objeto que generó 00:20:42
sobre el que se hizo ese evento, el momento en el que se hizo 00:20:44
etcétera, mouseEvent es como si fuera 00:20:46
acción event 00:20:48
que capturamos un key listener 00:20:49
porque queremos eventos que se hacen 00:20:53
con las teclas que no son 00:20:56
por defecto, pues tendrá 00:20:57
un key event, bueno eso ya 00:21:00
nos irán apareciendo 00:21:02
o sea, tendremos que ir usando 00:21:06
capturadoras de esos 00:21:07
bueno, pues eso en cuanto a ese 00:21:09
primer ejercicio 00:21:12
¿dónde está el resto? 00:21:14
vale 00:21:38
El 2, ¿quién no lo ha hecho? 00:21:38
¿Lo has hecho, Andoni? 00:21:44
Pues a la pizarra hacerlo 00:21:45
Entonces, ¿por qué no has levantado la mano? 00:21:47
He preguntado quién no lo ha hecho 00:21:49
Levantarla con alegría, hombre 00:21:51
Que no pasa nada, si no os voy a matar 00:21:53
Nada de eso 00:21:55
El 3, ¿quién no lo ha hecho? 00:21:57
Y el 4, ¿quién no lo ha hecho? 00:22:08
Bueno, o sea que 00:22:19
Os quedan cositas por hacer 00:22:20
¿Quién los ha hecho todos? 00:22:22
Pues eso iba a decir 00:22:28
¿Quién ha hecho los cuatro primeros? 00:22:29
Aparte de Miguel 00:22:32
Dije los cuatro primeros, juraría 00:22:33
Claro 00:22:38
Pero vamos, tanto el Combo 2 como todos 00:22:41
El resto de componentes, ya la idea es 00:22:43
Que uno ya los puede ir investigando 00:22:45
Pero mi pregunta es, bueno, quien no haya hecho los cuatro primeros 00:22:47
O sea, perdón 00:22:50
Quien los haya hecho, efectivamente 00:22:51
Que siga con los demás 00:22:52
En el cuarto hay que investigar el combo box 00:22:55
En el 00:22:57
En el quinto, perdón, en el sexto 00:22:58
Hay que investigar la ventana 00:23:01
Que te permite 00:23:03
Elegir ficheros 00:23:04
Este es para un mouse listener 00:23:06
Y esto ya 00:23:09
Los siguientes ya es 00:23:12
Hacer aplicaciones 00:23:15
Ya que gestionen cosas grandes 00:23:17
Pero claro, en la 8, la 9 y la 10 00:23:19
El problema que tenemos es que hay que meter muchos componentes 00:23:21
Entonces, o estudiamos gestores de ubicación en detalle 00:23:24
Que no quiero que pasemos tiempo en eso 00:23:27
O ya tenemos que usar un plugin patatero 00:23:30
Como es el builder, que es una patata 00:23:32
Pero bueno, patatero para poner cositas 00:23:33
Entonces, para el 8, el 9 y el 10 00:23:36
Ya la idea es usar el builder 00:23:38
Pues para no andar ahí con estos componentes todos en fila 00:23:41
Pues venga, acabad los cuatro primeros 00:23:45
El que no lo haya acabado 00:23:47
y tú contigo 00:23:48
con el tuyo y luego vas a hacer 00:23:50
venga, por rápido 00:23:52
el siguiente que tenga los cuatro primeros hechos 00:24:05
te lo diste y 00:24:07
se lo crees 00:24:09
efectivamente 00:24:10
se va a hacer 00:24:12
muy buenas 00:24:15
que para eso ya lo tengo 00:24:17
ahí 00:24:19
Gracias. 00:24:19
Muy bonita y hermosa la comunicación 00:24:49
Pero de verdad que 00:24:53
Eso va a hacer unidades en la vida 00:24:55
Viendo medios de hambre bajo un puente 00:24:56
Y eso solo pasa porque 00:24:59
¿Quién va a ser político? 00:25:01
Tú 00:25:06
Pues ya te estás yendo a la academia 00:25:06
A prepararte, a matricularte 00:25:14
No, no, cállate 00:25:16
Perdón 00:25:16
que... ¡Uy! Esto es 00:25:45
ella. 00:25:47
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
9
Fecha:
6 de mayo de 2024 - 19:33
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
25′ 48″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
114.54 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid