Saltar navegación

Activa JavaScript para disfrutar de los vídeos de la Mediateca.

Clase 16 -10-23 - 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 16 de octubre de 2023 por Raquel G.

5 visualizaciones

Más información Transcripción

Descargar la transcripción

Vale, pues vamos a incorporar, vamos a incorporar, silencio, María, vamos a incorporar más, Moisés y María, por favor, necesito que estéis callados cuando estoy hablando, vale, vosotros y por supuesto los demás, vale. 00:00:02
bueno pues vamos a incorporar más posibilidades que la sintaxis de Java nos brinda para tomar decisiones 00:00:30
para que nuestro código siga por un camino u otro en función de la condición 00:00:42
conocemos la básica que es la sentencia if que en realidad es la única imprescindible 00:00:46
sabemos en diagrama de control de flujo 00:00:54
como se expresa, importante que no perdáis 00:00:58
esas herramientas gráficas 00:01:00
el saber que existen e interpretarlas cuando las veáis 00:01:02
¿vale? 00:01:06
importante no olvidar eso 00:01:13
cuando uno expresa un algoritmo 00:01:14
en un diagrama de flujo, cuando uno lo expresa 00:01:17
ya lo mencionamos, lo que tiene es un gráfico 00:01:20
en el que va saliendo la secuencia de lo que el programa va haciendo. 00:01:23
Si son asignaciones sin más, pues nada, cuadraditos con asigna, lee, asigna, lee, una tras otra. 00:01:27
Desde el momento en que aparece una decisión, que ya es algo nuevo que hemos incorporado, 00:01:33
que aparece ya una decisión, ya vemos que automáticamente nuestro diagrama de control de flujo, 00:01:37
pues ya aparece algo así. 00:01:45
¿Vale? Y el programa ya pues continúa por aquí 00:01:50
¿Vale? Y aquí se hace todo, todo lo que se quiera hacer en la rama del sí 00:02:08
Y aquí se hace todo lo que se quiera hacer en la rama del no 00:02:22
Aquí puede haber un montón de sentencias tropecientas una tras otra 00:02:25
Y aquí puede haber un montón de sentencias tropecientas una tras otra 00:02:28
¿Vale? Y esta es la sentencia if 00:02:32
La sentencia if es esta, que es una única sentencia compleja 00:02:35
Una única sentencia compleja 00:02:39
Porque puede tener más dentro 00:02:41
Aquí puede haber tropecientas 00:02:42
Y aquí puede haber tropecientas 00:02:45
Una tras otra, es una única sentencia compleja 00:02:47
¿Vale? 00:02:49
Que estará dentro 00:02:50
Del flujo de nuestro programa 00:02:52
Vendrá a continuación de la sentencia 00:02:54
Que haya por aquí 00:02:57
Y después se harán más sentencias por aquí 00:02:57
¿Vale? 00:03:00
Entonces, esta sentencia en Java 00:03:02
Ya sabemos cómo se programa 00:03:04
If condición, lo que yo hago en la rama del sí 00:03:05
Que en la rama del no 00:03:08
No quiero hacer nada 00:03:10
Ni pongo else ni nada, se acabó la sentencia 00:03:11
Continuamos por abajo 00:03:14
En la rama del no, si quiero hacer algo también 00:03:15
Pues else, abro entre llaves 00:03:18
Lo que quiero hacer en la rama del no 00:03:20
Cuando eso ha terminado, se acabó la sentencia, sigo por abajo 00:03:21
Cuando en el else anidamos más if 00:03:24
Cuando en el else anidamos más if 00:03:28
Esa sentencia se convertía en un if 00:03:30
Lo que sea else 00:03:34
if lo que sea, else if lo que sea, eso se podía hacer muy complejo 00:03:35
pues podíamos usar la sentencia if, else if, else if, else if 00:03:40
que la simplificaba, ¿vale? esa sentencia la usábamos 00:03:43
cuando yo tengo varios caminos excluyentes 00:03:47
posibles, varios caminos excluyentes, o tiro por este 00:03:51
o tiro por este, o tiro por este, varios excluyentes, cada uno de ellos asociados a una condición 00:03:55
entonces uno identifica en su código, que el código 00:04:00
puede hacer una de varias 00:04:03
cosas, pero solo una de ellas, excluyentes 00:04:05
entre sí, una de varias 00:04:07
vale, pues entonces se identifica, vale, un if, el se, if 00:04:09
estupendo, lo identifica 00:04:13
ahora ya, lo que tiene que buscar es 00:04:15
la condición que fija 00:04:19
cuando me voy por cada 00:04:21
camino excluyente, pongo 00:04:23
cada una de esas condiciones en if, el se, if 00:04:25
el se, if, el se, if, listo 00:04:27
vale 00:04:29
bueno, pues hay otra 00:04:30
posibilidad de sintaxis 00:04:33
que nos da Java para simplificar 00:04:35
también una situación concreta 00:04:37
y es, cuando yo tengo una variable 00:04:38
y en función del valor de esa variable 00:04:41
si es este, o si es este otro 00:04:43
o si es este otro, o si es este otro, alguna cosa u otra 00:04:45
eso en Java 00:04:47
se haría de la siguiente manera, ¿no? 00:04:49
con la sentencia i lo sabemos hacer perfectamente 00:04:51
vale 00:04:53
vamos a poner, por ejemplo 00:04:55
vale, vamos a hacer una clase 00:04:57
en la que llamamos ejemplo case 00:05:33
por ejemplo 00:05:35
vale, pues vamos a imaginarnos 00:05:36
uff, esto no quería hacerlo yo 00:05:42
vamos a imaginarnos 00:05:44
por ejemplo, que tenemos aquí que hacer 00:05:50
la parte de un código que hace algo muy sencillo 00:05:52
simplemente la idea es 00:05:54
imprimir un boletín de notas 00:05:56
por ejemplo, imprimir un boletín de notas 00:05:58
para ello 00:06:00
Va a recibir una nota numérica 00:06:01
Y en función de esa nota numérica 00:06:06
En el boletín tiene que imprimir 00:06:09
Pues su insuficiente, suficiente, aprobado, notable 00:06:10
O sobresaliente o matrícula, por ejemplo 00:06:14
¿Vale? 00:06:16
Entonces ese programa tiene 00:06:18
Entrada, nota numérica 00:06:20
Salida, lo que imprime 00:06:21
En nuestro caso por pantalla 00:06:23
Porque no sabemos imprimirlo en otro sitio 00:06:25
A través de Java 00:06:27
En otro documento, en una impresora 00:06:27
A través de Java no sabemos hacerlo 00:06:30
Bueno, por pantalla, vale, que lo imprima por pantalla 00:06:31
Entonces, ese programa uno lo lee, lo analiza, lo estudia y dice 00:06:34
Vale, dato de entrada, nota 00:06:38
Posibilidades de salida 00:06:39
Muchas 00:06:41
O mostrar insuficiente, o mostrar suficiente, o mostrar bien 00:06:43
O mostrar aprobado, o mostrar, o sea, muchos caminos, vale 00:06:48
Primer punto importante que identificamos 00:06:51
Mi programa tiene varias posibilidades excluyentes 00:06:54
O va por aquí, que es imprime insuficiente 00:06:58
O va por aquí, o va por aquí, o va por aquí 00:07:01
¿Vale? Esa es la primera parte 00:07:03
Esa es la primera parte que elaboramos 00:07:05
Y es importantísima para poder elaborar 00:07:07
Nuestro algoritmo, bueno, diferentes caminos 00:07:09
Que se excluyen entre sí 00:07:11
¿Vale? Una vez que ya tenemos 00:07:13
Identificado eso, que son diferentes 00:07:15
Caminos que se excluyen entre sí 00:07:17
Pues ahora ya empezamos a perfilar eso 00:07:18
¿Vale? ¿Cuál es la condición 00:07:21
Para cada uno? Bueno, pues 00:07:22
En este caso la condición es fácil de encontrar 00:07:25
Pues que la nota sea menor que 5 y mayor que 0 00:07:27
Pues insuficiente 00:07:32
Que la nota sea 5, aprobado 00:07:33
Que la nota sea 6, entonces ahí a encontrar las condiciones es fácil 00:07:36
Bueno, pues ahí ya tendríamos nuestro programa, ¿no? 00:07:39
Pues venga, vamos a ponerlo aquí, por ejemplo 00:07:42
A ver cómo nos quedaría 00:07:45
Entonces 00:07:47
Programa que imprime la nota literal 00:07:49
En función de la nota numérica 00:07:55
¿Vale? 00:08:06
O sea, con un enunciado así 00:08:12
Bueno, yo lo he puesto para resumir 00:08:13
Pero este enunciado tendría que estar mejor detallado 00:08:15
¿No? 00:08:18
La nota de entrada, ¿qué va a ser? 00:08:19
¿Entera o decimal? 00:08:21
¿Vale? 00:08:22
¿Cuáles van a ser los literales que consideras? 00:08:23
¿Cuáles son los márgenes? 00:08:25
¿Vale? 00:08:26
Es siempre importantísimo 00:08:27
Que un problema que nos plantean 00:08:28
Esté bien claro lo que tiene que hacer 00:08:29
porque si algo no está claro 00:08:32
y lo damos nosotros por supuesto 00:08:35
a lo mejor la solución que hacemos está mal 00:08:37
entonces siempre 00:08:39
punto A clave, que lo que nos piden 00:08:40
es entender exactamente que quieren que hagamos 00:08:43
y si hay algún fleco suelto 00:08:45
uno va y le pregunta 00:08:46
al jefe, al cliente, a quien sea 00:08:48
nunca puede haber ningún fleco suelto 00:08:51
¿vale? 00:08:52
eso es tarea de análisis 00:08:54
bueno, en nuestro caso pues 00:08:56
vamos a usar las notas literales 00:08:59
Que conocemos de toda la vida y ya está 00:09:01
Bueno, cuando ya está ese punto clarísimo 00:09:03
Que esperan de nosotros 00:09:06
Ahora ya empezamos a perfilar nuestro programa 00:09:07
La primera parte 00:09:10
Que siempre abordamos 00:09:12
A ver, ¿cuál es mi información de entrada? 00:09:13
Pues 00:09:16
La nota numérica, no necesito más datos de entrada 00:09:17
Nota numérica, como ya he hablado yo 00:09:20
Con el cliente y me ha dicho es un número entero 00:09:22
Pues bueno, pues venga 00:09:24
Ala 00:09:26
Declaramos esto 00:09:27
Para que tenga el dato de entrada 00:09:29
Ahí va a ir la nota numérica 00:09:31
Sabemos que tenemos que leerla, etc. 00:09:33
Pero no empezamos a escribir directamente 00:09:36
Todo en línea, papapapapa, el chorizo 00:09:40
Bueno, si es un programa sencillo, que es que ya no sale de corrido, sí 00:09:42
Pero nunca programamos así, lo he dicho mil veces 00:09:45
No programamos, a la vez voy a escribir de corrido, no 00:09:47
Hacemos una primera estructura de cómo va a ser mi programa 00:09:49
Bueno, pues esa nota, este programa 00:09:53
Ya hemos dicho que tendrá varios caminos excluyentes 00:09:56
Cada uno asociado a una condición 00:09:58
Según eso, nosotros ya tenemos en la cabeza 00:10:01
Ah, pues mira, un if, el seif 00:10:04
Porque mi programa va a hacer varias cosas 00:10:06
Que se excluyen entre sí 00:10:08
En función de una condición 00:10:09
Bueno, pues esa tiene toda la pinta 00:10:11
De que mi programa va a ser algo así 00:10:14
Y así, bueno, todos los 00:10:15
Todas las 00:10:27
Un segundín 00:10:28
Así todas las condiciones que fueran 00:10:30
Hasta el else, etc 00:10:34
¿Vale? 00:10:35
Esa podría ser 00:10:37
Sí 00:10:37
A ver, dime María 00:10:39
Claro, porque solo hay una sentencia 00:10:48
Recordad que la diferencia 00:10:58
Entre poner llaves o no poner llaves 00:11:01
Es si hay solo una sentencia 00:11:02
En esa rama o hay varias 00:11:04
Si hay varias es obligatorio 00:11:06
Porque si no pones llaves 00:11:07
Entonces la máquina virtual cuando ejecuta eso 00:11:10
Interpreta que es la primera solo 00:11:12
Solo la primera 00:11:14
Y que el resto ya quedan fuera de la rama 00:11:16
Entonces, llaves si hay más de una 00:11:17
Obligatorio, si hay solo una 00:11:20
Si quieres sí, si no, no 00:11:21
entonces como yo en principio estoy planteando en mi programa 00:11:22
y no sé si va a haber muchas sentencias o solo una 00:11:25
yo sé que ahí va a haber un agujero negro 00:11:27
que ya llenaré 00:11:30
vale 00:11:30
pues esa es la arquitectura y programa 00:11:31
uy aquí, obviamente tendría que poner las condiciones 00:11:35
que fueran 00:11:37
bueno pues 00:11:38
yo sigo pensando 00:11:41
vale, que tiene que hacer en cada una de las ramas 00:11:42
pues en una de ellas 00:11:46
tendrá que mostrar 00:11:47
insuficiente 00:11:49
Ese es uno de los posibles resultados. ¿Cuál es otro de los posibles resultados? Otro de los posibles resultados excluyente del anterior es este. 00:11:51
Otro de los posibles resultados excluyente del anterior 00:12:06
Vamos a poner otros dos más solo 00:12:12
Es este 00:12:16
Otro de los resultados excluyente del anterior 00:12:17
Pues sería notable y sobresaliente 00:12:22
Ya está, y lo dejamos así 00:12:26
Sería este 00:12:27
Vale, hemos identificado que son caminos que se excluyen 00:12:29
O va por uno o va por otro 00:12:44
La nota no puede ser simultáneamente notable y aprobado 00:12:45
A ver, vamos a bajar esa persiana 00:12:49
Vale, mejor 00:13:03
Vale, son caminos excluyentes, cada uno en su rama 00:13:20
Sigo, sigo iterando hasta conseguir la formulación completa de mi código 00:13:24
Cada uno va a depender de una condición, vale, pues ahora ya pensamos en la condición 00:13:29
La condición siempre va a depender de los datos de entrada 00:13:33
un programa irá por un lado o irá por otro 00:13:36
en función de los datos de entrada 00:13:40
que son los que cambian en cada ejecución 00:13:41
en cada ejecución 00:13:43
el programa tiene los datos de entrada distintos 00:13:45
por eso en cada ejecución el programa o va por un lado 00:13:48
o va por otro 00:13:50
porque los datos de entrada son distintos en cada ejecución 00:13:51
en este caso el dato de entrada 00:13:53
solo uno nota el dato de entrada 00:13:55
tendremos que leerlo 00:13:57
venga pues nada, incorporamos la lectura 00:13:58
del dato de entrada 00:14:02
leemos el dato de entrada 00:14:02
uy, ahí está leído, vale 00:14:12
y ahora ya que tenemos el dato del cual depende la condición 00:14:25
podrían ser muchos, ahora ya empezamos a elaborar la condición 00:14:30
con las herramientas que tenemos, que son los operadores 00:14:34
relacionales, booleanos, todos, vale, pues cuando me iré por el camino 00:14:37
insuficiente, cuando la nota esté comprendida entre 0 y 5 00:14:42
sin incluir el 5, bueno, pues eso que decimos en lenguaje natural, estar comprendido 00:14:44
entre 0 y 5, ahora es lo que 00:14:50
trasladamos al lenguaje Java 00:14:51
pues como podemos poner este argumento 00:14:53
entre 0 y 5, pues ser simultáneamente 00:14:56
mayor que 0 y menor que 5 00:14:58
bueno, pues eso ya 00:15:00
lo podemos poner directamente en Java 00:15:02
y sería, si la nota 00:15:04
es mayor o igual que 0 00:15:06
la nota simultáneamente 00:15:08
además a ser mayor o igual que 0 00:15:12
es menor que 5, esto 00:15:14
vale, la simultaneidad de las dos 00:15:15
cosas. Si se dan las dos simultáneamente, entonces está comprendido en ese intervalo. 00:15:18
Vale. Bueno, y así elaboramos las condiciones para el resto. Suficiente, pues que la nota 00:15:26
sea, como estamos hablando de notas enteras, no con decimales, pues suficiente, bueno, 00:15:35
es que distinguido suficiente aprobado es un poco, quería poner bien en realidad. 00:15:42
que el bien de toda la vida era el 6, vale, suficiente, pues como anotas en este caso es entera, solamente que sea 5, no hay otra, 00:15:48
si fuera decimal podría poner que sea mayor o igual que 5 y menor que 6, porque eso comprendería muchos valores decimales, 00:15:57
en este caso como es entera solo hay una posibilidad, que sea 5, bueno, pues la condición de ser 5 la pongo de forma sencilla, 00:16:05
Vale, aquí la condición de ser bien 00:16:14
Puede ser 6 00:16:20
También es sencilla 00:16:21
Notable, pues 7 y 8 00:16:24
La puedo poner, pues ser igual a 6 00:16:27
O ser igual a 7 00:16:30
Perdón, ser igual a 7 o ser igual a 8, por ejemplo 00:16:32
Aquí es un or 00:16:36
La nota es igual a 7 00:16:41
O una cualquiera de las dos 00:16:43
O la nota es igual a 8 00:16:45
O una o la otra. O una o la otra. Bueno, pues si se da cualquiera de las dos, esto no es simultáneo, obviamente, es el or. O una o la otra, pues es notable. Y sobresaliente, pues si es nueve o diez. 00:16:48
me quedaría, y si no es ninguna 00:17:07
de ellas, porque mi sentencia 00:17:23
if else if, admite 00:17:24
un else si yo lo quiero, opcional 00:17:27
un else que es 00:17:29
si no se da ninguna de las anteriores 00:17:31
si no se da 00:17:33
entonces, ¿qué pasa? 00:17:34
pues en este caso, si no se da es que la nota 00:17:37
que hemos metido no es válida, pues podríamos 00:17:39
ponerlo, podríamos poner 00:17:41
nota no 00:17:42
válida 00:17:45
y ya está, ¿vale? 00:17:46
Bueno, este sería mi programa 00:17:50
He identificado varias excluyentes 00:17:51
He puesto lo que hacen cada una y ya está 00:17:54
Ahora es cuando uno 00:17:56
Entraría en la fase de pruebas 00:17:59
Y haría un 00:18:02
Barrido de pruebas lo más completo posible 00:18:04
Que en este caso sería 00:18:06
Probar una nota no válida 00:18:08
A ver si sale por aquí 00:18:10
Y ahora, probar todas y cada una del resto de las notas válidas 00:18:11
0, 1, 2, 3 00:18:15
Ese sería un 00:18:16
grupo completo de casos de prueba 00:18:17
¿vale? no hace uno una única prueba 00:18:22
en un programa, porque le puede haber salido bien 00:18:24
de casualidad, hace muchas 00:18:26
que cubran todas las posibilidades 00:18:28
de las entradas, bueno en este caso 00:18:30
como es sencillo, yo creo que no merece la pena hacer las pruebas 00:18:32
podríamos deducir que 00:18:35
hombre, a menos que hayamos hecho una 00:18:36
errata sin habernos dado cuenta, esto va a funcionar 00:18:38
vale 00:18:40
bueno 00:18:41
en relación a lo que decías tú María, en este caso 00:18:43
una vez que el programa está hecho, ya está aprobado, funciona, uno se puede plantear 00:18:46
a lo mejor, o bueno, hacer pequeños cambios en el código, que lo dejen más bonito 00:18:50
aquí al final me ha quedado una única sentencia 00:18:54
una única, entonces puedo quitar la llave 00:18:58
¿vale? podría quitarla, me da igual, lo que pasa es que si luego algo 00:19:02
cambia en mi código y le añado aquí una sentencia, tengo que poner automáticamente 00:19:06
la llave, pues si yo digo, ah vale, lo veo 00:19:10
más clarito, si la quito 00:19:14
lo veo más claro, no me molestan tanto las llaves 00:19:16
pero además de mostrar 00:19:18
insuficiente 00:19:20
quiero aquí pues 00:19:21
poner la nota 00:19:23
a cero, porque en el caso de que sea insuficiente 00:19:26
quiero resetear la nota, ponerla a cero, cualquier 00:19:28
cosa 00:19:30
pues si hago esto, ya obviamente ya me he cargado el programa 00:19:30
porque el compilador 00:19:36
me dice, vale no tienes llave 00:19:38
luego la única sentencia que va dentro 00:19:39
del if es esta, es la única sentencia que va 00:19:41
dentro del if, vale, aquí el if ya ha acabado 00:19:43
esto es un if que acabó 00:19:45
ya ha terminado, ya no hay 00:19:47
else, no hay if, ni hay nada, se acabó, vale 00:19:49
muy bien, este if terminó 00:19:51
ahora yo hago nota igual a cero, muy bien 00:19:53
y ahora me encuentro esto, y esto 00:19:55
y esto donde sale, como puede haber 00:19:57
una sentencia que empieza con ese if directamente 00:19:59
esto de donde ha salido, esto que es 00:20:01
claro, es que esto va 00:20:02
con este, va con este 00:20:05
y para ir con este 00:20:07
esto tiene que quedar muy claro 00:20:09
muy claro, que va todo en la 00:20:11
rama del if, que va todo en esa rama 00:20:13
entonces la única forma de que quede muy claro 00:20:15
que va todo en esa rama es eso 00:20:17
vale 00:20:19
bueno pues esta podría 00:20:21
ser nuestro programa y estaría bien y ya 00:20:23
está y lo entregamos, nos vamos y se 00:20:25
acabó, pero bueno 00:20:27
tenemos diferentes posibilidades sintácticas 00:20:29
en java para hacer las cosas 00:20:32
de forma que queden más claras 00:20:33
más elegantes, más bonitas para el que venga 00:20:35
detrás, que siempre va a venir uno detrás 00:20:37
a mantener ese código, siempre 00:20:39
Y entre ellas está la sentencia de decisión 00:20:40
La switch case 00:20:45
¿Vale? 00:20:46
Que a muchos os sonará 00:20:47
Bueno, pues 00:20:48
La switch case es una sentencia 00:20:50
Que en función del valor de una variable 00:20:54
Te hace una cosa o te hace otras 00:20:58
En función del valor de una variable 00:21:01
O sea, es un caso particular del if, el save 00:21:03
Porque el if, el save es el caso genérico 00:21:05
O hace esto, o hace esto, o hace esto 00:21:07
Hace esto en función de la condición, sea esa condición la que sea, una condición cualquiera, todo lo tocha que uno quiera, pero cuando esa condición es exclusivamente evaluar el valor de una variable, pues entonces podemos transformarla y expresarlo con el switch case y va a quedar más claro, el que lo vea, el ver el switch case automáticamente ve, ah vale, que esto depende del valor de una variable y eso seguramente le da información del resto del código. 00:21:09
Bueno, vamos a hacer este mismo código con el switch case 00:21:37
Entonces 00:21:40
Versión de lo anterior 00:21:41
Con la sentencia java 00:21:55
Switch case 00:21:57
¿Vale? 00:22:00
Vale 00:22:04
Sintaxis de esta sentencia 00:22:05
Sintaxis de esta sentencia 00:22:07
Sintaxis 00:22:09
Se pone el switch 00:22:11
Vale 00:22:16
Y aquí abrimos ya un, perdón 00:22:17
Se pone el switch 00:22:19
Aquí ponemos el nombre de la variable en función de la cual 00:22:20
Sea cual sea su valor, hacemos una cosa u otra 00:22:27
En nuestro caso, sería la variable nota, ¿verdad? 00:22:30
¿Vale? 00:22:38
Entonces, la sentencia empieza así 00:22:39
Switch y entre paréntesis un nombre de variable que existe en mi código 00:22:46
Un nombre de variable 00:22:54
Y las llaves 00:22:55
¿Vale? Obligatorio 00:22:57
Porque aquí dentro ya hay muchas cosas 00:23:00
Las llaves, vale 00:23:02
Pues aquí empezamos a distinguir casos 00:23:03
Eso significa, en el caso de que nota sea 00:23:06
Distinguimos un caso 00:23:08
Valor 1, el valor que yo quiera 00:23:12
Vamos a suponer, vamos a hacerlo primero sin simplificar 00:23:15
El case, el switch case original 00:23:18
Antes de que lo adaptaran 00:23:20
Pues en el caso de que la nota sea 0 00:23:21
Pues entonces yo pondría 00:23:24
Mostrar 00:23:27
Insuficiente 00:23:29
Vale 00:23:32
En el caso de que la nota sea 1 00:23:35
Vamos a hacer la primera versión 00:23:38
La que sería original 00:23:40
Pero que luego vamos a retocar 00:23:41
Para que sea una versión un poquito más compacta 00:23:44
Pero ahora estamos explicando 00:23:46
Lo que hace 00:23:47
Lo que hace es, repito 00:23:48
Palabra reservada switch 00:23:51
Entre paréntesis la variable que decide 00:23:53
Por qué camino me voy en función de su valor 00:23:56
Y ahora en un montón de case 00:23:58
Los valores 00:24:00
Que yo quiero distinguir 00:24:01
En este caso me queda un switch case 00:24:04
Con un montón de valores 00:24:06
Porque la nota puede tener un montón de 00:24:07
Posibilidades 00:24:14
¿Vale? Entonces en cada case 00:24:17
Yo contemplaría un caso 00:24:32
En el caso de que sea 0 hago esto 00:24:34
En el caso de que sea 1 hago esto 00:24:36
En el caso de que sea 2 hago esto 00:24:37
Y tengo la opción de hacer un default 00:24:39
Al final de todos los case 00:24:42
Un default 00:24:45
Seguido de dos puntitos también 00:24:48
Como los case 00:24:51
Que significa en caso de que no sea 00:24:52
Ninguno de los anteriores 00:24:53
Entonces vamos a 00:24:54
Poner primero 00:24:56
Ponerlo primero así 00:24:58
Lo suficiente 00:24:59
Con el 5 ya sería 00:25:31
Aprobado 00:25:33
Con el 6 y 7 ya sería 00:25:36
No, con el 6 sería bien 00:25:42
Con el 7 y 8 00:25:44
Sería notable 00:25:47
Y con el 9 y 10 sería sobresaliente 00:25:49
Bueno, la estructura básica es esta 00:25:58
Vamos a entenderla bien antes de retocarla 00:26:10
Para que sea un poco más operativa 00:26:13
La estructura básica es esta 00:26:15
Switch entre paréntesis 00:26:17
Un nombre de variable que existe en mi código 00:26:19
Un nombre de variable que existe en mi código 00:26:22
No hay tutía, vale 00:26:24
Y ahora cada case 00:26:25
cada case, palabra reservada case 00:26:26
yo le pongo 00:26:29
un posible valor 00:26:31
un posible valor 00:26:33
y ahora si la variable 00:26:34
tuviera ese valor, se hace lo que yo 00:26:37
diga aquí, tiene que ser una sentencia obligatoriamente 00:26:39
no, pueden ser más de una 00:26:41
dentro de cada case podría haber más de una 00:26:43
y aquí sí que no 00:26:45
hace falta que ponga llaves 00:26:47
porque ya se sabe que todo hasta el 00:26:48
siguiente case va dentro de ese 00:26:51
entonces no hace falta 00:26:53
aquí podría haber otra sentencia 00:26:54
por ejemplo en el caso 00:26:56
cero, yo no quiero que las notas 00:26:58
cero sean válidas, como poco quiero un uno 00:27:01
pues por ejemplo, si en el caso 00:27:03
cero yo quiero hacer esto también 00:27:05
insuficiente y además poner la nota 00:27:07
uno por lo que sea, pues yo pongo 00:27:09
aquí todas las entidades que quiera y en cada case 00:27:11
también, puedo poner todas las que quiera, aquí ya 00:27:13
sí que no hace falta, no es 00:27:15
necesario poner las llaves 00:27:17
las puedo poner 00:27:19
pero no hace ninguna falta, porque 00:27:21
aquí queda muy claro que hasta 00:27:23
el siguiente case, hasta el siguiente 00:27:25
todo va dentro del de arriba, todo 00:27:27
¿vale? no hace falta ponerlas 00:27:29
las puedo poner si quiero 00:27:31
por una razón que vamos a entender 00:27:33
un poquito más adelante, pero ahora mismo 00:27:35
ahora mismo, con lo que 00:27:37
sabemos, nos da exactamente igual, ponerla que no ponerla 00:27:39
vale, pues 00:27:41
este movimiento está claro, ¿no? 00:27:42
si no es ni esta, ni esta 00:27:44
ni esta, ni esta, ni esta, ni esta 00:27:47
llegamos hasta el final, y hay un default 00:27:49
que es opcional, puede no estar el default 00:27:51
esto podría no estar 00:27:53
Si hay un default 00:27:54
Entonces se mete a hacer lo que hay aquí 00:27:56
El default es la rama 00:27:58
En la que se mete 00:28:06
Si no ha entrado en ninguno de los case anteriores 00:28:08
Es como el else del else if 00:28:10
Es como el else del else if 00:28:12
¿Vale? 00:28:14
Bueno, este sería el funcionamiento 00:28:16
Vale 00:28:17
Bueno, pues primera cosa 00:28:18
A ver, que tenemos que incorporar 00:28:21
Esto en realidad 00:28:24
No es como el if else if 00:28:26
que es que cuando encuentra 00:28:27
la rama válida 00:28:29
por ejemplo, si la nota es 0 00:28:31
la rama válida es esta 00:28:33
nota igual a 0 00:28:35
esta es la rama válida, pues entraría aquí 00:28:37
pero el switch case está pensado 00:28:39
para facilitar 00:28:42
usarlo con algunas aplicaciones 00:28:43
que pondremos algún ejemplo para entender 00:28:45
por qué está pensado así, está pensado 00:28:47
para que una vez que encuentra la rama válida 00:28:49
entre en esa rama, haga esa 00:28:51
y además haga ya de corrido 00:28:53
todas las que están a continuación 00:28:55
Sea el valor, el de la variable o no 00:28:56
Es decir, si yo le doy la 0 00:29:00
Va a entrar aquí, me va a hacer esto 00:29:02
Pero es que además me va a hacer todo lo demás 00:29:03
Vamos a comprobarlo 00:29:05
Comentando esto 00:29:08
Vale, vamos a darle a nota 00:29:10
El valor 0 00:29:17
Entonces como en este case 00:29:18
Va a ver que sí que es 0, va a entrar aquí 00:29:21
Va a entrar aquí 00:29:22
Pero es que va a entrar aquí, va a hacer esto 00:29:24
Y luego de corrido va a seguir 00:29:26
Y va a hacer todo lo demás 00:29:28
Vamos a comprobarlo 00:29:30
Se queda esperando la nota 00:29:32
Vale, le pongo un 0 00:29:40
Me ha mostrado 00:29:40
El insuficiente primero 00:29:43
Y es que se ha puesto a hacer todo lo demás 00:29:46
Vamos a suponer que le damos un 9 00:29:47
Un 9, en el 0 no va a entrar 00:29:49
Porque no es 9, en el 1 tampoco, en el 2 tampoco 00:29:52
En el 3 tampoco, en el 9 ya sí que va a entrar 00:29:54
En el 9 sí, va a entrar en el 9 00:29:56
Y me va a mostrar sobresaliente, pero es que a partir 00:29:58
De la rama en la que entra, a partir de la que entra 00:30:00
Ya hace todas las demás 00:30:02
Todas, ya de corrido 00:30:03
Ya sin mirar condición ni nada 00:30:05
A partir de la que entra 00:30:06
Vale, o sea, le vamos a dar un 9 00:30:08
Y vamos a ver como me muestra 00:30:09
Todas las que están a continuación 00:30:12
Me muestra todas las que están 00:30:14
Por debajo de la que ha entrado 00:30:16
Si yo le doy el 9 00:30:18
Me va a entrar en la 9 y me va a mostrar esto 00:30:20
Pero también me va a mostrar esta y esta 00:30:22
Todas las que están debajo 00:30:24
Vamos a comprobarlo 00:30:25
Yo le doy el 9, vale 00:30:28
Y efectivamente 00:30:30
No ha entrado ni en el 0, ni en el 1, ni en el 2 00:30:31
No ha entrado 00:30:34
En el 9 ya sí que ha entrado 00:30:34
Porque la variable es 9 00:30:36
Y desde el momento en que entra 00:30:37
Hace lo que hay en esa rama 00:30:39
Y ya de corrido hace todo lo que hay en las demás 00:30:40
A ver, puede que eso nos interese 00:30:42
Dependiendo de la aplicación 00:30:46
Puede que eso que nos interese 00:30:48
Nos sea útil y práctico 00:30:50
Porque a veces alguna aplicación se puede mantener 00:30:51
Se puede enunciar 00:30:55
Cuando llegues a este valor 00:30:56
A partir de él haz esto 00:30:58
Bueno, podremos ver luego algún ejemplo 00:30:59
Puede que eso nos interese 00:31:01
Pero en la mayoría de los casos 00:31:03
No nos interesa ese funcionamiento 00:31:04
En la mayoría de los casos el funcionamiento que nos interesa es 00:31:07
Que haga sólo 00:31:09
La rama en la que coincide el valor 00:31:11
Sólo esa, como el if, el seif 00:31:14
Suele ser el uso del switch case que nos interesa 00:31:16
Bueno, pues para que el switch case 00:31:18
Funcione así 00:31:20
Entonces hay que poner obligatoriamente 00:31:21
Al final de cada case 00:31:24
Una sentencia 00:31:26
Que es una palabra reservada 00:31:27
Que es la primera vez que la vemos de Java 00:31:29
Que se llama break 00:31:30
Y hay que ponerla sí o sí 00:31:31
Detrás de cada uno de los 00:31:33
Case 00:31:36
Si yo no quiero que funcione 00:31:37
Como acabo de decir 00:31:39
Por eso cuando estudiáis el switch case 00:31:41
O lo miráis en un vídeo 00:31:45
O lo miráis en algún lado 00:31:47
Pues directamente os lo ponen así 00:31:48
Switch case y luego pones break 00:31:50
Pones break por eso 00:31:52
Porque si no lo pones 00:31:53
Desde el momento en que entra en esa rama 00:31:54
Se hace todas las demás 00:31:56
Hasta que llega al 00:31:57
Vale, detrás del default 00:31:59
Aquí ya sí que no hace falta que ponga break 00:32:48
Porque es que detrás del default, que es lo último que se pone 00:32:50
Ya no hay nada más debajo 00:32:52
Entonces ya, si he entrado en el default 00:32:53
Ya no hay nada más 00:32:56
Entonces me da igual poner el break 00:32:57
Que no ponerlo, no molesta 00:33:00
Entonces el break es una palabra 00:33:01
Reservada de Java 00:33:03
Que significa 00:33:05
Sal 00:33:08
Del bloque en el que estés 00:33:09
Esto vamos a entender un poco mejor más adelante 00:33:12
Un bloque es un trozo de código entre llaves 00:33:16
Quedémonos con eso por ahora 00:33:18
Un bloque es un trozo de código entre llaves 00:33:19
Y el concepto de bloque tiene importancia 00:33:23
Ya veremos en breve por qué 00:33:26
Bueno, pues si un bloque es un trozo de código entre llaves 00:33:28
Todo esto de aquí es un bloque, ¿verdad? 00:33:32
Porque está entre llaves 00:33:35
Todo esto de ahí es un bloque 00:33:36
Está entre esta llave y entre esta llave 00:33:37
Eso es un bloque 00:33:39
Bueno, pues break es una palabra que significa 00:33:40
Sal automáticamente del bloque en el que estés 00:33:44
Y sigue con el programa fuera de ese bloque 00:33:48
Pues es justo lo que queremos 00:33:51
Si la nota ha sido cero y ha entrado aquí 00:33:53
Hace esto y se encuentra el break 00:33:56
Y el break le dice, fuera, sal del bloque 00:33:58
Sal del bloque, ya está 00:34:00
Pues él se ve forzado a salir del bloque 00:34:01
Y ya continúa por aquí 00:34:03
Haciendo la siguiente sentencia o la que sea 00:34:05
¿Vale? 00:34:07
Que no ha entrado en el 0 y entra en el 1. 00:34:12
Muestra esto y luego se encuentra con el break. 00:34:14
Que significa, fuera, sal de este bloque. 00:34:16
Pues estupendo, sale del bloque y se va aquí. 00:34:19
Entonces, ¿para que esto funcione realmente como un if-else-if? 00:34:22
Es decir, que los caminos sean excluyentes. 00:34:25
Y que una vez que ha encontrado el válido, salga. 00:34:27
Y ya no compruebe ninguno más. 00:34:30
Tenemos que poner un break. 00:34:32
¿Vale? 00:34:34
Entonces, ahora ya, si probamos esto, pues ahora ya sí que lo va a hacer como queremos. 00:34:42
¿Le metemos un 0? 00:34:47
Pues me muestra solo el insuficiente 00:34:47
Porque le hemos hecho un break y ha salido fuera 00:34:50
Que le ponemos un 9 00:34:52
Pues me muestra solo el sobresaliente 00:34:54
Porque le he puesto un break y se ha ido fuera 00:34:56
Que le ponemos un 12 00:34:57
Pues entra solo en el default 00:35:00
Ah bueno, es que en el default 00:35:01
Yo he puesto insuficiente y en el default tenía que haber puesto 00:35:03
Nota no válida 00:35:07
Con el copia y pega 00:35:07
Si hubiéramos hecho pruebas 00:35:09
Habríamos visto que teníamos un error 00:35:11
Y es que el system.out.println con el copia y pega 00:35:13
El texto está mal 00:35:16
Si uno no hace pruebas 00:35:17
Se le van a escapar errores de esto seguro 00:35:18
Si ahora volvemos a hacer la prueba 00:35:20
Para el caso de prueba que nos ha fallado 00:35:27
El 12 00:35:29
Ahora ya si ya no nos ha fallado el caso de prueba 00:35:29
Vale 00:35:32
Importante lo de las pruebas 00:35:34
Vale 00:35:36
Pues este es el switch case 00:35:38
Así funciona 00:35:40
Y el break se incorpora 00:35:42
Siempre 00:35:45
Para forzar ese comportamiento 00:35:45
Que cuando ya he entrado en una rama 00:35:48
Ya las demás paso de ellas 00:35:50
Porque normalmente el switch case 00:35:52
Lo que queremos es que sean caminos excluyentes 00:35:54
Pero si yo no quiero que funcione así 00:35:56
Si yo quiero que una vez que he entrado en una rama 00:35:58
Haga eso y todo lo que hay a continuación 00:36:01
Todo lo que hay 00:36:03
Pues entonces no pongo el break 00:36:04
En algún caso puede ser que eso me interese 00:36:07
Que una vez que he encontrado una rama 00:36:09
Haga eso y todo lo que viene a continuación 00:36:11
¿Vale? 00:36:13
Bueno, pues siguiente cosa 00:36:16
no hay duda sobre esto 00:36:17
¿vale? seleccionamos 00:36:20
el switch case en esa situación 00:36:22
cuando vemos que hay varias 00:36:24
posibilidades para mi programa 00:36:26
y la condición es que 00:36:28
una variable sea un valor o sea 00:36:30
otro, no una condición genérica 00:36:32
como el if, el save, que puede ser la condición 00:36:34
que a mi me dé la gana, sino cuando la condición 00:36:36
es una condición concreta y es que una variable 00:36:38
sea un valor o sea otro 00:36:40
pues en ese caso pongo el switch case 00:36:41
y el programa 00:36:44
escrito con el switch case 00:36:46
el que lo ve desde fuera 00:36:47
lo ve más claro, en cuanto ve un switch case 00:36:49
ya sabe de qué va este rollo 00:36:51
que va de distinguir en función 00:36:52
del valor de una variable 00:36:55
si uno lo ve con un if-else-if 00:36:56
pues no lo ve tan claro, lo ve más feo 00:36:58
porque tiene que repetir esta condición un montón de veces 00:37:01
tiene que ir mirando condición por condición 00:37:03
no vaya a ser que cada condición 00:37:06
se refiera a ideas distintas 00:37:07
no es tan fácil cuando uno ve 00:37:09
un código con if-else-if rápidamente 00:37:11
entender de qué va el rollo 00:37:13
Pero si lo ve con un switch case ya sabe de qué va el rollo 00:37:15
Que es, ah vale, la nota 00:37:18
Me decide el camino, la nota me lo decide 00:37:19
Ya lo has visto de buenas a primeras 00:37:22
Ya te haces una idea de qué va la historia 00:37:23
Cuando tú ves esto de buenas a primeras 00:37:25
No sabes si la nota es la que decide o no 00:37:28
Tienes que ir condición por condición 00:37:30
Porque yo aquí podría haber puesto 00:37:32
Otra que tiene que ver con nota 00:37:34
Podría haber puesto cualquier cosa 00:37:35
Entonces 00:37:36
Aunque un programa se puede hacer 00:37:39
De mil maneras 00:37:42
Y solo con el if else 00:37:43
Podemos hacer cualquier cosa 00:37:45
La idea es seleccionar 00:37:46
De todas las posibilidades que tengo 00:37:48
Estructuras que hagan el código más claro 00:37:49
Que hagan el código más claro para el que lo lee 00:37:52
Pues en la situación que digo 00:37:54
El switch case 00:37:56
Aportará más claridad 00:37:57
Vale, bueno, pues entonces 00:37:59
Seguimos depurando un poco esto 00:38:01
Hasta cierta versión de Java 00:38:04
Esto era así y era así 00:38:06
Pero, ostras, en este caso en particular 00:38:07
Se hace un poco rollo 00:38:10
porque hay un montón de ramas 00:38:11
en las cuales 00:38:13
yo hago lo mismo 00:38:15
para el 0, para el 1, para el 2 00:38:20
para el 3 y para el 4 00:38:22
estoy haciendo para todas ellas 00:38:23
lo mismo 00:38:26
entonces, jolín, esto 00:38:27
queda muy feo 00:38:30
o sea, un montón de veces 00:38:33
lo mismo para varios casos 00:38:34
un montón de veces, vale 00:38:36
con lo que hemos dicho y sabemos hasta ahora 00:38:37
¿qué apaño haríais? 00:38:39
¿qué apaño haríais 00:38:42
para que este 00:38:43
System.out.println solo aparezca 00:38:46
escrito una vez 00:38:48
y el programa haga lo mismo 00:38:49
¿qué apaño se os ocurre? 00:38:51
un programa 00:38:54
que va a hacer exactamente lo mismo que este switch case 00:38:55
lo mismo, lo mismo 00:38:58
pero que el System.out.println insuficiente 00:38:59
solo me aparezca escrito una vez 00:39:02
que ya parece que al menos gana 00:39:04
¿se os ocurrirá algún apaño? 00:39:05
Espera, este no te lo había 00:39:07
Sí, bueno, eso era lo siguiente que iba a decir 00:39:13
Eso, hasta cierta versión de Java 00:39:22
No se podía usar 00:39:24
Pero sí, eso es lo que haríamos 00:39:25
Pero, olvídate de eso 00:39:27
Con lo que hemos dicho hasta ahora 00:39:29
Lo que quiero ahora mismo simplemente es que penséis 00:39:31
Que penséis 00:39:33
Pero bueno, nota tiene el valor que le he dado 00:39:36
No te entiendo 00:39:49
Eh, sí, pero 00:39:50
¿Y los queis? 00:40:05
¿Estos? 00:40:07
Claro, pero el tema es 00:40:18
Si nota es igual a 0 00:40:20
O nota es igual a 1 00:40:22
O sea, que este switch se hace en función de nota 00:40:23
En cualquier caso 00:40:26
Ah, bueno, ya 00:40:28
Ya, ya, ya, ya, ya 00:40:43
Bueno, sí, pero 00:40:44
Sí, pero bueno, que metes una variable adicional 00:40:45
Vale, sí, sí, el objetivo no es 00:40:48
Tanto 00:40:50
Que solo me aparezca una vez, sino que además 00:40:51
simplificando el programa 00:40:54
vale, a ver, por ejemplo, con lo que hemos 00:40:55
dicho, a lo que yo me refiero es 00:40:58
lo que podemos es, por ejemplo 00:41:00
quitar todo esto 00:41:01
¿verdad? 00:41:04
¿este programa no haría lo mismo que el anterior? 00:41:11
con lo que hemos explicado el switch case 00:41:13
con lo que hemos explicado hasta ahora 00:41:15
este programa haría lo mismo 00:41:16
¿qué es cero? 00:41:18
entra en cero 00:41:22
pero como no hay un break 00:41:23
ya hace de corrido todo lo que 00:41:24
viene a continuación, todo, todo, todo 00:41:27
Y lo que viene a continuación es esto 00:41:29
Que es lo que queremos 00:41:31
Entonces si hay un 0 imprime esto 00:41:31
Y aquí ya sí que break se va afuera 00:41:33
Con lo cual si la nota es 0 funciona 00:41:35
Si la nota es 1 00:41:37
En 0 no entra y en 1 también 00:41:39
En 1 también entra 00:41:42
No hace nada pero como no hay un break 00:41:43
Hace de corrido todo lo que hay a continuación 00:41:45
Hasta que llega hasta aquí 00:41:48
Lo muestra 00:41:49
Y como aquí ya sí que hay un break sale 00:41:50
Si la nota es 2 00:41:54
Entra aquí, no hace nada 00:41:55
Pero como no hay un break, hace de corrido 00:41:57
Todo lo que hay a continuación 00:41:59
Luego muestra esto 00:42:00
Con el 4 igual, con el 3 igual y con el 4 igual 00:42:01
Entonces, este código 00:42:05
Quitando todas las líneas de arriba 00:42:07
Es idéntico 00:42:08
Este código y el anterior son idénticos 00:42:09
Sin más que pulírselo de arriba 00:42:12
¿Vale? Son idénticos 00:42:14
¿Entendéis? 00:42:16
Bueno, pues así se hacían las cosas 00:42:19
Cuando yo quería agrupar 00:42:21
Varios valores en uno 00:42:23
Quería agrupar varios valores en uno 00:42:25
Así se hacían las cosas 00:42:27
Hasta cierta versión de Java 00:42:29
Y así lo podéis encontrar de hecho en muchos códigos 00:42:31
Si miráis por ahí 00:42:33
Programas o 00:42:35
Así se hacían cuando yo quería agrupar varios en uno 00:42:36
Pues ponía lo que quería hacer 00:42:39
Para todos ellos 00:42:41
En el último de los que hay 00:42:42
Y los demás en blanco 00:42:44
Entonces desde el momento en que entraban cualquiera de ellos 00:42:46
Bajaba, lo hacía ya todo 00:42:48
Hasta el último 00:42:50
¿Vale? Entonces esto y el código anterior 00:42:52
Es idéntico 00:42:55
Bueno, pues así lo vais a encontrar muchas veces 00:42:56
¿Qué pasa? Hombre, que esto es feo 00:42:59
De nuevo, esto es un poco feo a la vista 00:43:01
Esto es un poco feo 00:43:03
Entonces, a partir de cierta versión de Java 00:43:04
Se dijo, vale 00:43:06
Pues cuando yo quiero agrupar 00:43:09
Varios valores con un único código 00:43:10
Con un único código 00:43:13
Venga, vamos a permitir ponerlos uno tras otro 00:43:14
Con un ACOF, vamos a permitirlo 00:43:17
¿Vale? 00:43:19
Entonces, esto lo podríamos entonces simplificar así 00:43:21
Si es 0, o si es 1, o si es 2, o si es 3, o si es 4 00:43:25
¿Vale? 00:43:35
Es decir, después del case 00:43:37
Yo puedo poner varios valores separados por comas 00:43:39
Y eso es como tener varios case vacíos 00:43:43
Y solo el último, el del 4, tiene la condición 00:43:47
¿Vale? 00:43:49
entonces esa opción siempre la tenemos 00:43:54
pero esta opción no es válida 00:43:55
para cualquier versión 00:43:58
del nivel de compilación 00:44:00
no es válida 00:44:03
en el switch case no 00:44:04
tú distinguías por casos 00:44:11
de hecho vamos a ver exactamente con qué nivel de compilación 00:44:13
me lo cambia 00:44:15
un momentito 00:44:17
java compiler 00:44:19
por ejemplo 00:44:28
si yo al Java Compiler 00:44:29
como el 00:44:32
¿veis? por ejemplo 00:44:34
he bajado al nivel 7 00:44:44
que es un nivel de Java 00:44:46
al nivel de compilación 7 00:44:47
que es un nivel de Java que todavía se usa 00:44:49
en muchas empresas, en muchos sitios 00:44:52
porque pueden mirar los servidores 00:44:53
y bajando a ese nivel 7 de Java 00:44:54
eso me dice de que me está afectando 00:44:57
¿vale? 00:45:00
hasta luego 00:45:01
y a ver en el 8 00:45:02
hay una cosa que también se utiliza 00:45:09
en el 8 sigue siendo ahí 00:45:13
si pones entre 00:45:15
quites la coma que hay desde 0 a 4 y pones los puntos 00:45:16
si, si, si, ya, ya, ya 00:45:19
si, si, si 00:45:21
es el rango de valores 00:45:22
si, si 00:45:24
pero esas cosas se han incorporado posteriormente 00:45:25
la versión 8, que es la versión que se usa 00:45:28
casi todas las empresas no es válida 00:45:30
tenéis que ser conscientes de que es una 00:45:32
posibilidad que se ha hecho 00:45:36
después para simplificar el código 00:45:38
pero que en muchos casos, ahora estoy en la versión 8 00:45:39
que es la que se usa en todas las empresas 00:45:41
y no podría usarla 00:45:43
venga, pues nada 00:45:45
uuuh, yo no he parado esto 00:45:49
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
5
Fecha:
16 de octubre de 2023 - 13:21
Visibilidad:
Público
Centro:
IES ROSA CHACEL
Duración:
45′ 53″
Relación de aspecto:
1.78:1
Resolución:
1280x720 píxeles
Tamaño:
875.66 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid