Saltar navegación

20261009 SWITCH-CASE - 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 9 de octubre de 2026 por Raquel G.

1 visualizaciones

Más información Transcripción

Descargar la transcripción

Vale, vamos a recopilar las sentencias, la sintaxis de las sentencias de decisión que conocíamos. 00:00:00
Recordad que estábamos con la sentencia Java de decisión. 00:00:06
¿Cuándo aplica esa sentencia? 00:00:17
Pues esa sentencia aplica cuando mi programa puede que tiene dos caminos posibles. 00:00:20
Tiene dos caminos posibles. 00:00:27
O hace una cosa o hace la otra. 00:00:28
Dos caminos posibles. 00:00:30
O bien viene por aquí haciendo estas sentencias 00:00:31
O bien viene por aquí 00:00:35
Tiene dos caminos posibles 00:00:36
Entonces un programa no puede hacer dos cosas 00:00:38
O hace una o hace la otra 00:00:40
Bueno puede hacer dos y las hace en secuencia 00:00:43
Una detrás de otra 00:00:45
Pero no es esta la situación que estamos representando 00:00:45
Estamos representando 00:00:49
La situación de que mi programa 00:00:51
O bien hace esto o bien hace esto 00:00:52
Otro 00:00:55
En función de una condición 00:00:55
Que pueda ser cierta o no 00:00:58
Pues esta era la sentencia de decisión 00:00:59
En función de una condición 00:01:06
Hace una cosa o hace otra 00:01:08
Vale 00:01:09
Esa sintaxis ya la conocemos 00:01:11
Pero la sintaxis no es la dificultad 00:01:14
La dificultad es entender 00:01:16
En qué contexto 00:01:18
Tengo yo que aplicar esa sentencia 00:01:19
En qué contexto tengo que aplicarla 00:01:21
Entendiendo bien un enunciado 00:01:23
Pues aquí tengo que aplicar esta sentencia 00:01:25
Porque estoy en un contexto en el cual 00:01:27
O hago una cosa o hago otra 00:01:29
Esa es la parte difícil, no la de escribir el código. 00:01:31
Bueno, ¿qué otra parte difícil había? 00:01:36
Pues expresar la condición correctamente. 00:01:39
Expresar la condición correctamente. 00:01:43
¿Vale? Porque a mí me dirán las condiciones. 00:01:45
El que me está pidiendo un software, me lo dirá en su lenguaje natural 00:01:48
y yo lo tengo que traducir a expresiones de Java. 00:01:51
Ayer ya pusimos algunos ejemplos más grandes. 00:01:55
pues puede pasar a una atracción 00:01:57
que cumpla esto, pero siempre y cuando no tenga 00:01:59
no sé cuántos 00:02:01
o va a tener descuentos si el producto no está 00:02:02
en liquidación, pero siempre y cuando 00:02:05
seas cliente para ti, eso que te dicen 00:02:07
en palabras, hay que traducirlo 00:02:09
a Java, sobre eso 00:02:11
ya hicimos ejemplos ayer 00:02:13
y es la otra dificultad que hay 00:02:15
identificar bien la condición 00:02:17
bueno, lo siguiente 00:02:19
que incorporamos es 00:02:21
vale, ¿qué pasa si mi programa 00:02:23
tiene no solo dos caminos posibles 00:02:25
sino varios caminos posibles 00:02:27
pues si tiene varios caminos posibles 00:02:29
sí 00:02:32
esta sentencia if 00:02:33
nos vale igualmente 00:02:35
porque hacíamos lo siguiente 00:02:37
si tengo varios caminos posibles 00:02:39
pues yo voy incorporando condiciones 00:02:41
si esta condición es cierta 00:02:45
hago esto 00:02:48
que no lo es 00:02:48
siguiente condición 00:02:50
es cierto, hago esto 00:02:52
que no lo es 00:02:54
hago esto otro 00:02:57
¿vale? 00:03:01
entonces esta sentencia de aquí 00:03:04
este diagrama de flujo 00:03:07
tiene tres caminos posibles 00:03:08
camino 1, camino 2 y camino 3 00:03:10
el camino 1 si se cumple esta condición 00:03:12
el camino 2 si se cumple esta 00:03:15
y el 3 si no se cumple 00:03:17
ni esta ni esta 00:03:19
entonces esto es un if anidado 00:03:20
dentro del else de un if 00:03:23
que esto es lo que dijimos que escrito 00:03:24
queda muy feo, no es que esté mal, está bien como código, pero escrito queda feo, 00:03:26
pues entonces hacíamos esta sentencia de aquí, que Java nos lo permite, if, else if, etc. 00:03:33
Y así voy aquí. Se me ha olvidado la condición, claro. C2, el C3, el C, ya lo que sea. 00:03:47
Aquí ya tenemos un montón de caminos. Este camino, este camino, este camino, cada uno asociado a una condición. 00:04:14
bueno, lo que he contado 00:04:20
17 veces 00:04:22
vale, pues entonces, aplicando esto 00:04:24
hacer este ejercicio 00:04:27
que os he dicho aquí, sería muy fácil 00:04:29
vale 00:04:30
vale, pues este ejercicio que he dicho aquí 00:04:31
sería muy fácil 00:04:45
vale, vamos a arrancarlo 00:04:46
el 13 00:04:49
vale 00:04:51
pues venga 00:05:14
programa 00:05:17
que recibe un número entero 00:05:18
vale, muy bien, recibe un número entero 00:05:21
y te dice que día corresponde 00:05:24
si es uno, lunes, si es dos, martes 00:05:26
vale, entendido esto 00:05:28
aquí automáticamente ya vemos 00:05:30
que es un programa que puede tomar 00:05:32
hasta siete caminos distintos 00:05:34
después de haber leído lo que hace 00:05:36
ya tenemos que ver una especie 00:05:39
ya de diseño de diagrama en la cabeza 00:05:40
que ya nos va orientando 00:05:42
hacia dónde tirar 00:05:44
si hemos entendido esto ya decimos 00:05:45
Ah, vale, mi programa tiene siete posibles caminos. O mostrar es lunes, mostrar es martes, mostrar es miércoles, jueves, viernes, sábado y domingo. Tiene hasta siete posibilidades. ¿En función de qué? Pues de la condición correspondiente. Si el número es uno, dos y tres. 00:05:47
entonces un programa que tiene hasta 7 caminos distintos 00:06:03
en función de condiciones que yo puedo escribir 00:06:06
lógicamente, pues es un if-else-if 00:06:09
y ya está, entonces con lo que sabemos hasta ahora 00:06:12
pues este programa ya lo tendríamos esbozado 00:06:15
en la cabeza y sería sencillo 00:06:18
primero como siempre 00:06:20
leer el numerajo 00:06:22
leer los datos 00:06:25
copio de otro que ya lo tengo 00:06:28
introduzca número de día en este caso introduzca el número de día y ahora de 00:06:33
efectivamente este programa puede hacer hasta siete cosas posibles o mostrar 00:06:44
esto o mostrar esto o mostrar esto o mostrar esto o mostrar esto o esto 00:06:50
o esto, vale, siete caminos excluyentes 00:07:25
o hace uno, o hace el otro, o hace el otro, desde luego no en secuencia 00:07:36
son siete caminos excluyentes, luego esto es un if, el save, vale, cada 00:07:39
camino arrancará en función 00:07:43
de una condición, entonces yo tengo que asociar 00:07:47
qué condición marca que yo arranque por cada uno 00:07:51
de los caminos, es fácil de escribir esa condición, en este 00:07:56
caso sí, depende de este dato de entrada. Si el dato de entrada es igual a 1, pues ya está, será 00:08:00
esta. Ahora, siguiente rama, la siguiente rama será otro, el save, ¿vale? Asociada a la condición 00:08:11
correspondiente, pues que en un día sea igual a 2, ¿vale? Ya tengo las dos ramas, cada una asociada 00:08:23
una condición. Siguiente rama, asociada a la condición de que en un día sea igual 00:08:33
a tres. Siguiente rama, asociada a la condición, voy a ir copiando y pegando que será más 00:08:45
fácil, asociada a la condición de que sea cuatro. Siguiente, asociada a la condición 00:08:59
de que sea 5, siguiente 00:09:12
asociada a la condición de que sea 6 00:09:19
y aquí yo podría poner también 00:09:22
y siguiente asociada a la condición de que sea 7 00:09:28
vale, y esto está bien, y mi if else if se ha quedado sin else 00:09:31
no pasa nada, el else siempre es opcional 00:09:36
el else siempre es opcional, vale 00:09:38
eso significa que si se da esta condición hago esto 00:09:42
Y se acabó 00:09:46
Si no se da, miro la siguiente 00:09:47
Se da esta, hago esto 00:09:49
Y se acabó 00:09:51
Y así una tras otra 00:09:51
Cuando ya he llegado al final 00:09:53
Esta se da, sí, hago esto 00:09:54
Que no, se acabó 00:09:57
Y al no haber un else 00:09:58
En el caso de que sean falsas todas 00:10:00
Esta, esta, esta, todas falsas 00:10:03
No hace nada, porque no hay un else 00:10:05
El else ya sabéis que significa 00:10:07
¿Qué hago si todas las anteriores son falsas? 00:10:08
¿Qué hago si todas son falsas? 00:10:13
Aquí si no hay ningún else 00:10:14
Si todas son falsas 00:10:15
Porque ha introducido el número de día mal 00:10:17
No hace nada 00:10:19
Entonces bueno, ya que estamos 00:10:19
Pues podríamos poner 00:10:22
En cualquier otro caso 00:10:23
Poner el número de día introducido 00:10:25
Pues no es válido 00:10:26
En el caso 00:10:29
Este de aquí 00:10:31
Pues número de día 00:10:34
No válido 00:10:38
¿Vale? 00:10:39
¿Vale? 00:10:46
Así hemos hecho nuestro programa 00:10:47
Y esto, pues, como nos podemos imaginar, funciona. Es un programa facilito en el que no hemos tenido que pensar mucho. Y, lógicamente, si lo probamos, nos funcionará. Si yo pongo el día menos 9, pues, número de día no ha valido. Vale, nos funciona. 00:10:49
Bueno, hasta aquí vale, ¿no? 00:11:13
Vale, pues hay una tercera y, digamos, última sintaxis alternativa para la sentencia de decisión 00:11:18
que se aplica en el caso de que las condiciones sean exactamente que una variable sea igual a un valor. 00:11:28
Solo en ese caso, como es este ejemplo. 00:11:37
en general las condiciones que yo pongo aquí 00:11:39
lógicamente pueden ser las condiciones 00:11:42
todo lo grandes que yo quiera 00:11:44
y todo lo complejas que yo necesite 00:11:46
estas condiciones de aquí pueden ser complejísimas 00:11:47
como algunas de las condiciones que vimos ayer 00:11:51
la que sea 00:11:52
la que esté asociada a ese camino 00:11:54
la que sea 00:11:57
¿vale? 00:11:57
pero en el caso concreto 00:11:59
en el caso concreto 00:12:02
de que las condiciones 00:12:03
sean todas así 00:12:05
es decir, que el camino que se opta 00:12:08
dependa del valor de una variable 00:12:12
pues podemos poner una sintaxis alternativa 00:12:15
¿vale? 00:12:18
es una situación relativamente habitual 00:12:20
tú tienes un dato 00:12:22
y en función del valor de ese dato 00:12:23
haces unas cosas u otras 00:12:26
justo lo que tenemos aquí 00:12:28
tenemos un dato que es de un día 00:12:30
y en función del valor de ese dato 00:12:32
hacemos unas cosas u otras 00:12:34
¿vale? es una situación 00:12:35
relativamente habitual 00:12:37
que tiene una sintaxis propia 00:12:39
aunque podríamos hacerlo así 00:12:42
tiene su sintaxis propia 00:12:44
y es la sintaxis switch case 00:12:46
¿vale? 00:12:50
entonces repito 00:12:54
la sintaxis de decisión switch case 00:12:55
aplica solo 00:12:58
en el caso concreto 00:12:59
en que las diferentes condiciones 00:13:01
de las diferentes ramas 00:13:04
sean todas ellas 00:13:05
una misma variable 00:13:07
igual a un valor, de ahí viene lo de switch 00:13:08
que es, conmuta a una rama o conmuta a otra 00:13:12
en función del valor de una única variable 00:13:16
en función del valor de una única variable, conmutas una rama, conmutas a otra 00:13:18
bueno, pues con esa sintaxis, ¿cómo sería este mismo código? 00:13:23
pues la sintaxis es la siguiente, vale, la sintaxis de esta sentencia 00:13:30
es, se pone primero switch 00:13:47
y ahora entre paréntesis 00:13:50
la variable 00:13:53
cuyo valor vamos a mirar 00:13:55
para decidir por qué camino nos vamos 00:13:57
porque recordad 00:13:59
que esto de switch case se aplicaba 00:14:01
solo al caso 00:14:03
en los cuales las condiciones para los 00:14:05
diferentes caminos fueran 00:14:07
posibles valores de una única variable 00:14:09
pues aquí ponemos 00:14:12
esa única variable, vale 00:14:13
pues este switch sería 00:14:15
en función de la variable numDía 00:14:16
ahora ya en función de la variable en un día vamos distinguiendo los casos 1 a 1 00:14:19
caso de que mi variable 00:14:25
tome el valor, pongo case y luego el primer valor 00:14:30
posible que yo quiero contemplar, el primero que quiero contemplar 00:14:34
en este caso el 1, queremos contemplarlo, en el caso de que 00:14:37
sea 1, aquí pongo 2 puntos 00:14:42
y aquí la sentencia o la lista de sentencias 00:14:46
que se va a hacer en ese caso, aquí sin llaves 00:14:50
en este caso sería esto exclusivamente, sería esto de aquí 00:14:55
punto pelota, y acabo con un break 00:15:02
ahora indicamos por qué 00:15:07
y así voy definiendo cada uno de los casos 00:15:11
¿qué es? caso de que mi variable 00:15:17
numDía tome el valor 2, ese caso 00:15:20
Pues aquí lo que yo quiero hacer 00:15:24
Que en este caso 00:15:27
Quiero mostrar martes 00:15:29
Y termino 00:15:31
Con esto 00:15:33
Obligatorio 00:15:35
Ahora explicamos por qué 00:15:36
Y así iría poniendo cada caso 00:15:38
Cada una de las posibilidades 00:15:42
Que yo quiero contemplar 00:15:44
Para esa variable 00:15:46
No sé si he puesto ya suficientes 00:15:49
Caso 1, caso 2 00:15:53
caso 3, miércoles, caso 4, jueves, caso 5, viernes, caso 6, sábado, caso 7, domingo, vale, 00:15:55
Y el else donde se contempla, porque yo aquí tengo en mi else if, tengo un else si no se da ninguna de las anteriores. 00:16:35
En el switch case también puedo contemplar la rama en la que no se da ninguna de las anteriores. 00:16:47
Si la puedo contemplar poniendo default. 00:16:52
default significa 00:16:59
si la variable no toma 00:17:02
ninguno de los valores anteriores 00:17:05
si no toma ninguno 00:17:07
pues lo que yo quiero hacer aquí 00:17:09
número 00:17:15
de día 00:17:18
vale pues esta 00:17:20
sintaxis aquí 00:17:28
se ve más clara que la otra 00:17:30
haciendo lo mismo 00:17:32
queda más bonita 00:17:34
y se ve más claro 00:17:39
porque en cuanto tú ves esto 00:17:42
dices, ah vale, que se me abren 00:17:45
diferentes posibilidades 00:17:47
en función del valor de una variable 00:17:49
ya lo ves de partida 00:17:51
dices, este programa va de esto 00:17:52
de hacer diferentes cosas en función 00:17:54
del valor de una variable, va de esto 00:17:57
sin embargo, si tú esto mismo 00:17:58
lo ves en un if else if 00:18:01
la primera condición sabes que depende 00:18:02
del valor de la variable 00:18:05
pero para ver el tipo de condiciones 00:18:06
siguientes, a ver si dependen de esa 00:18:09
variable o dependen de otras cosas distintas, tienes que ir una por una 00:18:11
para ver esas condiciones cuáles son. Entonces 00:18:14
esto mismo hecho con el switch case queda más bonito 00:18:19
porque tú lo ves y dices, ah, vale, en función de esta variable pueden pasar 00:18:22
cosas distintas. Ya sabes que todo lo que viene después tiene que ver 00:18:27
exclusivamente con el valor de esta variable. 00:18:31
Y cada posible valor va 00:18:35
Acompañando a un case de estos 00:18:40
Este default se me ha ido 00:18:42
Vale 00:18:48
Entonces 00:18:52
Recordad lo que os digo siempre 00:18:54
Del estilo a la hora de escribir el código 00:18:58
Las tabulaciones correctas 00:19:00
Cuando yo entro dentro de un if o de un else 00:19:04
Las tabulaciones correctas 00:19:07
Dentro del main 00:19:09
Entonces no es que sea obligatorio 00:19:09
El código podría estar escrito todo seguido horrible 00:19:11
Que no se entendiera nada 00:19:13
Pero sería lo mismo 00:19:14
los saltos de línea y los espacios para el compilador no son nada 00:19:16
pero para el desarrollador sí, porque permite 00:19:20
de ver un código y entender de qué va a no entender nada 00:19:24
entonces seguramente ya habréis averiguado 00:19:27
que la combinación 00:19:32
control shift F 00:19:36
en el eclipse, en otros entornos de desarrollo 00:19:38
o sea, otra, en el eclipse, el control sheet F 00:19:43
te cambia el formato para dejarlo bonito, no te cambia 00:19:47
nada relacionado con el código, te cambia el formato para dejarlo bonito, ¿vale? 00:19:52
entonces yo aquí lo he descolocado, hago control sheet F y me lo deja bonito 00:19:55
¿vale? entonces 00:20:00
usadlo para dejarlo bonito, pero 00:20:03
una vez que tenéis el conocimiento de cuáles son las reglas de estilo 00:20:08
vale, una llave siempre se abre en la misma línea en la que empieza 00:20:12
su método 00:20:17
en este caso el if, aquí es que no he puesto llave, pero si hubiera puesto llave 00:20:21
que en este caso era opcional, pero vamos, si lo hubiera puesto, pues la llave se abre 00:20:24
en la misma línea donde está la sentencia que la provoca 00:20:31
se cierra en una línea nueva suya 00:20:36
para ella a la misma altura de donde arrancó 00:20:40
lo que esté dentro tabulado, etc 00:20:44
vale 00:20:46
entonces aquí el control shift F 00:20:48
pues el switch case lo deja así 00:20:51
todo a la vez 00:20:53
que a mi me resulta muy feo, yo lo veo más claro cuando está así 00:20:53
pero bueno 00:20:57
vamos a dejarlo como lo deja el 00:20:58
y ya está 00:21:00
vale, yo esto todo 00:21:02
lo tabularía porque lo veo más claro 00:21:04
así tabulado 00:21:07
lo dejaría así, switch y el case 00:21:07
dentro 00:21:11
pero bueno, si hacemos control shift F 00:21:11
pues él me pone a la misma altura 00:21:15
¿vale? switch case 00:21:17
todo juntito ahí 00:21:19
no pasa nada, es un convenio 00:21:20
también seguido 00:21:22
¿vale? 00:21:24
bueno, pues entonces 00:21:27
he entendido que esta sintaxis 00:21:28
es sólo cuando 00:21:31
las condiciones de las diferentes ramas 00:21:33
se corresponden 00:21:35
a posibles valores de una variable 00:21:37
sólo en ese caso, ¿vale? 00:21:39
Ahora ya, matices y detalles a conocer de la sentencia, vale, aquí se puede poner cualquier tipo de variable primitiva y string también, se usa para esos, primitivas y string, 00:21:41
Entonces si yo pusiera aquí un string 00:21:57
Como los posibles valores de string 00:21:59
Son cadenas, aquí tendría que poner una cadena de texto 00:22:02
Lógicamente 00:22:04
Si la variable que yo he puesto aquí 00:22:05
Es un string 00:22:08
Pues sus posibles valores tendrían que ser 00:22:09
Lógicamente compatibles con string 00:22:12
¿Vale? 00:22:14
Ahí yo tengo que poner un valor 00:22:15
Que es la posibilidad que yo contemplo 00:22:17
Para esa variable, del tipo que sea 00:22:20
Si es string, pues string, es que no hay otra 00:22:21
Eso por un lado 00:22:23
¿Vale? Vale 00:22:25
Por otro lado, se pueden poner varias posibilidades en la misma línea, ¿vale? Todas estas pequeñas variaciones se han ido incorporando en sucesivas versiones de Java, entonces a lo mejor uno ve un programa de hace tres o cuatro años que la mayoría de los códigos de las empresas, lógicamente, son código legado, que se llama, que son aplicaciones que están hechas hace mucho tiempo, 00:22:27
y yo no puedo de repente cambiarlas de arriba a abajo 00:22:56
solo porque Java incorpore 00:23:00
pequeñas modificaciones sintácticas 00:23:02
a modo de marketing 00:23:05
entonces, la mayoría de los desarrollos 00:23:07
tienen código compatible 00:23:12
con versiones antiguas 00:23:15
porque tú no puedes migrar de golpe 00:23:17
seguramente si tú haces una migración 00:23:19
así por las buenas 00:23:22
las aplicaciones que tienes ahí en los servidores 00:23:24
dando servicio, hasta que vuelvan 00:23:26
a estar operativas, a lo mejor pasa más tiempo 00:23:28
del que conviene, para tus intereses 00:23:30
entonces 00:23:32
las aplicaciones que vais a ver 00:23:34
por ahí, la gran mayoría tienen código 00:23:36
compatible con versiones antiguas 00:23:38
porque es que si no, no podemos estar 00:23:40
actualizando todo el rato 00:23:42
entonces el código compatible con versiones 00:23:43
antiguas 00:23:47
es el código que se llama legado 00:23:47
código legado 00:23:50
que 00:23:51
en los términos 00:23:52
informáticos que deberíais 00:23:56
ir incorporando 00:23:58
términos profesionales 00:23:59
de los que cuando uno habla 00:24:02
pues no le hace aparentar que sabe 00:24:04
porque no solo hay que saber 00:24:06
eso es fundamental 00:24:08
también tenéis que aparentarlo 00:24:09
para eso vuestro discurso 00:24:12
tiene que ser ya 00:24:15
manejando los términos 00:24:16
de desarrollo 00:24:19
todo eso 00:24:20
bueno pues este código 00:24:21
es código compatible 00:24:24
con versiones antiguas 00:24:27
que está en todos los desarrollos de todas las empresas 00:24:28
mucho más antiguos 00:24:31
de los que os podéis imaginar 00:24:32
hoy en el Recreo precisamente ha venido una alumna 00:24:33
a coger el título 00:24:36
que acabó hace dos años 00:24:37
y ha subido a vernos 00:24:40
y todo lo que me ha contado 00:24:42
de lo que siguen haciendo en Java 00:24:44
dice que seguimos estando 00:24:46
en la versión 1.8 00:24:48
¿vale? 00:24:50
porque no es tan fácil para las empresas 00:24:52
a seguir cambiando de... 00:24:54
Bueno, pues ¿por qué os cuento esto? 00:24:56
Porque algunas de las cosas que yo os estoy 00:24:58
diciendo aquí del switch case 00:25:00
solo las admiten 00:25:01
las versiones modernas de Java. 00:25:04
Claro, a lo mejor os vais 00:25:06
a un sitio y escribís, por ejemplo, 00:25:07
esto de poner 00:25:10
varias posibilidades separadas por comas 00:25:11
y el compilador se empeña en deciros 00:25:13
esto está mal, esto está mal, esto está mal. 00:25:15
No es que esté mal, es que el compilador 00:25:17
que tienen ahí es un poco más antiguo. 00:25:19
¿Vale? 00:25:22
entonces que sepáis que en Java 00:25:22
que está sacando versiones nuevas continuamente 00:25:25
y que esas versiones lo que hacen es 00:25:27
incorporar chorraditas 00:25:29
vale, pues a lo mejor usáis alguna 00:25:30
de esas chorraditas y dices está mal, está mal, está mal 00:25:33
no, es que esa chorradita 00:25:35
está a partir de esta versión 00:25:36
no está en la versión que tiene este servidor 00:25:38
vale 00:25:41
hay versiones 00:25:43
de Java que sí que hicieron 00:25:45
cambios esenciales 00:25:47
y siempre 00:25:49
es esta por en sí, por ejemplo 00:25:51
la 1.8 de hace un montón 00:25:52
esa hizo el cambio esencial 00:25:55
con toda la programación funcional 00:25:57
etcétera, que no vamos a tocar 00:25:59
este año porque es imposible 00:26:01
pues no hay 00:26:02
ninguna empresa que use 00:26:05
de 1.8 hacia atrás, eso no 00:26:07
porque 1.8 fue el cambio esencial 00:26:08
pero de 1.8 en adelante 00:26:10
lo más probable es que haya 00:26:12
muchos contextos de desarrollo 00:26:14
que ni lo utilicen, con lo cual esto 00:26:16
ni siquiera sería válido en esos contextos 00:26:19
esto ni siquiera sería válido 00:26:21
vale, bueno, pero nosotros 00:26:22
que estamos modernizados, pues si lo 00:26:25
podemos usar sin ningún problema 00:26:27
venga, más cosas 00:26:28
aparte de poder poner 00:26:30
varios en coma 00:26:33
muy bien, vale 00:26:34
perdón 00:26:39
que si puedo bajar 00:26:40
vale, a ver, más cosas 00:26:50
hemos dicho que estos valores 00:26:52
en general son o primitivos 00:26:54
o string, y lo que hay que poner aquí 00:26:56
es uno de los posibles valores 00:26:58
de la variable que esté aquí, si es string 00:27:00
pues cadena, lo que sea 00:27:02
que se pueden poner varios separados por comas 00:27:03
y ahora la pregunta es 00:27:06
¿por qué hay que poner el break 00:27:08
todo el rato? 00:27:10
bueno, porque por esta sentencia 00:27:13
por razones antiguas 00:27:15
de cuando se hizo en su momento 00:27:17
esta sentencia 00:27:18
funciona de la siguiente manera 00:27:20
primero coge la variable 00:27:21
y empieza desde el principio 00:27:24
esta variable tiene este valor 00:27:27
lo tiene, hace lo que hay dentro 00:27:29
y a partir 00:27:31
de ahí sigue 00:27:33
con el resto de los casos ya sin mirar 00:27:34
nada, sigue 00:27:37
hasta que se encuentre un break 00:27:38
entonces, si nosotros 00:27:40
no ponemos un break dentro de cada 00:27:43
case 00:27:45
y un día es igual a uno y este break no está 00:27:46
haría esto y seguiría 00:27:49
ya sin mirar los case, seguiría 00:27:51
hasta el siguiente break 00:27:53
y normalmente no ese es el efecto que queremos 00:27:54
normalmente el efecto que queremos es 00:27:57
si la variable tiene este valor, haz esto 00:27:59
y se acabó, no hagas nada más 00:28:01
pues entonces hay que poner el break detrás 00:28:03
pero si tiene este valor, haz esto 00:28:04
y se acabó, no hagas nada más 00:28:06
con lo cual tienes que poner el break detrás 00:28:08
porque si no pones el break 00:28:10
desde el momento en que entra en un case 00:28:11
él ya sigue hasta el siguiente break 00:28:13
si no hay siguiente break 00:28:16
sigue hasta el final haciéndolo todo 00:28:17
aunque no sean los case correctos 00:28:19
Entonces, la sentencia del switch case se diseñó así, precisamente, antiguamente, porque como no estaba la opción de poner varios casos con comas, como no estaba la opción esta que acabo de decir, de poner varias posibilidades con comas, 00:28:22
Si tú querías hacer varias 00:28:44
Para varios números 00:28:47
¿Vale? 00:28:50
Pues entonces tenías que quitar el break 00:28:51
Para que una vez que era un número te lo hiciera todo 00:28:52
Entonces tenías que jugar con ese break 00:28:54
Pero ahora ya eso ya no tiene sentido 00:28:56
Entonces 00:28:59
Ahora ya nosotros no vamos a jugar 00:29:02
Quitando y poniendo el break 00:29:05
Para hacer varias ramas a la vez 00:29:06
Si solo tengo un case cierto 00:29:08
Ya con eso no vamos a jugar nunca 00:29:10
entonces, lo ponemos porque hay que ponerlo 00:29:12
porque si no funciona, como hemos dicho 00:29:15
si no hay un break, desde el momento en que entran 00:29:17
un case, ya sigue 00:29:19
entonces lo ponemos porque hay que ponerlo 00:29:20
como hábito 00:29:23
y si queremos contemplar 00:29:24
varias posibilidades en el mismo 00:29:28
case, pues ya sabemos 00:29:29
separadas por comas y se acabó 00:29:30
bueno, y ya por último 00:29:33
último matiz del switch case 00:29:39
como ya el break 00:29:40
empezó a convertirse en una cosa molesta 00:29:43
que es jolines 00:29:45
que rollo tener que poner el break 00:29:47
cada vez 00:29:50
como ya empezó a convertirse en una cosa molesta 00:29:51
se admite 00:29:53
una sintaxis sin break 00:29:55
y no por ello 00:29:57
avanzando en todas las ramas 00:29:59
que de nuevo es una sintaxis relativamente nueva 00:30:01
entonces 00:30:04
habrá 00:30:05
sistemas que no la reconocen 00:30:06
y cuál es esa sintaxis 00:30:10
relativamente nueva 00:30:12
Que te permite olvidarte del break 00:30:13
Pues sería 00:30:16
Tú pones el case 00:30:17
Y en lugar de los dos puntos 00:30:19
Pones este simbolito de aquí 00:30:20
Guión mayor que 00:30:22
Y ahora entre llaves 00:30:25
Lo que hay que hacer en ese caso 00:30:26
Y ahí ni break ni nada 00:30:28
Esa es más bonita 00:30:30
Más elegante 00:30:32
Pero relativamente reciente 00:30:34
Con lo cual habrá versiones 00:30:36
De Java que el compilador 00:30:39
No las conozca 00:30:41
Entonces, esto mismo 00:30:42
Escrito con esa nueva versión 00:30:48
Que yo ya voy a ponerlo así siempre 00:30:50
Porque es la que más me gusta 00:30:53
Sería esto 00:30:54
En el caso 1 00:31:01
Quito la llave 00:31:03
Pongo esto 00:31:05
Y aquí abro mi llavecita 00:31:08
Y el break aquí me sobra 00:31:10
¿Vale? El break aquí me sobra 00:31:11
En el caso 2 00:31:14
Abro 00:31:18
Así 00:31:21
En el caso 3 00:31:25
A ver, voy a ir copiando y pegando 00:31:28
Para no perder tanto tiempo 00:31:31
En el caso 3 00:31:33
Lo mismo 00:31:36
En el caso 4 00:31:38
Ahora lo arreglamos 00:31:40
Lo mismo 00:31:41
En el caso 5 00:31:43
Mismo 00:31:45
Caso 6 00:31:48
caso 7 00:31:50
y caso default 00:31:54
vale, entonces caso 1, caso 2, caso 3 00:31:57
entonces aquí tengo que imprimir lunes, martes 00:32:02
miércoles 00:32:04
miércoles, jueves 00:32:07
viernes, sábado 00:32:17
Caso 7, domingo 00:32:25
Y aquí 00:32:28
Día no 00:32:32
Válido 00:32:35
Ala 00:32:36
¿Vale? 00:32:39
Pues esta sintaxis es la más bonita 00:32:43
Aquí no hay break 00:32:45
En el caso de que la variable tenga 1 00:32:46
¿Qué vamos a hacer? 00:32:49
¿Qué ha pasado? 00:32:50
Ah, jolines 00:32:51
Esta es la sintaxis más bonita 00:32:52
En el caso de que la variable tenga 1 00:32:54
¿Qué vamos a hacer? 00:32:57
Lo que hay en estas llaves 00:32:58
Y aquí me olvido del break y ya está 00:33:00
Y ya no se mira nada más, se acabó 00:33:02
En el caso de que tenga dos 00:33:04
¿Qué voy a hacer? 00:33:06
Uh, aquí es que el break 00:33:07
Con el copia y ahí 00:33:08
En el caso de que tenga dos 00:33:10
El shift F no quita todas las cosas 00:33:12
Así que tampoco tengáis 00:33:18
Vaya por Dios 00:33:19
Vale 00:33:21
Vale, pues nada, esta sería más bonita 00:33:27
Cuando encuentra 00:33:33
Un case que se cumple 00:33:35
hace lo que hay entre las llaves que puede ser una sentencia humil y ya no 00:33:36
hace nada más y ya está entonces bueno no hace falta que perdamos el tiempo 00:33:39
probándolo porque esto va a funcionar cualquiera de las tres versiones está la 00:33:46
vais a ver mucho por ahí porque es la ha sido la estándar de toda la vida mundial 00:33:51
pero esta es la más actualizada 00:33:58
bueno vamos a parar aquí un momentito 00:34:03
Materias:
Programación
Niveles educativos:
▼ Mostrar / ocultar niveles
  • Formación Profesional
    • Ciclo formativo de grado básico
      • Primer Curso
      • Segundo Curso
    • Ciclo formativo de grado medio
      • Primer Curso
      • Segundo Curso
    • Ciclo formativo de grado superior
      • Primer Curso
      • Segundo Curso
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
1
Fecha:
9 de octubre de 2026 - 14:08
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
34′ 07″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
311.77 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid