Saltar navegación

20251014 ProgEstr-SentSwitch - 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 19 de octubre de 2025 por Raquel G.

3 visualizaciones

Más información Transcripción

Descargar la transcripción

Vale, para introducir otra forma de hacer decisiones vamos a hacer el 30, por ejemplo, el 30, que sería, a ver, que es una tontería, pero nos permite introducir otra sentencia para hacer los códigos que involucran decisiones un poquito más bonitos, nada más. 00:00:00
Bueno 00:00:21
Sí, pero 00:00:22
Dentro de sentencia de decisión 00:00:24
Tenemos if, el se if 00:00:27
Pero nos falta otra 00:00:30
Forma de hacer decisiones 00:00:31
De escribirlas 00:00:33
Pues venga, vamos a poner 00:00:34
Ejer 30 00:00:37
Esto dice 00:00:41
Pedir una nota y mostrarla 00:00:47
De la siguiente forma, 0, 1, 2 00:00:50
Como si fuera en cadena 00:00:52
O podríamos poner suspenso 00:00:53
Por ahora vamos a ponerla 0, 1, 2 00:00:54
Vale, entonces este programa se convertiría en esto 00:00:57
Bueno, primero vamos a, como tenemos que pedir un numerito 00:01:02
Pues vamos a esto 00:01:06
Ala, pedimos la nota 00:01:10
Venga, introduzca nota numérica 00:01:25
introduzca 00:01:42
nota 00:01:46
entre 0 y 10 00:01:47
a la introduzca 00:01:51
nota entre 0 y 10 00:01:53
ahí tenemos la nota 00:01:54
ahora, ¿qué tiene que hacer el programa? 00:01:55
mostrarme la nota 00:01:58
traducida a cadena para que yo la entienda 00:02:00
mejor 00:02:03
para imprimirla en un boletín, para lo que sea 00:02:03
0, 1, 2 00:02:06
con lo cual, este es un programa 00:02:07
no hay nadie 00:02:09
Este es un programa con un montón de ramas 00:02:10
Porque me puede mostrar 0 00:02:14
O bien 1, o bien 2, o bien 3 00:02:16
Así hasta 10 00:02:19
Este es un programa con un montón de ramas 00:02:20
Luego 00:02:21
Esto 00:02:23
Que optaríamos por un if else if 00:02:24
Porque si lo hacemos con el if else básico 00:02:27
Haríamos algo de este estilo 00:02:31
Si nota igual a 0 00:02:32
Pues entonces 00:02:35
cero 00:02:40
¿pero qué pasa si la nota no es igual a cero? 00:02:42
pues si la nota no es igual a cero 00:02:48
entonces me voy a preguntar 00:02:50
¿nota igual a uno? 00:02:52
y pondría aquí 00:02:56
uno 00:02:58
estoy no poniendo llaves 00:02:59
porque dentro del if solo hay una sentencia 00:03:04
y dentro del else solo hay una compleja 00:03:06
que es la if 00:03:09
¿pero qué pasa si la nota no es uno? 00:03:09
que hay en este else de aquí 00:03:12
dentro de este if 00:03:14
pues no lo sé 00:03:15
vamos a mirar a ver si ahora fuera 00:03:17
vale, y hasta aquí está bien la broma 00:03:21
pero es que si tenemos que 00:03:30
seguir considerándonos 00:03:32
¿y qué pasa si la nota no es 2? 00:03:33
¿qué pasa si es 3? 00:03:36
pues si yo sigo las reglas de un código 00:03:38
elegible, elegante, todo esto 00:03:40
aquí se me quedan unos anidamientos 00:03:42
tremendos, ¿vale? 00:03:44
por eso hacíamos la sentencia if 00:03:46
ELSEIF, que me permitía compactar esto 00:03:48
cuando hay IF dentro de ELSE. 00:03:50
¿Vale? No porque 00:03:53
el programa haga algo 00:03:54
distinto. Si la máquina virtual va a hacer 00:03:56
lo mismo. Es otra forma de escribirlo. 00:03:58
Entonces, en nuestro caso, 00:04:01
como rápidamente vemos que nuestro programa 00:04:02
tiene un montón de ramas. O mostrar 00:04:04
cero, o mostrar uno, o mostrar dos, o mostrar tres. 00:04:06
Pues pienso cuál es la condición 00:04:08
para cada uno de ellas, la pienso y lo 00:04:10
planto en un IF, ELSEIF, ELSEIF, ELSEIF. 00:04:12
Lo que explicamos el otro día, ¿no? 00:04:14
pues entonces no voy a seguir aquí hasta el infinito 00:04:16
con el save note igual a 3 00:04:19
porque esto sería muy feo 00:04:20
aunque el programa estaría bien hecho 00:04:22
sería muy feo y digo, a ver 00:04:23
espérate 00:04:26
esto tiene varias opciones, ¿no? 00:04:27
si se cumple la condición 1 00:04:31
hará una cosa 00:04:32
la que sea 00:04:34
pero 00:04:36
si se cumple 00:04:37
la condición 2 00:04:42
vale, si se cumple la condición 2 00:04:45
entonces haces otra cosa 00:04:50
esta era la sintaxis del if, el save 00:04:54
que es lo mismo que hemos escrito antes 00:04:58
y así puedo poner todas las ramas que a mí me den la gana 00:05:00
todas las que yo quiera, cada una asociada a una condición 00:05:13
y entra en esta rama si la condición que se cumple 00:05:15
es la correspondiente a su rama 00:05:19
Podemos acabar con un else 00:05:21
Al cual entrará 00:05:24
Al cual entrará 00:05:26
Si no se cumple nada de los anteriores 00:05:32
Esto era el if, el save 00:05:33
Era la representación de un programa 00:05:35
Con varias ramas 00:05:38
Cada rama asociada a una condición 00:05:39
Solo se va a ejecutar una de ellas 00:05:41
Solo una, la correspondiente a la condición cierta 00:05:44
Si ninguna es cierta, se ejecuta el else 00:05:47
Si hay dos que son ciertas 00:05:50
Y si me decís, oye, y si se cumple esta y esta 00:05:53
La primera que encuentre 00:05:55
Porque esto iba en secuencia 00:05:57
Miro la primera, que se cumple, hago esto 00:05:59
Punto pelota 00:06:01
Me voy, se acabó 00:06:02
Que no se cumple, miro la siguiente 00:06:04
Podría ser que se cumpliera esta y esta 00:06:06
Pero es que a esta no llegaría a mirarla nunca 00:06:10
Porque como ya se ha cumplido esta 00:06:12
Ha entrado aquí y se ha pirado 00:06:14
¿Vale? 00:06:15
No tienen por qué ser excluyentes 00:06:18
Lo que pasa es que, hombre, este programa 00:06:19
esta estructura tiene sentido cuando tú quieres 00:06:22
condiciones excluyentes 00:06:24
y para cada una de ellas hacer una cosa 00:06:27
bueno pues 00:06:28
esto es exactamente 00:06:29
la estructura de lo que nos están pidiendo 00:06:31
varias posibilidades 0, 1, 2 00:06:34
hasta 10 y en cada una de ellas hago una cosa 00:06:37
es justo lo que me están diciendo 00:06:38
se adapta a esto perfectamente 00:06:40
pues venga se trata de reflejar eso 00:06:42
si nota es igual a 0 00:06:44
pues entonces 00:06:47
Entonces, pon cero. 00:06:49
Y así no vamos a ponerlas todas porque es un montón. 00:06:55
Si nota es igual a uno, pon uno. 00:07:01
Y vamos a poner la última, aunque habría que poner todas. 00:07:09
Si nota es igual a tres, pues pon tres. 00:07:15
Sí, porque es que no las voy a poner todas que me vuelvo loca. 00:07:28
Pero vamos. 00:07:31
Vamos a ver, lo podemos dejar así 00:07:33
Dos 00:07:35
Y si no 00:07:37
Pues podríamos poner nota no válida 00:07:41
Aquí iría en el resto 00:07:44
Del save, ¿vale? Que no los pongo 00:07:52
El save, nota igual a 00:07:54
Tres, dos, ¿vale? 00:08:01
Pues nos queda un programa más legible que si yo 00:08:03
Voy anidando, voy anidando, pero es lo mismo 00:08:05
Hace lo mismo 00:08:07
¿Vale? Entonces si ejecutamos esto 00:08:08
Pues 00:08:11
Si le pongo el dos, pues me saca el dos 00:08:12
pero si le pongo 00:08:17
el 6, pues nota no válida 00:08:21
porque no tengo esa contemplada 00:08:23
vale 00:08:25
sí que tenía yo aquí cosas abiertas 00:08:26
madre de Dios 00:08:37
vale, bueno 00:08:38
pues 00:08:45
cuando la situación 00:08:46
es exactamente esta 00:08:49
yo identifico que tengo que hacer un programa 00:08:50
que tiene varias 00:08:53
ramas de actuación 00:08:55
y de qué depende que haga una cosa o haga otra 00:08:56
pues si yo identifico que depende 00:08:59
del valor de una variable 00:09:01
entonces puedo poner otra condición 00:09:02
que hace que el código sea más claro 00:09:05
que es el switch case 00:09:07
esta es una genérica, yo aquí puedo poner 00:09:08
cualquier condición 00:09:11
esta en particular, la condición 00:09:12
era que la variable fuera igual a un valor 00:09:15
pero aquí podría haber sido una condición muy compleja 00:09:16
y aquí podría haber sido una muy compleja 00:09:19
y aquí también 00:09:21
pero en el caso concreto 00:09:22
de que estas condiciones 00:09:24
sean que una variable 00:09:27
sea igual a algo 00:09:29
esto lo puedo poner con 00:09:31
otra sintaxis 00:09:33
de la sentencia de decisión 00:09:35
si las condiciones 00:09:36
son todas 00:09:43
que muy mal expresado 00:09:46
que una variable tome 00:09:49
un valor 00:09:53
pues entonces 00:09:54
podemos hacerlo 00:09:57
con esta 00:09:59
sentencia 00:10:01
suite 00:10:02
una sentencia que existe en todos los lenguajes de programación 00:10:05
vale, pues como es la sintaxis 00:10:10
de esta sentencia 00:10:14
primero se pone switch 00:10:14
como no podía ser de otra manera 00:10:17
y entre paréntesis 00:10:18
se pone 00:10:22
la variable 00:10:24
entre paréntesis 00:10:25
la variable que 00:10:28
en función de su valor yo hago una cosa u otra 00:10:29
tiene que ser una única 00:10:32
variable 00:10:33
vale, pues este programa en función 00:10:34
del valor de nota yo hago una cosa o hago otra 00:10:37
pues aquí pongo nota 00:10:40
y ahora aquí distingo 00:10:42
cada una de las posibilidades 00:10:45
que yo contemplo para esa variable 00:10:48
y las distingo cada una en un case 00:10:50
case nota que sea cero 00:10:54
dos puntos y lo que yo quiero que se haga 00:10:58
cuando sea cero, pues mostrar cero 00:11:01
y ya he terminado con esta rama 00:11:05
¿Qué quiero otra rama? 00:11:08
Pues en el caso de que sea 1 00:11:12
Pues 1 00:11:14
¿Y qué quiero yo en el caso de que sea 2? 00:11:18
Pues 2 00:11:26
Entonces esta es más bonita 00:11:27
Que un if, el se if, el se if 00:11:31
Cuando las condiciones que mandan 00:11:33
Es que una variable sea igual a un valor 00:11:36
¿Vale? Aquí de hecho 00:11:38
Por ejemplo voy a poner algunas más 00:11:41
La 3 00:11:48
La 4 00:11:50
3, 4 00:11:53
hay un else 00:11:58
que es 00:12:03
y si no es ninguno de los anteriores 00:12:04
ese else se llama 00:12:07
default 00:12:09
nota no válida 00:12:10
y ahí acabaría el switch, vale 00:12:17
esto ahora tiene un montón de matices que tenemos que incorporar 00:12:22
vale 00:12:25
pero primero 00:12:26
repetimos 00:12:29
recordad que 00:12:30
esta sentencia es 00:12:32
la sentencia que usamos cuando un programa 00:12:34
tiene varias posibilidades 00:12:37
varias ramas de actuación 00:12:39
y de qué depende que haga una rama 00:12:41
o haga otra 00:12:43
del valor que tome una variable 00:12:44
del valor que tome una variable 00:12:47
ese es un caso particular 00:12:49
el if, el save es más general 00:12:50
el if, el save tiene un montón de ramas 00:12:53
pero yo aquí puedo poner las condiciones 00:12:56
que me den la gana 00:12:58
no tiene que ser que una variable tome un valor 00:12:58
la condición que yo quiera 00:13:02
pero el switch case es un caso 00:13:04
particular de programa con varias ramas 00:13:07
donde lo que define 00:13:09
a qué rama me voy es el valor 00:13:11
que tome una única variable 00:13:12
una única variable 00:13:15
si identifico esa situación 00:13:16
pongo un switch case y queda más bonito 00:13:18
y queda más claro 00:13:20
vale, entonces ¿cómo funciona el switch case? 00:13:21
pues tiene un funcionamiento raro 00:13:25
¿cómo funciona? 00:13:26
la máquina virtual llega aquí 00:13:31
coge esta variable 00:13:32
y empieza, mira su valor y empieza a compararlo 00:13:33
con cada uno de los case. 00:13:40
¿El valor es cero? 00:13:42
Uy, sí, es cero. 00:13:43
Pues entra y hace lo que hay aquí. 00:13:45
Pero a diferencia del if, el save, no se pira, 00:13:47
sino que a partir de ahí empieza a hacer 00:13:50
todo lo que hay a continuación. 00:13:54
Me da igual que no sea uno o sea dos, me da igual. 00:13:56
Es decir, en cuanto encuentra un valor que coincide con la variable, es como decir, arranca desde aquí y ya coge carrerilla para todo. 00:14:02
Entonces, eso a veces puede que encaje, pero en este caso no. 00:14:12
Si la variable es cero, queremos que muestre cero y que salga, no queremos que haga nada más. 00:14:16
Pues para eso hay que poner una sentencia después, que es la que suele acompañar al switch case. 00:14:21
A ver, ¿por qué estáis tan revolucionados? 00:14:27
¿Qué es break? 00:14:32
Entonces es lo habitual 00:14:33
Tener que poner break 00:14:35
En cada case cuando acabo 00:14:37
Lo que 00:14:40
Simplemente para que se salga ya 00:14:40
Y no ejecute el resto 00:14:46
En cada uno 00:14:47
Hay que ponerlo en cada uno 00:14:50
Hay que ponerlo en cada uno 00:15:01
Si queremos 00:15:03
Que cuando encuentre el valor que coincide con la variable 00:15:03
Haga eso 00:15:07
Y termine y se vaya del switch case 00:15:08
Y siga por aquí, claro 00:15:11
Si queremos que funcione así 00:15:12
Que es lo habitual 00:15:13
Lo habitual es que queremos que funcione así 00:15:15
Si no ponemos el break 00:15:17
Esto se interpreta de otra manera 00:15:20
Y es que en cuanto encuentra ese valor 00:15:22
Empieza a partir de ahí 00:15:25
Vale, vamos a ejecutar esto 00:15:27
Este if, el save 00:15:38
Que ya sabemos que funciona 00:15:40
Voy a poner en comentarios para no liar 00:15:41
Esto lo voy a poner todo comentado 00:15:43
Todo esto está comentado 00:15:45
Mi programa se ha quedado 00:15:47
¿Cómo lo he comentado todo a lo bestia? 00:15:49
Control 7 00:15:51
Seleccionáis, control 7 00:15:52
Se comenta todo a lo bestia 00:15:56
Y lo podéis volver a descomentar 00:15:57
De la misma manera 00:16:00
Control 7, descomento 00:16:00
Si lo queréis comentar todo a lo bestia 00:16:07
Control 7, comentáis 00:16:10
Vale, bueno pues nos ha quedado 00:16:11
Esto 00:16:14
El default sería como el ELSE 00:16:15
Si no es ninguno de los anteriores 00:16:19
Entonces vamos a ejecutarlo 00:16:23
Callao 00:16:26
Venga, si yo le pongo el 0, muy bien, 0 00:16:28
Si lo vuelvo a ejecutar y le pongo el 3 00:16:34
Muy bien, 3 00:16:37
Si le pongo el 7, que el 7 no lo tenía contemplado 00:16:39
Nota no válida, vale 00:16:43
Imaginaos que se me ha olvidado poner el break aquí 00:16:44
lo voy a poner ahí en comentarios 00:16:49
si encuentra el 1 00:16:52
va a entrar en el 1 y como no hay un break 00:16:54
va a seguir haciendo lo demás 00:16:56
hasta que se encuentre el siguiente break 00:16:58
imaginaos que se me había ponido este break 00:16:59
pues que que más da 00:17:02
no, pero que lo haga no significa que entra a evaluar 00:17:05
sino que ya 00:17:08
lo hace todo de carrerilla 00:17:09
ya ni mira el valor ni mira nada 00:17:11
ni mira el valor ni mira nada 00:17:13
entonces yo le pongo el 00:17:16
espera, es que no era el 0 00:17:19
era el 1, donde se me había olvidado ponerlo 00:17:22
el break 00:17:24
entonces yo le pongo el 1 00:17:24
pues me hace el 1 00:17:27
y me hace el 2 también 00:17:29
porque como no hay un break aquí, ya sigue 00:17:31
sigue hasta que se encuentre un break 00:17:34
hasta que se encuentre un break 00:17:36
claro 00:17:37
desde que entra 00:17:40
porque ha encontrado la variable 00:17:42
que el valor que coincide desde que entra 00:17:43
empieza a hacer ya todas las sentencias 00:17:45
ya ignorando los case. 00:17:47
Los ignora, empieza a hacerlo todo 00:17:49
hasta que se encuentre un break. 00:17:50
¿Vale? 00:17:53
Entonces, esto se hizo así 00:17:54
antes de que se hiciera cierta incorporación 00:17:56
porque la sentencia switch case 00:18:00
ha tenido actualizaciones 00:18:03
según Java se ha actualizado. 00:18:04
Por ejemplo, 00:18:06
antiguamente no se podía poner ahí 00:18:08
una variable que fuera string 00:18:10
y aquí poder stringar así. 00:18:11
Ahora lo comprobamos. 00:18:13
Pero, por ejemplo, 00:18:14
¿para qué me puede a mí ser útil 00:18:15
que no haya break? 00:18:16
Pues, imaginad que en lugar de poner 0, 1, 2, queremos poner aprobado, suspenso, notable. 00:18:17
Pues, yo podría jugar de esta manera. 00:18:24
Quito aquí el 0. 00:18:27
Quito aquí el break. 00:18:29
Quiero poner suspenso. 00:18:30
Quito aquí todos los break. 00:18:33
Quiero poner suspenso hasta el 4 incluido. 00:18:34
Pues, entonces, pongo aquí ya, por ejemplo, quito todos estos system out. 00:18:37
Los quito todo. 00:18:45
Perdón. 00:18:53
quito esto así, lo dejo esto así, 00:18:53
y aquí en este x4 ya pongo el siso este, 00:19:09
suspenso, y aquí ya sí que pongo un break. 00:19:13
Entonces, ¿qué va a pasar? 00:19:18
Que tanto si es 0, como si es 1, como si es 2, como si es 3, como si es 4, 00:19:19
lo que va a ejecutar es esto. 00:19:24
Porque si es 0, entra aquí, no hace nada, 00:19:25
pero como no hay un break, se pone de corrido hasta que llega el break, 00:19:29
con lo cual haría esto. 00:19:33
Si es un 2, entra aquí 00:19:33
Y ya se pone a hacerlo todo de corrido 00:19:36
Hasta que se encuentre un break 00:19:39
Que no lo encuentra hasta aquí 00:19:40
Entonces, ahora 00:19:41
Imaginaos el 5 y el 6 00:19:44
Que es aprobado 00:19:47
Es el valor 00:19:49
De la variable 00:19:53
Que si coincide, entra ahí 00:19:54
Este sería bien 00:19:55
Y aquí ya si pondríamos un break 00:19:59
Vamos a poner 00:20:03
Case 7 00:20:04
Y case 8 00:20:08
Este sería notable 00:20:13
Y case 9 00:20:15
Y case 10 00:20:25
Sobresaliente 00:20:30
Vale, sobresaliente 00:20:32
Pues jugar con los break 00:20:37
Nos permite hacer cosas como esta 00:20:39
Por ejemplo 00:20:41
Hay 5 valores diferentes 00:20:43
que yo quiero que salgan por el mismo lado 00:20:45
pues les quito el break 00:20:47
los dejo en blanco 00:20:49
y me da igual por cual entre 00:20:50
porque desde el momento en que entra en 1 00:20:52
porque esta variable nota es 1 00:20:54
o es 2 o es 3 00:20:57
ya empieza a hacer todo de corrido hasta el break 00:20:58
luego me da igual por donde entre 00:21:00
si entra porque es 0 o porque es 1 00:21:02
va a hacer todo de corrido hasta el break 00:21:03
que es hacer suspenso 00:21:04
y ahí ya se va 00:21:05
porque es un break 00:21:07
pero que pasa si es un 5 o un 6 00:21:08
entonces no entra en ninguna de estas 00:21:10
no entra pero aquí si que entra 00:21:12
O aquí sí que entra 00:21:13
Entonces, me da igual que entre aquí 00:21:15
Que entre aquí, hace todo de corrido 00:21:17
Que será el bien 00:21:19
Y aquí ya sale, porque hay un break 00:21:21
Con el 7 y el 8 igual, con el 9 y el 10 igual 00:21:22
Entonces, jugar con los break me permitía 00:21:25
Hacer esto, de ahí venía lo del break 00:21:27
¿Vale? 00:21:29
¿Entendido hasta aquí? 00:21:32
Pero claro 00:21:33
Esto era hasta que no sé qué momento 00:21:34
Llegó 00:21:37
Una versión de Java que te permitía 00:21:39
Poner varios valores 00:21:41
en el mismo case separados por coma 00:21:43
que antes no 00:21:45
no se hasta que versión, no fue hace mucho 00:21:46
entonces, antes 00:21:49
este programa se hubiera hecho así 00:21:51
y todavía se podría 00:21:53
encontrar así, y lo podréis encontrar 00:21:55
así en 00:21:57
pero ahora ya no hace falta 00:21:58
hacerlo así, porque ahora 00:22:01
ya podríamos hacer, en el caso de que sea 00:22:03
0, 1 o 2 00:22:05
o 3 o 4 00:22:06
vale, entonces ahora ya hago lo que 00:22:08
sea, verdad 00:22:11
ahora ya las versiones de Java 00:22:12
me permiten completar varios 00:22:19
luego 00:22:22
esto que ha tenido como herencia 00:22:25
que ahora el break lo ponemos siempre 00:22:27
y se ha quedado ahí como sentencia fea 00:22:29
esto es una de las cosillas que 00:22:31
bien heredadas 00:22:33
de las actualizaciones 00:22:35
que se han tenido que ir 00:22:38
compatibilizando con lo anterior 00:22:40
luego 00:22:41
en los años en los que estamos 00:22:43
2026, ¿con qué nos quedamos 00:22:45
del switch case, nos quedamos 00:22:48
¿qué? 00:22:50
es una 00:22:51
me da igual 00:22:52
me da igual, los espacios 00:22:56
los parsea 00:22:58
el compilador 00:23:00
vale, ahora ya 00:23:01
en la versión del año 2026 00:23:04
de Java 00:23:06
¿con qué nos quedamos? 00:23:06
nos quedamos con que el switch case es una sentencia 00:23:09
que plantamos ahí 00:23:12
cuando tenemos un programa 00:23:13
que puede hacer varias 00:23:15
cosas, tiene varias posibilidades 00:23:17
y de qué depende 00:23:19
cada una de esas posibilidades 00:23:21
del valor de una única variable 00:23:22
si identificamos eso 00:23:24
switch case, y ahora 00:23:27
¿cuál es su sintaxis? pues switch 00:23:28
la variable que sea 00:23:31
que puede ser cualquier primitiva o también un string 00:23:32
también un string 00:23:35
y aquí yo voy poniendo en los case 00:23:36
los valores posibles 00:23:38
que para varios valores quiero hacer lo mismo 00:23:39
los pongo separados por comas 00:23:42
y para esos valores entrará en cualquiera 00:23:44
de ellos que tome y hará lo mismo 00:23:47
y ahora en cada 00:23:48
switch 00:23:51
hago un break 00:23:53
en cada case, perdón 00:23:54
hago un break porque si no lo hago 00:23:56
si no lo hago 00:23:59
una vez que entre 00:24:02
va a ir hasta el final 00:24:03
y ese es un efecto que normalmente 00:24:06
no queremos 00:24:10
normalmente no queremos 00:24:11
pero bueno, hay que saber cómo funciona, claro 00:24:13
vale 00:24:18
El valor del case puede ser 00:24:30
Una variable 00:24:42
¿Te puedes creer que me haces dudar? 00:24:43
Porque normalmente casi nunca se usa 00:24:48
En ese 00:24:50
Con ese 00:24:52
Estándar 00:24:54
No, es que 00:24:55
No, lo tienes que poner 9 00:25:02
No puede ser una variable 00:25:05
¿Vale? Es que me hacías dudar 00:25:06
Porque claro, en la vida lo había visto 00:25:09
a, bueno, espérate 00:25:11
a ver si n igual a 00:25:13
no, bueno ya, pero a ver 00:25:15
tiene sus usos, sus valores concretos 00:25:19
una variable, una serie 00:25:21
de valores concretos, pues 00:25:23
tiene su mercado 00:25:25
interesante 00:25:26
¿no le puedes poner del 1 al 4? 00:25:28
¿ves? tiene que ser un valor constante 00:25:32
perdón 00:25:34
¿no le puedes poner del 1 al 4? 00:25:36
para esas pijerías 00:25:40
Python 00:25:44
¿Vale? 00:25:45
Pero luego a cambio 00:25:49
Tiene muchos otros problemas 00:25:50
¿Vale? Pues este programa 00:25:51
De dada un valor numérico 00:25:54
Dada una nota 00:25:56
Ponerla en literal, pues podría ser así 00:25:58
Por ejemplo, no es el 00:26:00
30 en particular, pero bueno, lo hemos aprovechado 00:26:02
¿Vale? Pues ya todos 00:26:04
Sabemos el switch case y sus 00:26:06
Detalles 00:26:08
Que son los que he dicho, nada más 00:26:10
Claro 00:26:12
Imaginaos, claro, por ejemplo 00:26:14
Voy a cambiar 00:26:19
Versión de Java 00:26:28
Java compiler 00:26:31
Por ejemplo 00:26:35
La 1.8 00:26:56
Fijaos 00:26:57
En cuanto he bajado 00:27:01
he bajado 00:27:03
a la versión de Java 00:27:05
1.8, que en realidad 00:27:07
es una de las que más se usan 00:27:08
porque es la más estable 00:27:11
pues en cuanto bajo la versión de Java 1.8 00:27:12
esto ya no me deja 00:27:15
hacerlo, me dice, para esa versión 00:27:17
de Java, que es una de las más 00:27:19
utilizadas de hecho, esto 00:27:21
no, porque esto fue una incorporación que he sido posterior 00:27:23
tendríamos que desglosarlo a 0, 1 00:27:25
2, 3, 4, 5 00:27:27
para que lo tengáis ahí presente 00:27:29
Entonces me voy a volver a la versión que estaba 00:27:34
Bueno, pues a ver 00:27:37
¿Qué otros ejercicios podemos hacer? 00:27:54
¿Qué otro ejercicio 00:27:57
O llama la atención, ¿eh? 00:27:59
Venga 00:28:06
Vamos al 7 a ver que nos sale 00:28:07
Bueno, sí 00:28:12
Pero el último día es hoy 00:28:21
Ah, no, el lunes 00:28:22
¿Por qué? 00:28:24
el switch, no, por eso no 00:28:27
me viene nada 00:28:29
vale, dime 00:28:30
jolín, con lo char 00:28:32
no, no lo sé, pero vamos 00:28:35
que será lo que estamos haciendo aquí en los ejercicios 00:28:37
si lo hemos repetido 00:28:40
un montón de veces 00:28:41
ejer 7, ah, vale, pero que el ejer 7 ya lo teníamos 00:28:42
pero he hecho 00:28:48
ah, vale 00:28:48
un segundito, a ver 00:28:52
el ejer 7 lo teníamos hecho así 00:28:53
Y tú planteas hacerlo de otra manera 00:28:56
¿Vale? ¿Qué manera? 00:28:58
¿Querías una variable que se llama 00:29:02
Número mayor? 00:29:04
Este va a ser nuestro resultado 00:29:05
El máximo 00:29:07
Este va a ser el resultado 00:29:08
Y ahora 00:29:11
Lo declaras desde primeras como número uno 00:29:12
Sí, y vas recorriendo los otros 00:29:15
Max N1 00:29:19
Y ahora 00:29:20
¿Lo haces? 00:29:21
O lo hacemos con el ternario 00:29:24
Si no, o bueno, venga 00:29:25
con if. Si el número 2 es mayor que el máximo, máximo igual a n2, ¿verdad? Vale. Y ahora 00:29:27
te irías con el tercero. Si n3 es mayor que el máximo, el nuevo máximo igual a n3. ¿Vale? 00:29:38
Entonces, este es otro algoritmo con la ventaja que es generalizable si tenemos un montón 00:29:49
de números, no solo tres. 00:29:56
Porque sería copiar este if un montón 00:29:58
de veces. 00:30:00
¿Vale? Entonces, 00:30:02
esto 00:30:04
que hemos hecho aquí también lo habéis entendido, ¿no? 00:30:06
Habría que ordenar el del medio también, ¿no? 00:30:08
No, no hace falta. No, no estamos ordenando. 00:30:10
Es decir, 00:30:13
esta es una manera de calcular el máximo 00:30:14
que se orienta en lo siguiente. 00:30:16
Tienes un montón de números. 00:30:17
Tu mente, aunque uno no lo crea, 00:30:20
procesa en secuencia, 00:30:23
no procesa en paralelo. 00:30:24
lo que pasa es que nos parece que es un paralelo 00:30:25
pero cuando tú ves siete números a la vez 00:30:27
de golpe, ¿cuál es el mayor? 00:30:30
tú dices, el doce 00:30:32
pues no lo has visto de golpe 00:30:33
ha sido uno por uno 00:30:36
y has cogido el primero 00:30:38
lo has comparado con otro 00:30:39
has dicho, oye, este primero yo creo que es el mayor 00:30:41
pero de repente ha aparecido este 00:30:44
ah, no, no, no, que este otro es mayor 00:30:46
pues ahora tengo un nuevo mayor 00:30:48
y te vas con el siguiente 00:30:50
el siguiente es más pequeño, paso de él 00:30:51
ah, no, el siguiente es mayor 00:30:54
pues me lo quedo y tengo un nuevo mayor 00:30:55
es el algoritmo que realmente hacemos 00:30:57
nos quedamos con un candidato 00:30:59
primero a mayor 00:31:01
vamos explorando los otros y si hay alguno 00:31:02
que lo supera, ese es el nuevo ganador 00:31:05
y si no lo supera, se va a la basura 00:31:07
pues este es el algoritmo 00:31:09
mi ganador 00:31:11
el primero, a ver si hay alguno que me supere 00:31:12
¿tú me superas? 00:31:15
sí, eres el nuevo ganador 00:31:17
ya está 00:31:19
tengo un nuevo ganador, sigo con los que me quedan 00:31:20
N3, tú me superas 00:31:23
eres nuevo ganador 00:31:25
y si me hubieran dado más números 00:31:26
pues yo podría hacer esto 00:31:29
un montón de veces 00:31:32
imaginaos que me hubieran dado N3 00:31:34
N1, N2, N3 00:31:46
¿vale? 00:31:58
silencio 00:32:02
entonces así lo podría fácilmente 00:32:03
generalizar, que me han dado 00:32:05
seis números, ¿cuál es el 00:32:07
máximo? asumo que es 00:32:09
el primero, oye tú 00:32:11
segundo me ganas, pues ahora eres tú 00:32:12
voy contigo, tú me ganas, pues ahora eres tú 00:32:14
ahora voy contigo, tú 00:32:17
me ganas, pues ahora eres tú 00:32:19
este algoritmo es más fácilmente generalizable 00:32:20
que el de 00:32:23
arriba, porque el de arriba 00:32:25
tendríamos varios el save 00:32:26
y cada el save con una condición muy grande 00:32:29
si tengo 6 números 00:32:31
esta condición 00:32:34
serían 00:32:35
5 cláusulas de LAN 00:32:37
sin embargo así queda como más claro 00:32:39
¿vale? 00:32:42
lo que pasa es que 00:32:44
lo ideal es meter esto en un bucle 00:32:45
y así no tengo que poner tantos saves seguidos 00:32:47
bueno, ya lo meteremos en un bucle 00:32:49
¡ala! pues venga, nos vamos 00:32:51
pero no me estoy haciendo ni puñetero caso 00:32:53
Estoy muy cansada de que no me hagáis ni caso. 00:32:55
Materias:
Programación
Niveles educativos:
▼ Mostrar / ocultar niveles
  • Formación Profesional
    • Ciclo formativo de grado superior
      • Primer Curso
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
3
Fecha:
19 de octubre de 2025 - 17:30
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
32′ 59″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
137.47 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid