Saltar navegación

20241008 ProgrEstruct-Decision-Ejer_8 - 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 10 de octubre de 2024 por Raquel G.

14 visualizaciones

Más información Transcripción

Descargar la transcripción

venga, vamos a ver 00:00:00
a ver 00:00:02
a mi ver este 00:00:04
sistema es sincero, me da alergia 00:00:06
porque es una forma muy fea de salir de un programa 00:00:08
pero por ahora lo voy a dejar 00:00:10
vale, para poderlo poner todo así 00:00:11
sin necesidad de tabularlo 00:00:14
en un else 00:00:16
vale, pues nuestro programa tiene 00:00:16
tres posibilidades, uy que digo yo, tres 00:00:20
tiene siete posibilidades 00:00:22
es lunes, es martes, es miércoles, es jueves 00:00:24
es viernes o es domingo 00:00:26
¿verdad? ¿y de qué depende? 00:00:28
es verdad, el sábado no se me había olvidado 00:00:31
y el sábado, se me olvida el sábado 00:00:33
¿por qué será? bueno 00:00:37
¿y de qué depende? de una condición del numerito 00:00:39
pues ya está, uno ya lo 00:00:43
es que ya lo tiene todo cascado aquí, no tiene que volverse 00:00:45
loco, planta esto y se acabó 00:00:48
perdonen ustedes 00:00:52
Ahora 00:00:56
Perdón 00:00:57
Sí, está grabando 00:01:04
Vale 00:01:06
N no 00:01:07
Si N es igual a 1 00:01:10
Pues entonces lunes 00:01:12
A ver 00:01:14
Vale, entonces 00:01:21
El 6 00:01:30
N es igual a 2 00:01:34
Martes 00:01:36
Elseif 00:01:38
¿Lo podría dejar? 00:01:42
Podría dejar, de hecho, sin los elses 00:01:44
Y poner 00:01:46
Número igual a uno esto 00:01:47
A ver, espera, vamos a 00:01:51
Voy a dejarlo así 00:01:54
Pero bien puesto, claro 00:01:55
Número igual a tres 00:01:58
Espera, miércoles 00:02:02
Número igual a cuatro 00:02:04
Jueves 00:02:10
Número igual a cinco 00:02:11
Viernes 00:02:16
numes igual a 6 00:02:18
y me ha faltado uno 00:02:23
sábado 00:02:24
y numes igual a 7 00:02:25
domingo 00:02:36
vale, yo podría dejar mi programa así 00:02:39
y está bien hecho 00:02:44
lo que pasa es que 00:02:46
tiene un montón de sentencias if distintas 00:02:48
¿verdad? 00:02:50
esta primera, esta segunda 00:02:51
vale, aunque esto está bien hecho y funciona 00:02:53
¿cuál es la única 00:02:55
cosa fea que tiene? 00:02:58
es que a la máquina virtual 00:02:59
la estoy obligando a hacer 00:03:01
evaluaciones de condiciones 00:03:03
innecesariamente, ¿verdad? 00:03:05
Si dejamos el código así, la máquina virtual 00:03:07
evalúa esta, que se cumple 00:03:09
entra, se acabó la sentencia 00:03:11
nos vamos a la siguiente, evalúa 00:03:13
esta, que se cumple esta y se acabó la sentencia 00:03:15
nos vamos a la siguiente, con lo cual 00:03:18
la estoy obligando a evaluarlas 00:03:19
todas, sin embargo, si yo 00:03:21
esta ya es true, las demás 00:03:23
no quiero evaluarlas, ya no me interesan, ya sé que son 00:03:25
falsas, entonces 00:03:27
este código lo puedo dejar así y funciona 00:03:29
y está bien, pero la máquina virtual la tengo 00:03:31
haciendo esto, ahora haciendo 00:03:33
esto, ahora haciendo esto, pues para qué 00:03:35
qué necesidad 00:03:37
mucho mejor si lo metemos en una 00:03:38
else if, ¿verdad? 00:03:41
pero claro, la metemos 00:03:49
en un else if porque sabemos que 00:03:51
solo nos interesa una de todas 00:03:52
ellas, una, si nos 00:03:55
interesaran varias 00:03:57
no podríamos meterlo en un else if 00:03:58
vale, y esta ya no hace parte 00:04:00
que ponga un else if 00:04:05
la meto en el else que queda y se acabó 00:04:06
esta ya la meto en el else 00:04:09
vale 00:04:10
ahora ya este código es más bonito 00:04:15
tengo 00:04:19
7 posibilidades 00:04:19
un else if con 7 ramas 00:04:22
y funciona perfectamente 00:04:24
vale, entonces diréis 00:04:29
¿para qué has hecho esta chorrada de ejercicio? 00:04:30
bueno 00:04:33
para enseñar lo del sistema 00:04:33
no solo 00:04:36
vale, pero efectivamente 00:04:37
ahora que me lo recordáis 00:04:40
ahora ya cuando uno se pone 00:04:41
a dejar bonitas las cosas o lo que sea 00:04:44
pues efectivamente 00:04:45
podría decir, vamos a ver, voy a meter 00:04:47
esto en un else if de verdad 00:04:50
y la condición 00:04:51
restante 00:04:53
que sería 00:04:54
que no fueran válido 00:04:57
pues en esa ya digo bye bye 00:05:00
y ya no tengo que poner ni system exit 00:05:01
ni nada, porque el system exit 00:05:04
es como una sentencia de ruptura 00:05:06
de los antiguos lenguajes 00:05:08
no estructurados, que hay veces 00:05:10
que hay que ponerla, porque yo tengo que salir en ese momento 00:05:12
pero es innecesaria 00:05:14
entonces, si yo cambio esto 00:05:15
y pongo aquí mi mensajito de salida 00:05:23
claro, lo comentaré 00:05:25
si yo lo pongo así 00:05:29
ahora ya no necesito ni system exit 00:05:31
ni nada, porque si el número no es válido 00:05:33
va a irse aquí 00:05:35
vamos a ir al mensaje y ya, va a ir a la siguiente 00:05:37
como la siguiente no existe 00:05:39
va a terminar, y esa es la forma 00:05:41
buena de acabar los programas, que acaben 00:05:43
porque han terminado las sentencias 00:05:45
no porque yo en mitad, porque me ha dado la gana 00:05:47
le he dicho, eh, rompe 00:05:49
la forma buena de 00:05:51
construir un código 00:05:53
es de tal manera que yo lo hago para que 00:05:54
cuando haya acabado 00:05:57
las sentencias, en ese momento el código termine 00:05:59
entonces 00:06:01
una vez que ya he hecho yo mi código, digo 00:06:03
hombre, queda mucho más bonito si yo digo 00:06:05
vamos a ver, voy a meter una rama 00:06:07
más y si no es ninguno de los anteriores 00:06:09
pues ya está, no es válido 00:06:11
y se acabó, en ese caso esto 00:06:13
de aquí nos sobraría y por eso lo voy a 00:06:15
comentar, lo voy a dejar ahí comentado 00:06:17
para que no se os olvide que bueno, que esto 00:06:19
existe, pero no lo uséis 00:06:21
a ser posible 00:06:23
claro, es que lo he comentado 00:06:25
a todos, a todo esto fuera 00:06:29
simplemente el código se ha quedado 00:06:30
aquí, vale, y mucho más 00:06:33
bonito así 00:06:35
vale 00:06:35
entonces, aun siendo bonito 00:06:37
todavía puede ser más bonito 00:06:39
pero 00:06:42
mucho más 00:06:43
ya, pero no porque lo compactemos 00:06:45
porque es que eso no se puede compactar 00:06:48
o sea, es que eso son esas condiciones y las tengo que evaluar 00:06:50
sí o sí 00:06:52
no hay tutía, vale 00:06:52
pero, existe 00:06:55
otra forma de expresar la sentencia 00:06:57
de decisión, ahora mismo conocemos 00:07:00
para las decisiones en general 00:07:02
El famoso operador ternario 00:07:04
Que ahora ya 00:07:06
Vemos clarísimamente 00:07:08
Que es un if en realidad 00:07:09
Ahora ya vemos 00:07:11
Más claro que nunca 00:07:15
Que cuando hemos hecho antes 00:07:18
Una sentencia de decisión 00:07:22
Pues de este estilo 00:07:24
Int n 00:07:26
Se cumple esta condición 00:07:27
Entonces le doy el valor 3 00:07:30
Si no le doy el 7 00:07:32
Ahora ya sí que vemos que lo que estábamos haciendo cuando hacíamos esto era esto en realidad, ¿no? 00:07:34
Si se cumple la condición n igual a 3, el se n igual a 7, ¿vale? 00:07:39
Esto es una forma en una única línea de escribir esto, pero es lo mismo, ahora ya lo vemos, ¿no? 00:07:48
Ahora ya que tenemos la sentencia i, vemos que esto es una manera de escribir esto de aquí, ¿no? 00:07:55
Que cuando estamos asignando un valor a una variable 00:08:00
o este o este 00:08:03
y solamente eso 00:08:04
pues esas dos alternativas de asignación 00:08:06
esas dos alternativas de asignación 00:08:09
las podemos poner aquí 00:08:11
en la asignación condicional, ¿vale? 00:08:12
Bueno, pues entonces 00:08:15
formas de hacer condiciones 00:08:16
ya hemos visto esto, repito 00:08:19
pero esto solamente es válido 00:08:21
cuando lo que yo quiero hacer es la asignación 00:08:23
de un valor a una variable 00:08:25
¿vale? El if general 00:08:26
que es válido para lo que me dé a mí la gana hacer 00:08:29
por supuesto 00:08:32
y luego el if, el save 00:08:33
cuando yo tengo un if anidado 00:08:34
y lo quiero compactar 00:08:37
y ya sé que eso 00:08:39
pues se traduce en última instancia 00:08:40
a tener varias ramas 00:08:43
excluyentes 00:08:45
en función de varias condiciones 00:08:45
esa es toda la sintaxis de decisión que hemos visto 00:08:48
vale 00:08:50
pues en el caso particular 00:08:51
de que yo veo efectivamente 00:08:54
que tengo un programa con varias posibilidades 00:08:56
varias ramas 00:08:58
¿y de qué depende irme por una o por otra? 00:08:59
depende del valor de una variable 00:09:02
y depende de eso 00:09:04
pues este caso es ese caso concreto 00:09:05
tengo varias ramas 00:09:09
y dependen de lo que valga 00:09:11
una variable 00:09:13
no dependen de otra condición más compleja 00:09:13
sino de lo que valga 00:09:17
una variable, pues en ese caso concreto 00:09:19
en el cual 00:09:21
la rama por la que me voy 00:09:23
depende de si num es este valor 00:09:24
o si num es igual a este, o si num es igual a este otro, en ese caso concreto, podemos usar otra sentencia, que es la sentencia switch, que lo va a dejar más claro, vale, pues entonces, este mismo código, esto mismo hecho con esa sentencia switch, vale, ¿cómo se hace?, pues se escribe la palabra de java switch, vale, 00:09:26
luego que se escribe 00:09:52
entre paréntesis 00:09:55
la variable 00:09:57
¿vale? 00:09:59
de la que en función de su valor hacemos una cosa 00:10:01
u otra, en mi caso ¿cuál es? 00:10:03
de la variable num, depende del valor de num 00:10:05
vale 00:10:07
y ahora abrimos el bloque 00:10:09
del switch 00:10:11
y ahora empezamos a distinguir los casos 00:10:12
que num es este valor 00:10:14
hago todo esto, que num es este valor 00:10:17
hago todo esto, ¿y cómo se distinguen los casos? 00:10:19
Pues con la palabra reservada, case, esta de aquí, espacio y el valor, el posible valor, 1, 2 puntos y ahora ponemos después de esos 2 puntos las sentencias. 00:10:22
En mi caso era lunes, pero pueden ser muchas. 00:10:36
Vale, y una vez que yo he puesto todas las sentencias que quiero que se hagan en el caso de que num sea igual a 1, que en este caso solo es una, pero podrían ser muchas, 00:10:44
una vez que las he puesto 00:10:54
calzo y un break 00:10:56
que ahora ya 00:11:00
veremos por qué 00:11:02
en el caso 2, pues lo mismo 00:11:03
pero martes 00:11:09
caso 3 00:11:10
lo mismo 00:11:28
pero miércoles 00:11:30
5, viernes 00:11:35
6, sábado 00:11:57
y 7 00:12:08
sí, un segundito 00:12:14
Venga, a ver 00:12:16
Vale, miércoles, domingo 00:12:20
Mira, este se acaba de despertar 00:12:23
Y no sabe ni de qué está 00:12:28
Ah, ya, ya, ya 00:12:31
Bueno, venga, a ver, entonces, la sentencia switch case 00:12:34
Silencio 00:12:37
Esta sentencia es otra manera de 00:12:40
Plantear un programa que va por varias ramas 00:12:42
como en el nuestro, que va por la rama de mostrar 00:12:46
lunes, mostrar martes, mostrar miércoles. 00:12:48
¿Y de qué depende que vaya por una rama o por otra? 00:12:49
Depende del valor de una variable. 00:12:52
¿Vale? No es como el 00:12:54
el safe es general. 00:12:56
En el safe que vaya 00:12:58
que 00:12:59
en el safe que vaya de una rama 00:13:01
que vaya por una rama o por otra, 00:13:08
depende de la condición que haya aquí. Esta condición 00:13:10
puede ser cualquiera, una condición muy 00:13:12
compleja, lo que sea. 00:13:14
¿Vale? 00:13:16
Entonces, el safe es general. 00:13:17
puedo ir por varias ramas dependiendo de la condición 00:13:18
que a mí me dé la gana 00:13:21
en el switch case 00:13:22
yo puedo ir por varias ramas 00:13:24
pero depende del valor 00:13:27
de una variable 00:13:29
solamente para ese caso usamos esa sentencia 00:13:30
solo para ese caso 00:13:33
bueno, pues en este caso, la sintaxis 00:13:34
¿cuál sería? entre paréntesis siempre 00:13:36
la variable de la cual depende 00:13:39
y luego, seguido del case 00:13:40
los posibles valores que contemplamos 00:13:42
lo que haya que hacer 00:13:45
que pueden ser una o muchas 00:13:47
y luego seguido de break 00:13:48
yo aquí tenía 7 casos 00:13:50
y me diréis 00:13:52
y si no es ninguno de los anteriores 00:13:53
porque el save te permitía un else 00:13:55
y si no es ninguno de los anteriores 00:13:57
pues este también, si no es ninguno de los anteriores 00:13:59
tú pones aquí un default 00:14:02
y el default significa 00:14:04
no ha sido ninguna de las anteriores 00:14:07
y en este caso 00:14:09
sería este mensajito 00:14:11
de salir 00:14:13
bueno pues 00:14:14
es otra posibilidad 00:14:18
usar esta sentencia 00:14:22
y queda más bonito 00:14:23
porque cuando uno 00:14:26
identifica rápidamente, ah, que en función de una 00:14:28
variable hago esto, hago esto, hago esto 00:14:30
pues ya está, ya automáticamente 00:14:32
automáticamente pienso en el switch case 00:14:34
lo planto y ya 00:14:36
el que lo ve ahí dice, ah, vale 00:14:38
ya ve rápidamente que esta variable 00:14:40
es como si fuera 00:14:42
la que manda 00:14:43
y esta variable es la que su valor 00:14:46
manda para decidir algo 00:14:48
lo ve uno ahí más rápido que en un 00:14:49
infelsafe, que tiene que meterse en la condición, etc. 00:14:52
¿En el deporte 00:14:55
falta un break? No. 00:14:55
Lo del break ahora lo vamos más a ello. 00:14:57
¿Vale? Esta sería la sintaxis 00:15:00
general de cómo funciona. 00:15:02
Y en los casos en los que se usa. 00:15:03
Que está claro en qué casos se usa. En los casos en los cuales 00:15:05
las diferentes ramas dependen de una variable. 00:15:08
Del valor de una variable. 00:15:10
Vale. 00:15:11
Y aquí yo he puesto un entero. 00:15:12
Pero podría ser una variable 00:15:14
de cualquier tipo primitivo. 00:15:16
Incluyendo 00:15:21
el string 00:15:21
o sea, hasta cierta versión 00:15:22
de Java 00:15:25
no sé cuál, no se 00:15:27
podían poner variables 00:15:29
no primitivas ahí 00:15:31
pero a partir de 00:15:33
ya la 10 o no sé cuál 00:15:35
y así se puede, es decir, yo podría hacer un switch case 00:15:37
así también 00:15:39
en el, por ejemplo 00:15:40
tenemos aquí 00:15:43
un string que yo he leído por teclado 00:15:44
o lo que sea 00:15:49
tengo yo aquí un string 00:15:51
vale, y ahora en función 00:15:52
del valor de esta cadena 00:15:57
quiero hacer una cosa, quiero hacer otra 00:15:58
vale, pues pongo aquí el nombre de la variable 00:16:00
en función de la cual 00:16:03
tomo la decisión, y ahora en los 00:16:05
case, tomo los valores 00:16:07
que yo quiero contemplar, pues que 00:16:08
la cadena contiene esto 00:16:11
y pongo 00:16:13
un valor compatible con una cadena 00:16:15
aquí he puesto un valor 00:16:17
compatible 00:16:19
con un número, que es 00:16:19
1, como podría poner 7, 28 00:16:22
menos 2, vale 00:16:24
yo aquí pongo cualquier 00:16:26
valor compatible con la variable 00:16:28
en este caso un valor entero porque num es 00:16:30
entero, entonces como num es 00:16:32
entero, todo lo que yo ponga 00:16:34
aquí tienen que ser números enteros 00:16:36
números enteros, vale 00:16:38
aquí esto 00:16:40
¿veis? 00:16:47
claro 00:16:51
porque quería poner una variable 00:16:51
pero como no tenía más variables declaradas 00:16:52
imaginaos que yo pongo aquí esto 00:16:55
porque esto sí que no lo puedo 00:17:00
en cualquier cosa, ¿vale? 00:17:02
n igual a 1 00:17:03
¿vale? y quiero poner esto 00:17:06
me podríais decir 00:17:11
oye 00:17:12
y esto no me deja, yo quiero decir 00:17:13
en el caso de que num sea 1 00:17:16
pero uno lo guarda en una variable 00:17:18
y le pasa, no 00:17:20
no es para usarlo así 00:17:21
esta sentencia, no es para usarlo así 00:17:24
si yo quiero esto 00:17:26
tendría que hacer un if, if num 00:17:28
doble igual n 00:17:30
porque entonces sí 00:17:31
pero esta sentencia es para 00:17:34
comparar el valor de una variable 00:17:36
con valores concretos, para ese caso 00:17:38
con valores constantes 00:17:40
que se llaman, pero bueno, el concepto de constante todavía no lo tenemos 00:17:42
entonces, que os quede ahora 00:17:44
que aquí es para valores concretos 00:17:46
entonces esta sentencia pega cuando tienes 00:17:48
un conjunto de valores concretos 00:17:50
que ya lo sabes, 3, 7, 12 00:17:52
o en el caso de una cadena, hola, adiós, no sé qué 00:17:54
y quieres hacer una cosa u otra 00:17:56
en función de si nos movemos 00:17:58
en alguno de esos valores concretos 00:18:00
que tú ya sabes y conoces 00:18:02
que en este caso eran 1, 2, 3, 4, 5, 6, 7 00:18:04
¿vale? 00:18:06
pero aquí no ponemos variables 00:18:08
bueno, pues en este caso 00:18:10
esto se adapta a lo que queríamos 00:18:13
yo tengo un conjunto 00:18:15
de valores concretos 00:18:17
1, 2, 3, 4, 5, 6 y 7 00:18:18
y en función 00:18:20
de si una variable toma 00:18:22
S o S o S o S concreto 00:18:24
quiero hacer una cosa u otra 00:18:26
pues estoy en ese caso, pues entonces en ese caso 00:18:27
si se adapta a esto 00:18:30
¿vale? 00:18:31
lo que estábamos diciendo 00:18:33
poner tipos compatibles 00:18:35
aquí he puesto esto porque estos son números enteros 00:18:37
pero si mi switch tiene dentro 00:18:39
una variable string 00:18:42
aquí tendré que poner tipos compatibles 00:18:43
con string 00:18:46
¿vale? 00:18:46
lo que sea 00:18:55
¿vale? entonces el tipo que ponga aquí 00:18:56
tiene que ser compatible con la variable 00:18:59
el switch case se usa en general 00:19:01
pues con números enteros 00:19:04
en función de una variable entera 00:19:06
si toma un valor de un conjunto 00:19:07
o con cadenas, yo tengo una cadena 00:19:10
y si la cadena es nombre, hago una cosa 00:19:12
es apellido, hago otra cosa 00:19:14
vale 00:19:15
antes no se permitía que aquí hubiera 00:19:17
repito, tipos primitivos 00:19:20
de hecho 00:19:22
vamos a por 00:19:23
curiosidad, como sé que sois muy curiosos 00:19:25
vamos a ver en qué versión de Java 00:19:27
se incorporó poder meter en un switch case 00:19:29
tipos primitivos 00:19:32
y lo vamos a ver con un truco 00:19:33
a ver, vamos a poner 00:19:35
la lupa 00:19:38
nosotros aquí hasta ahora, esta estructura 00:19:38
ya estáis medio 00:19:44
familiarizados con ella, ¿verdad? 00:19:46
es la estructura de un proyecto de Java 00:19:48
la estructura de un proyecto de Java 00:19:49
donde a partir 00:19:52
de aquí, cuelgan lo que 00:19:54
yo he llamado paquetes 00:19:56
que son carpetitas con mis clases 00:19:59
y ya está 00:20:00
y dentro de esas carpetitas, que todavía no entendemos bien lo que son 00:20:01
pero por ahora nos vale, dentro de esas carpetitas 00:20:04
que se llaman paquetes 00:20:06
en Java, yo ya pongo mis clases 00:20:08
y cada clase un programa, dentro de su main 00:20:10
y todo, es en el punto del que estamos 00:20:12
ahora, vale 00:20:14
entonces, ¿qué ocurre con los códigos 00:20:16
que ponemos aquí, que se compilan 00:20:18
automáticamente, gracias a que 00:20:20
lo estamos haciendo en el Eclipse, si no tendríamos 00:20:22
que ir uno por uno con Java C, bla bla bla 00:20:24
Java C, bla bla bla, pero eso se compila automáticamente 00:20:26
bueno 00:20:28
y estamos en ese punto 00:20:28
bueno, pues aparte de eso aquí ya hay un montón 00:20:31
de rollos, de historias 00:20:34
y una de ellas 00:20:35
de particularidades de los proyectos 00:20:37
una de ellas es que yo puedo elegir 00:20:40
como hay muchas versiones de Java 00:20:42
desde la primera estable 00:20:43
ya buena que hubo 00:20:46
que es la Java 1.2, la 2 00:20:47
hasta ahora, la 22, la 23 00:20:49
o la 24, no sé cuál está ahora 00:20:51
pues ha habido muchas 00:20:53
algunas han sido más 00:20:55
innovadoras que otras y desde 00:20:57
la 8 hasta ahora, tampoco es que haya 00:20:59
habido muchas cosas. Bueno, pues 00:21:02
entonces, como ha habido varias versiones, 00:21:04
tú puedes decidir 00:21:06
tu programa en concreto 00:21:07
con qué versión lo quieres compilar. 00:21:09
¿Con qué versión lo quieres compilar? 00:21:12
¿Vale? Porque imagínate que estás 00:21:14
trabajando con servidores 00:21:16
que tienen la máquina virtual 00:21:17
de la versión 1.8. 00:21:19
Pues entonces, 00:21:23
tu programa lo tienes que compilar 00:21:24
con la versión 1.8. 00:21:25
Porque si no, cuando esa máquina virtual trate de interpretarla, no lo va a entender. 00:21:28
¿Vale? No lo va a entender. 00:21:33
Entonces, tú puedes elegir con qué nivel compilas. 00:21:35
Y tienes que compilar con un nivel que sea el que luego tiene la máquina virtual con la que vas a ejecutar. 00:21:37
¿Vale? 00:21:45
Entonces, ese nivel de compilación, ¿dónde se cambia? 00:21:46
Pues nosotros no lo estamos cambiando porque estamos dejando el que trae por defecto. 00:21:51
Pero si le damos aquí botón derecho, no lo hagáis vosotros. 00:21:54
Es solo para, bueno, hacedlo si queréis 00:21:56
Pero vamos, que le dais aquí a botón derecho 00:21:59
Y le vais, vale 00:22:01
Le dais a propiedades 00:22:03
Del proyecto 00:22:05
Bueno, voy a quitar la lupa 00:22:08
Para abrir las propiedades y luego lo abro otra vez 00:22:16
Vale 00:22:18
Ahí está 00:22:23
Si os vais a 00:22:25
Las propiedades del proyecto 00:22:27
Veis que hay una cosa 00:22:29
Que dice aquí Java compile 00:22:32
Vale, pues pincháis ahí 00:22:34
y dice con qué nivel de compilación estáis 00:22:36
yo estoy aquí en el 21 00:22:38
no sé en el que estáis vosotros 00:22:40
22, 23, no lo sé, da igual 00:22:42
da un poco lo mismo 00:22:43
pero 00:22:45
podría cambiarlo, vale 00:22:46
si desactivo esta pestañita de aquí 00:22:49
lo puedo cambiar y decir 00:22:52
compílame uno más bajo, el más bajo que me permite 00:22:54
es el 1.3, vale 00:22:56
pues voy a cambiarlo al nivel 00:22:58
de compilación al 1.8 00:23:00
que es uno 00:23:02
en el que trabajan la mayoría 00:23:04
de las máquinas virtuales de los servidores 00:23:05
de las empresas porque fue 00:23:07
el que introdujo ciertas cosas 00:23:09
y ya 00:23:11
migrar de ahí ha sido complicado 00:23:12
en muchas empresas, pues bueno 00:23:15
yo voy a bajar al nivel de compilación 1.8 00:23:17
porque ese es bueno 00:23:19
y la empresa me ha dicho, compila 00:23:21
1.8 porque como compiles por encima 00:23:23
mi servidor no te lo va a interpretar 00:23:25
vale 00:23:27
bajo a 1.8, apply and close 00:23:28
me dice 00:23:31
tengo que recompilártelo otra vez 00:23:33
Al 1.8, ¿te lo recompilo? Sí, vale 00:23:35
Vale, ¿me lo ha recompilado? 00:23:37
Vale, pues el 1.8 00:23:39
Todavía me permitía 00:23:41
Utilizar 00:23:44
String como variables 00:23:45
Va a ser 1.7 00:23:47
Vamos a ver 00:23:48
Voy a bajar al 1.7 00:23:50
Recompila 00:23:54
Vale 00:23:58
Y aquí, ah, no, es que igual ya me había aparecido antes y no lo he visto 00:24:00
¿Veis? 00:24:03
Aquí ya me ha aparecido 00:24:05
Vale 00:24:08
Un momentito 00:24:09
Vale, todavía no me ha aparecido 00:24:17
Un momento 00:24:26
Venga, vamos a bajar 00:24:27
Al 1, 5 00:24:37
Ahí está, bueno, debe ser el 00:24:42
Y a ver un momentito, el 1, 6 00:24:44
El 1, 6 tampoco, y el 1, 7 00:24:46
El 1, 7 ya sí 00:24:57
Vale, entonces fue 00:25:05
El 1, 6, vale 00:25:06
vale, pues esto es como curiosidad 00:25:08
para introducir los niveles de compilación 00:25:14
entonces yo he compilado el 1.6 00:25:16
y me ha aparecido aquí un error 00:25:17
y este error me dice, ojo no puedes 00:25:19
usar una variable 00:25:22
que no sea primitiva 00:25:24
o sea, string no es primitiva, es objeto 00:25:26
en una sentencia switch, no puedes 00:25:28
porque para la versión 1.6 de Java 00:25:30
todavía no se podía 00:25:32
vale, la 1.7 ya sí, entonces si yo ya recompilo 00:25:33
a la 1.7 o a la última 00:25:37
que tengo 00:25:39
que en mi caso es 00:25:39
la 22, pero no sé 00:25:42
qué máquina virtual tengo, entonces 00:25:44
voy a 00:25:46
voy a dejar 00:25:48
la que tenía, porque mi máquina virtual creo que es la 21 00:25:50
vale, si yo recomplio la 21, ya 00:25:52
se me quita ese ruido, ¿vale? entonces 00:25:56
¿qué querían 00:25:58
simplemente introduciros con esto? que de unas 00:25:59
versiones de Java a otras 00:26:02
hay pequeñas cosas que se han introducido 00:26:03
entonces, a lo mejor 00:26:06
nosotros aquí estamos con la última 00:26:07
versión porque es la maqueta 00:26:10
que ponemos al principio del curso 00:26:11
pero a lo mejor probáis esto 00:26:13
en otras versiones de Java anteriores 00:26:15
y dices, ¿y este error de compilación por qué me sale? 00:26:17
igual es porque 00:26:20
no se había incorporado 00:26:21
esa sintaxis todavía en esa versión 00:26:23
¿vale? entonces que sepáis 00:26:25
que existen diferentes versiones de Java 00:26:27
yo puedo compilar a cada versión 00:26:29
y que puede haber diferencias 00:26:31
mínimas, pero puede haberlas 00:26:33
entre unas y otras, ¿vale? 00:26:35
por si a uno de repente le aparece algo raro 00:26:37
que sepa que de ese hilo podría tirar 00:26:39
bueno, pues en nuestro caso 00:26:41
como ya estamos por encima 00:26:43
de la 1.6, bastante por encima de la 1.6 00:26:45
podemos usar 00:26:47
un string aquí dentro 00:26:49
el break, diréis 00:26:51
¿y ese break? ¿qué hace ahí ese break? 00:26:55
¿es obligatorio ponerlo? 00:26:58
depende 00:27:00
del efecto que yo quiera 00:27:01
depende 00:27:03
si yo no pongo break 00:27:04
¿Qué hace la máquina virtual? 00:27:07
Es un comportamiento extraño 00:27:10
Pero luego 00:27:12
Evalúa esto 00:27:12
O sea, coge este numerito 00:27:15
Que es igual a num, entra aquí 00:27:17
Y ya sigue 00:27:19
Como un rodillo 00:27:22
Sigue hacia abajo hasta que se encuentre un break 00:27:24
Al margen de que 00:27:26
Este coincida o no 00:27:28
Da igual 00:27:30
Al margen de que coincida o no 00:27:31
Imaginaos que a mí se me ha olvidado aquí poner 00:27:33
estos dos break, porque se me ha olvidado. 00:27:35
Entonces, si el numerito fuera 1, 00:27:38
si el numerito fuera 1, 00:27:40
entraría aquí. Estupendo, ha entrado ahí. 00:27:42
Pero es que ya después 00:27:45
ya se pondría como tonto. 00:27:46
Ya sigue en piloto automático. 00:27:48
Sigue y sigue hacia abajo. 00:27:50
Es decir, empieza a ejecutar 00:27:52
desde que encuentra un valor 00:27:54
que es igual. 00:27:56
Y desde que encuentra un valor que es igual 00:27:58
hasta que encuentre un break. 00:28:00
No hasta el siguiente case. 00:28:02
No hasta el siguiente case. 00:28:04
entonces eso puede inducir a confusión 00:28:05
porque es antiintuitivo 00:28:09
completamente 00:28:11
¿vale? es completamente 00:28:11
antiintuitivo, uno ve esto y dice 00:28:16
hombre 00:28:18
si es uno hago esto 00:28:18
y ya está, y si es dos hago esto 00:28:22
y ya está, y si es tres hago esto 00:28:24
por eso se llama en el caso uno esto, en el caso dos 00:28:26
pues no, no funciona así 00:28:28
si es uno hago esto 00:28:30
pero no es hago esto 00:28:32
si es uno arranco a partir de ahí 00:28:34
es lo que significa 00:28:36
si es uno, arranco a partir de ahí 00:28:37
y sigo hasta que me encuentre un breve 00:28:39
y sigo, ya es que esto ni lo miro 00:28:42
luego este switch 00:28:44
tiene ese funcionamiento 00:28:47
porque si lo queremos aprovechar de alguna manera 00:28:48
¿vale? 00:28:50
entonces, porque a lo mejor 00:28:52
lo queremos aprovechar y decir 00:28:54
oye, en cuanto se encuentre una variable 00:28:55
que ya es igual, que haga todo lo que venga a continuación 00:28:58
en cuanto se encuentre una 00:29:00
que ya es igual, lo haga toda 00:29:02
si yo quiero usar ese comportamiento, vale 00:29:03
pero si yo lo quiero usar como comportamiento 00:29:05
de ramas excluyentes 00:29:08
o hace una, o hace la otra, o hace la otra 00:29:09
o hace la otra, tengo que poner el break 00:29:11
no se me puede olvidar 00:29:14
entonces con break o sin break son dos significados 00:29:15
si no tengo break 00:29:18
en cuanto encuentra un número 00:29:21
que es igual a este 00:29:23
entra y empieza 00:29:24
desde ahí, sin break significa 00:29:27
arranco y sigo 00:29:30
ya estos case como si no existieran 00:29:31
sigo cuando, sigo hasta que me encuentre 00:29:33
un break, claro, que este break 00:29:35
ya sí que está puesto 00:29:37
pues en el caso de que la variable es a uno 00:29:39
me haría esta, me haría esta y me haría esta 00:29:41
luego uno 00:29:43
me haría estos tres casos 00:29:45
si la variable es dos, me haría estos dos 00:29:47
si la variable es tres 00:29:49
me haría este solo 00:29:51
pues si queremos utilizar ese 00:29:52
uso, pues lo usamos 00:29:55
¿vale? 00:29:57
pero normalmente la switch case la usamos 00:29:59
para o me voy por una 00:30:01
o me voy por otra, o me voy por otra 00:30:03
Es decir, excluyo 00:30:05
Normalmente lo usamos así 00:30:06
Entonces, como normalmente la usamos así 00:30:08
Pues normalmente ponemos siempre 00:30:10
Ahí ya capón 00:30:12
El break 00:30:15
Y ya tengo ese funcionamiento 00:30:17
¿Vale? Ya tengo ese funcionamiento 00:30:22
Bueno, pues 00:30:24
Esa es la razón de que exista 00:30:26
Y lo quitamos 00:30:28
Si el funcionamiento que se genera nos interesa 00:30:29
Nos interesa por alguna razón 00:30:31
¿Vale? Por ejemplo 00:30:33
a ver 00:30:38
así sobre 00:30:42
la marcha, imaginaos 00:30:43
que tenemos aquí este switch case 00:30:46
con la variable 00:30:48
y pongo aquí 00:30:54
en el caso de que sea 7 00:31:07
pues hago las sentencias 00:31:09
que sean 00:31:11
en el caso de que sea 6 00:31:12
hago 00:31:17
las sentencias que sean 00:31:18
vale, voy a sacar 00:31:21
este código a una clase aparte 00:31:32
aquí, que sea ejemplo switch case 00:31:34
para que nos sirva 00:31:37
para entender bien este funcionamiento 00:31:39
y así no ensucio este ejercicio 00:31:41
a ver 00:31:43
lo voy a sacar 00:31:45
aquí en 00:31:50
proyecto 00:31:51
tenía uno 00:31:52
ejemplo string, no tenía uno específico de proyecto 00:32:01
de decisión 00:32:10
porque lo hemos hecho con los ejercicios 00:32:11
porque lo habíamos hecho con 00:32:15
o sea en el aula virtual no tengo uno 00:32:18
específico de 00:32:19
a ver 00:32:21
para que esté organizado 00:32:22
vale, ya teníamos 00:32:25
los ejercicios 00:32:39
vale 00:32:40
pues voy a hacer un 00:32:41
proyectito aparte con una clase switch case 00:32:44
para ver un poco bien como funciona 00:32:47
y subirlo a modo de ejemplo 00:32:49
venga, vamos a hacernos 00:32:50
una nueva clase 00:33:11
ejemplo 00:33:14
ya está 00:33:19
me hago hoy esa clase 00:33:21
y ahora el ejercicio este voy a quitarle 00:33:23
esto de abajo 00:33:25
para que no se quede estropeado 00:33:27
vale, teníamos las dos versiones 00:33:29
hechas con el save 00:33:31
y hecha con switch case 00:33:32
y ahora todo esto que yo había puesto aquí 00:33:35
para ver como funcionaba 00:33:37
ya lo quito 00:33:39
y ya se me queda el ejercicio 13 00:33:40
Ya he hecho con las dos variantes 00:33:43
Vale 00:33:46
Venga, ahora estamos con el ejemplo de switch case 00:33:47
Para acabar de entender bien como funciona 00:33:50
Pues vamos a ponernos 00:33:52
Un numerito cualquiera 00:33:54
Y ahora nos hacemos 00:33:55
En el caso de que el numerito 00:33:59
Sea 00:34:04
7, por ejemplo 00:34:05
Pues voy a 00:34:14
Mostrar un mensaje 00:34:16
Y ahora me voy a hacer lo mismo 00:34:18
Para, ahora cambio 00:34:23
Vale, voy a partir del 4 00:34:31
Para no hacer tantos case 00:34:39
Y 1 00:34:46
Vale, este switch case es válido, ¿no? 00:34:48
No tengo el break 00:34:51
Entonces, ¿este switch case cómo va a funcionar? 00:34:52
Para 00:34:56
Números 00:34:56
Para 00:34:58
Va a mostrar el mensaje 00:35:01
¿Cuántas veces? 00:35:04
Cuatro veces. 00:35:10
Sin embargo, si le meto el 3, ¿cuántas veces muestra el mensaje? 00:35:11
Ahora lo voy a leer por teclado para que se vea. 00:35:14
Y ahora vamos a leerlo del teclado. 00:35:27
Vale. 00:35:36
Entonces, en función de la variable n, 00:35:39
yo planto este switch case 00:35:42
y vamos a ejecutar esto. 00:35:44
Está esperando un numerito. 00:35:51
Le pongo el 4. 00:35:52
Me pone el mensaje cuatro veces. 00:35:54
Ahora le voy a poner el 3. 00:35:56
Me lo pone tres veces. 00:35:58
Ahora voy a poner el 2. 00:35:59
me lo pone dos veces 00:36:01
ahora voy a poner el 1, me lo pone una vez 00:36:02
entonces esta forma 00:36:05
de funcionar 00:36:07
pues la he simulado yo 00:36:08
con el switch case aprovechándome 00:36:11
de que sé cómo funciona 00:36:13
y por qué lo he podido simular 00:36:14
así 00:36:17
¿qué ha pasado cuando el numerito ha sido 4? 00:36:18
ha entrado en este case 00:36:22
porque era 4 00:36:23
y como no hay ningún break 00:36:24
¿qué significa entrar en un case? 00:36:26
significa que arrancas desde ahí 00:36:28
arrancas, y ahí arrancas 00:36:30
y paras cuando llega un break 00:36:32
como no hay ningún break, no ha parado 00:36:35
vale, ahora yo le he metido el 3 00:36:36
aquí ya no ha entrado, porque era 3 00:36:38
pero aquí sí, ¿qué significa entrar? 00:36:40
no significa ejecuto eso solo 00:36:43
significa arranco desde ese punto 00:36:44
arranco desde ese punto 00:36:47
¿hasta cuándo? 00:36:49
hasta que llegue un break, como no hay ningún break, lo ha mostrado todo 00:36:50
y aquí lo mismo 00:36:53
cuando le he metido un 2 00:36:55
¿qué significa? en el 4 y en el 3 no ha entrado 00:36:56
ha entrado en el 2, significa arranco 00:36:59
desde ese punto, hasta que llegue un break 00:37:01
¿vale? 00:37:03
¿que queremos este funcionamiento? 00:37:05
¿vale? pues depende 00:37:08
de lo que queramos hacer, depende de lo que queramos 00:37:09
pero repito, normalmente 00:37:11
lo que queremos con un switch case 00:37:13
es distinguir una rama 00:37:14
o hago esto, o hago esto, o hago esto 00:37:17
o hago esto, y no arranco aquí 00:37:19
y hago todo lo demás 00:37:21
entonces en ese caso 00:37:22
lo haríamos con el break, voy a poner aquí 00:37:24
Aquí ejecuta todo el código 00:37:26
Desde el case válido 00:37:37
Desde el case válido ejecuta todo 00:37:43
Pero sin embargo 00:37:45
Si hacemos la versión habitual 00:37:46
Hacemos la versión habitual 00:37:55
Y voy a volver a leer el numerito 00:38:12
Voy a volver a leerlo 00:38:14
Aquí 00:38:15
Lo vuelvo a leer 00:38:17
Con esta versión da igual el número que meta 00:38:19
Da igual 00:38:22
va a mostrar siempre ola 00:38:22
da igual que meta 1, 2, 3 y 4 00:38:24
a ver, si no meto ninguno 00:38:26
de ellos no hará nada, porque no entra en ninguno 00:38:29
de los casos, claro 00:38:31
vale, entonces si ahora ejecutamos esto 00:38:32
para el primer número le meto 00:38:35
el 3, me ha sacado los 3 olas 00:38:39
pero ahora le vuelvo a meter el 3 00:38:40
y me ha sacado solo 1, porque estoy en la otra versión 00:38:42
y aquí da igual lo que haga 00:38:45
le meto un 2, me ha sacado los 2 00:38:47
pero en la otra versión le meto un 2 y solo me lo ha hecho una vez 00:38:48
bueno, pues 00:38:51
eso significa el break 00:38:54
vale 00:38:58
aquí 00:38:58
solo se ejecuta 00:39:00
el case válido en este caso 00:39:03
bueno, pues no hay que complicarse 00:39:05
hay que usar el switch 00:39:11
cuando identificamos 00:39:13
que tengo varias ramas 00:39:14
en mi programa, varias ramas 00:39:16
y que se haga una o que se haga otra 00:39:18
depende del valor de una variable 00:39:20
entonces si identificamos 00:39:22
que esa es nuestra situación 00:39:24
pues ya está 00:39:25
ponemos un switch case con la sintaxis 00:39:28
la variable que sea, que me vale string 00:39:30
los valores que yo 00:39:32
contemplo, pongo un break 00:39:34
para asegurarme que solo se hace 00:39:36
la que toque y ya está 00:39:38
y no hay que darle más vueltas a esto 00:39:39
¿vale? 00:39:42
ya por último, también desde cierta 00:39:45
versión, que esta ya sí que es 00:39:48
más posterior, no sé si la 10 00:39:50
o cual, se pueden poner 00:39:52
varias opciones en un mismo case separadas por coma 00:39:54
Por ejemplo, vamos a cambiar este switch case 00:39:56
Vamos a darle el numerito 00:39:59
Por ejemplo, si yo en el caso 4 y en el 3 00:40:02
Quiero que se haga lo mismo 00:40:12
Por ejemplo, imaginaos que aquí 00:40:14
Si meto 4, quiero que se muestre la 4 00:40:16
Ahí quiero que se muestre la 3 00:40:18
Ahí quiero que se muestre la 2 00:40:19
Y aquí quiero que se muestre o la 1 00:40:21
Vale 00:40:24
Pero, en el caso de que me hayan metido 00:40:25
5, 6, 7, 8, 9 o 10 00:40:28
Por ejemplo 00:40:30
pues en ese caso quiero que se muestre 00:40:31
hola sin más 00:40:33
pues me puedo hacer un case así 00:40:34
con todos esos valores 00:40:36
5,6 00:40:39
7,8 00:40:42
9,10 00:40:44
por ejemplo 00:40:45
¿vale? entonces puedo agrupar 00:40:46
varios en uno 00:40:57
bueno, aquí si no pongo el break 00:40:58
entonces esto simplemente 00:41:00
que se introduce cualquiera 00:41:07
de estos, n es 5 00:41:10
o es 6 o es 7 o es 8 00:41:11
Cualquiera de estos 00:41:13
Entra por aquí 00:41:14
Y break, se acabó, ya no hace más 00:41:16
¿Que no se ha introducido cualquiera de ellos? 00:41:19
Pues sigue mirando 00:41:22
¿Es el 4? Sí, pues entra por aquí 00:41:22
Y break, se acabó, ya no hace más 00:41:25
Que no 00:41:27
Sigue, sigue mirando 00:41:29
¿Es el 3? 00:41:31
Pues entra por aquí 00:41:34
Y break, se acabó, ya no hace más 00:41:35
¿Vale? 00:41:37
Bueno, pues nada 00:41:40
Si en algún momento es útil 00:41:41
agrupar varias en una misma línea 00:41:42
se agrupan y ya está 00:41:44
depende de lo que necesite hacer uno 00:41:45
¿vale? en este caso entonces 00:41:48
si yo meto el 7 00:41:52
por ejemplo 00:41:57
en el primer caso no me ha mostrado ningún hola 00:41:58
porque solo contemplaba o 4 o 3 00:42:02
o 2 o 1, vuelvo a meter 7 00:42:04
tampoco me muestra nada porque solo contemplaba 4 o 3 00:42:06
o 2 o 1 y en el tercer caso 00:42:08
ya sí 00:42:10
¿vale? aunque meto el 6 pasa lo mismo 00:42:11
¿vale? 00:42:17
Que meto el 2 00:42:22
Pues ahora ya 00:42:24
Pasa ya lo que espero 00:42:25
Bueno, estas son las 00:42:27
Particularidades del switch 00:42:35
Y no tiene más en realidad 00:42:37
No tiene más interesante 00:42:39
Está bien, ¿verdad? 00:42:41
Qué bonito 00:42:49
Bueno, pues ahora a partir de aquí 00:42:50
Ya tenemos la vía libre 00:43:00
Para usarlo en los ejercicios en los que 00:43:01
Veamos que nos lleva códigos 00:43:04
Más claros, más legibles y ya está 00:43:05
Venga, pues a ver 00:43:08
más ejercicios 00:43:12
a menos que 00:43:17
queréis que avancemos 00:43:18
de Mario 00:43:22
un respirito, venga, vamos a parar 00:43:23
vale, vamos a parar 00:43:29
que es lo que os pasa a los mayores 00:43:30
que os cansáis, yo lo entiendo 00:43:33
cuando yo tenga vuestra edad, pues también me cansaré 00:43:35
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
14
Fecha:
10 de octubre de 2024 - 16:56
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
43′ 40″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
191.28 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid