Saltar navegación

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

Clase 16-10-23 - 2 - Contenido educativo

Ajuste de pantalla

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

Subido el 16 de octubre de 2023 por Raquel G.

5 visualizaciones

Más información Transcripción

Descargar la transcripción

Bueno, seguimos. Pues a ver, pues si uno quisiera seguir compactando esto, pues claro, podría hacerlo. Por ejemplo, aquí tenemos dos ramas que también son iguales, siete y ocho. 00:00:00
Entonces efectivamente uno podría hacer esto, podría hacer esto, ¿vale? 00:00:14
Vamos a poner el 5 y el 6 también como aprobado, para que, vale, estas dos ramas son iguales, pues podría quitarse y hacer esto, ¿verdad? 00:00:22
Entonces, esto lo podéis encontrar mucho, varios keys seguidos. 00:00:35
Entonces, esto significa que estos dos están agrupados y que tanto 5 como 6 hacen lo de abajo. 00:00:41
Esto significa que estos dos están agrupados, que tanto 7 como 8 hacen lo de abajo. 00:00:48
Esto significa que estos dos están agrupados. 00:00:53
El 1, 2, 3, 5, ¿vale? 00:00:56
Podría poner 5, 6 o podría poner esto, es lo mismo. 00:00:58
Pero repito lo que os decía antes 00:01:01
Si vosotros estáis en una empresa que esté con Java 8 00:01:05
Que es la gran mayoría de ellas 00:01:08
Pues la situación que vais a encontrar es esta 00:01:10
Voy a bajar aquí 00:01:12
A ver, bueno, lo voy a mostrar 00:01:17
Para que os vayáis familiarizando 00:01:19
Java, como ya sabéis, tiene sucesivas versiones 00:01:23
Tiene sucesivas versiones 00:01:28
De las cuales un par de ellas fueron las críticas, la 2 y la 8. 00:01:30
A partir de ahí, pues es bueno, porque hay que incorporar cositas para que no parezca que se aburra la gente. 00:01:35
Pero esos detalles que se incorporan es lo de menos. 00:01:43
O sea, no es mejor programador el que conoce la última versión de una sentencia, es que eso da igual. 00:01:47
Lo que importa es saber elaborar bien algoritmos, saber hacer programas. 00:01:54
entonces la 2 y la 8 fueron las más críticas 00:01:58
la 2 obviamente, ya pues claro 00:02:00
la 2 fue crítica porque se incorporaron 00:02:02
las colecciones, que ya entendemos 00:02:04
lo que son, que son fundamentales 00:02:06
las colecciones, y la 8 es la 00:02:08
siguiente crítica porque se incorporó 00:02:10
programación funcional, otra serie de historias 00:02:13
que bueno, que más o menos 00:02:15
un poquito entenderemos, y a partir 00:02:16
de ahí, vale, pues pequeñas incorporaciones 00:02:18
como esta de aquí 00:02:21
entonces, si uno quiere 00:02:22
por ejemplo, imaginaos que vosotros 00:02:24
estáis desarrollando 00:02:26
y sabéis que 00:02:27
donde se va a desplegar vuestra aplicación 00:02:30
y cuando digo desplegar 00:02:33
es donde vuestra aplicación se va a ejecutar 00:02:34
es en ese ordenador 00:02:37
de ahí, que es en el que ya 00:02:39
la gente se va a conectar y va a hacer cosas 00:02:40
tú no desarrollas 00:02:42
obviamente en el ordenador normalmente 00:02:44
donde se van a ejecutar las aplicaciones que te han pedido 00:02:46
desarrollas en tu ordenador 00:02:49
en el que tú haces tus cositas 00:02:50
ahí es donde tú haces tu desarrollo como programador 00:02:52
Cuando esa aplicación ya está terminada y está aprobada y todo eso, esa aplicación ya se despliega para su ejecución en otro ordenador 00:02:54
Bueno, pues cuando tú estás trabajando tienes que conocer los requisitos donde se va a desplegar esa aplicación 00:03:03
Y cuando digo los requisitos es, en este caso si es una aplicación Java, la versión de la máquina virtual que la va a ejecutar 00:03:11
porque tu aplicación tiene que estar compilada con un nivel de JDK 00:03:19
que sea igual o inferior al de la máquina virtual que lo va a ejecutar. 00:03:27
Porque si no, la máquina virtual no va a saber entenderlo. 00:03:33
¿Vale? O sea, recordad que teníamos dos conceptos distintos. 00:03:36
No os olvidéis de todas estas cosas, de esta nomenclatura, de todo. 00:03:41
No os olvidéis, tenéis que saber de lo que estáis trabajando. 00:03:44
Recordad que una cosa es el JDK, el Java Development Kit 00:03:48
Que es el kit de desarrollo Java, que es todo ese conjunto de herramientas, de comandos 00:04:00
Que nos permiten desarrollar para Java 00:04:05
Entre ellos compilar, lo más importante, ese es el JDK 00:04:08
Lo que no se descarga y usa por ejemplo el Java C desde comandos 00:04:12
Si eso es incómodo pues usa un entorno de desarrollo 00:04:17
Pero el entorno de desarrollo usa internamente el JDK 00:04:20
Claro, una cosa es el JDK 00:04:22
Esto es para desarrollar 00:04:24
Para hacer programación Java 00:04:26
Luego una vez que la aplicación ya está hecha 00:04:27
Compilada 00:04:31
Ya tenemos los .class 00:04:33
Ahora ya eso se puede ejecutar 00:04:35
En cualquier ordenador 00:04:37
En cualquiera 00:04:38
Bueno, pues quien lo ejecuta 00:04:39
Es lo que llamamos la máquina virtual de Java 00:04:43
Que es esta 00:04:46
La Java Virtual Machine 00:04:47
vale 00:04:49
entonces la JDK es el conjunto 00:04:51
de herramientas para desarrollar 00:04:53
entre las cuales 00:04:55
la más importante es el compilador 00:04:57
para pasar del punto Java al punto Class 00:04:59
y luego ya la máquina virtual 00:05:01
esto ya si es lo que está en todos los ordenadores 00:05:03
que sirve para ejecutar un programa 00:05:05
que ya está compilado en Java 00:05:07
ya está compilado y yo lo ejecuto, vale, esta es la máquina virtual 00:05:08
y esta si está en todos los equipos 00:05:11
que ya han ejecutado aplicaciones Java 00:05:13
la JDK solo estará 00:05:15
en los que quieran hacer desarrollo Java 00:05:17
vale 00:05:19
vale 00:05:21
entonces 00:05:23
la JDK y la JVM 00:05:24
pues van avanzando 00:05:27
van saliendo versiones, etc 00:05:29
bueno pues 00:05:31
donde se vaya 00:05:33
a ejecutar nuestra aplicación 00:05:35
habrá una máquina virtual 00:05:37
que tendrá una versión 00:05:39
la 1.8 en la gramaría de los casos 00:05:40
o la versión que tenga 00:05:43
1.9 o 1.10 la que tenga 00:05:45
pues esta máquina virtual solo va a poder ejecutar aplicaciones 00:05:46
que se hayan desarrollado con versiones de JDK 00:05:51
iguales o inferiores a la que tiene la propia máquina virtual 00:05:55
si la máquina virtual es la 8, la 1.8 00:06:00
yo no puedo darle para ejecutar una aplicación 00:06:04
que he desarrollado en la versión 20 00:06:09
por ejemplo, como la que estamos haciendo aquí nosotros 00:06:12
Hemos descargado la última que había, la jdk20 00:06:15
No sé si es la última, la 20 o ya la 21 00:06:17
La 21, es la que hemos descargado 00:06:19
Y es la que estamos utilizando 00:06:22
Claro, y dentro de donde está la 22 00:06:23
Pero da igual 00:06:26
Si es que da lo mismo, da exactamente igual 00:06:27
Porque no se usa ninguna de ellas 00:06:29
No se usa ninguna 00:06:30
Entonces 00:06:31
¿Qué ocurre? 00:06:33
Que si yo no cambio el nivel de compilación 00:06:37
Y no lo bajo 00:06:38
Al de la máquina virtual que se vaya a ejecutar 00:06:40
Si no lo bajo 00:06:43
Pues la máquina virtual no lo va a entender 00:06:44
No lo va a entender 00:06:46
¿Vale? 00:06:47
Vamos a 00:06:51
Vamos a verlo 00:06:53
Que es interesante 00:06:58
A ver 00:07:00
Vamos a 00:07:01
Lo que pasa es que aquí en este ordenador 00:07:08
Tengo en el pendrive una máquina virtual más baja 00:07:10
Creo, la JR8 00:07:12
Si podemos descargarlo rápidamente 00:07:14
Porque aquí ahora mismo 00:07:16
Vamos a ver que máquinas virtuales tenemos 00:07:18
las máquinas virtuales 00:07:20
están en la carpeta de Java 00:07:24
lo único que tengo en la carpeta de Java 00:07:25
aquí 00:07:33
esta, ¿vale? 00:07:42
porque recordad que la JDK 00:07:44
tiene dentro también una máquina virtual 00:07:46
tiene dentro también una máquina virtual 00:07:49
entonces estamos ejecutando con esta 00:07:50
¿vale? por eso nuestras aplicaciones 00:07:53
las entiende la máquina virtual con la que ejecutamos 00:07:55
porque es la misma versión 00:07:57
¿vale? 00:07:58
A ver si en archivos de programa 8086 tenemos otra 00:07:59
Java no es la única que tenemos 00:08:04
Vamos a ver si nos podemos descargar rápidamente 00:08:07
La JR8 00:08:17
Que es la que más, es una de las que más 00:08:26
Java para Windows, por ejemplo 00:08:30
vale, esta página 00:08:59
te descarga la 00:09:04
máquina virtual 00:09:05
a ver si me la descarga rapidito 00:09:07
veis, pone Java Runtime Environment 00:09:13
no es la JDK 00:09:18
instalarla 00:09:20
lo único que va a hacer va a ser descomprimir la carpeta 00:09:25
y el zip 00:09:27
pues vamos a ver si ya la ha instalado 00:09:28
vamos a meternos en 00:09:37
archivos de programa 00:09:39
java 00:09:42
vale, aquí la tengo 00:09:43
vale 00:09:57
vale, esta es 00:09:58
la máquina virtual 1.8 00:10:05
vale, que es una 00:10:10
que es la que vais a encontrar prácticamente 00:10:11
en cualquier lado 00:10:13
la máquina virtual 1.8 00:10:16
la más estable, de las que son 00:10:18
máquinas virtuales exclusivamente 00:10:19
vale, pues la máquina virtual 8 00:10:21
si yo la uso para ejecutar 00:10:24
mis aplicaciones, voy a tener 00:10:27
que compilarlas a un nivel 00:10:29
igual o inferior a 8 00:10:30
que siempre será el 8 00:10:32
vale, pues venga, vamos a 00:10:33
configurar nuestro Eclipse 00:10:35
para darle la opción 00:10:38
de ejecutar con esta otra máquina 00:10:40
virtual también, ahora mismo está ejecutando 00:10:43
solo con la que está dentro de la 00:10:45
JDK 20, que la JDK incluye una máquina 00:10:46
virtual, vale, vamos a 00:10:49
darle la opción de trabajar con otra también 00:10:50
con otra máquina virtual, con la JR8, porque yo puedo querer simular la situación que va a encontrar mi aplicación cuando esté en un servidor, que es trabajar con la JR8, pues venga, vamos a, vale, a ver, venga, pues ya quito esto, vale, pues venga, por ejemplo, este proyecto de aquí, ejemplo sentencia selectiva, 00:10:53
vale, si le dais al botón derecho 00:11:27
si le dais al botón derecho 00:11:30
y os vais a propiedades 00:11:31
vais a ver muchas cosas 00:11:35
relacionadas con ese proyecto 00:11:38
nos vamos a propiedades 00:11:39
vale, pues aquí en propiedades 00:11:41
vemos un montón de cositas 00:11:45
que ahora mismo nos pueden sonar a chino todas 00:11:46
vamos a pinchar en java buildpad 00:11:47
en java buildpad 00:11:51
uno pincha, se va a librerías 00:11:54
y te dice 00:11:57
con qué máquina virtual 00:11:59
va a ejecutar el Eclipse 00:12:01
ese proyecto 00:12:03
nos está diciendo, bueno 00:12:04
con la máquina virtual que está dentro del JDK20 00:12:07
es lo que nos está diciendo 00:12:10
vale 00:12:11
vamos a añadirle 00:12:14
la opción de 00:12:24
compilar con otra máquina virtual 00:12:26
con la lupa, es que me pierdo 00:12:29
A ver, pero voy a quitar la lupa 00:12:30
Porque es que si no 00:12:37
Es imposible ver algo aquí 00:12:39
Pues venga 00:12:41
Vámonos otra vez donde estábamos 00:12:48
Propiedades 00:12:50
Java build path, vale 00:12:51
Librerías, librerías 00:12:54
Vale, pinchamos module path o class path 00:12:56
Ahora mismo no entendemos lo que es 00:12:59
Da igual, pinchamos class path y le decimos 00:13:01
Venga, añade una librería 00:13:02
Botón derecho, añade librería 00:13:04
Vale, esto no hace falta que lo hagáis vosotros 00:13:07
Lo que quiero es que veáis el error que se daría 00:13:08
Venga, librería de JRE 00:13:10
Allá arriba está escrito 00:13:13
Aunque no lo veáis 00:13:15
Está escrito 00:13:16
Añade una JRE 00:13:22
Venga 00:13:24
Quiero librería 00:13:25
De tipo Java Runtime Environment 00:13:28
O máquina virtual de Java 00:13:30
Pues venga, la selecciono 00:13:31
Next 00:13:34
Me dice, vamos a ver 00:13:34
Te dice, tienes esta 00:13:36
alternativas 00:13:38
ninguna 00:13:41
no tienes ninguna alternativa 00:13:43
es la unidad que tienes 00:13:44
vamos a ponerle una adicional 00:13:45
la que yo acabo de instalar en mi ordenador 00:13:49
la JR8 00:13:51
pues pincho en este botoncito 00:13:52
a ver cual está instalada 00:13:54
ahora mismo en la JDK20 00:13:56
quieres habilitarte la opción 00:13:59
de compilar con otra 00:14:01
venga si, pues añades 00:14:02
añadimos, venga vamos a añadir 00:14:04
a una máquina virtual 00:14:07
next 00:14:08
¿dónde va a estar? 00:14:11
¿dónde está esa máquina virtual? 00:14:13
pues buscamos en el 00:14:16
ahí 00:14:18
¿dónde está esa máquina virtual? vamos a buscar 00:14:18
donde me la ha instalado 00:14:26
en C, archivos de programa, Java 00:14:28
ahí estaba, JR18 00:14:31
seleccionada 00:14:33
vale, ya la tenemos, ahí seleccionada 00:14:35
finish 00:14:36
vale, pues ahora ya 00:14:37
Me ha aparecido 00:14:40
En esta ventanita 00:14:46
Que ahora ya tengo dos alternativas 00:14:48
Con las que puedo elegir 00:14:50
Para ejecutar mis aplicaciones desde Eclipse 00:14:51
Esta JDK20 00:14:54
Que es la JR que me viene 00:14:56
Con la JDK20 que yo he descargado 00:14:57
Esta JDK20 00:14:59
Y esta JRE 00:15:01
Que es la última máquina virtual 00:15:02
Estable 00:15:06
Vale, tú ahora ya puedes elegir 00:15:07
Ya tienes las dos instaladas 00:15:09
Pues venga, aplicamos 00:15:11
Apply 00:15:12
Ah, y apply and close 00:15:14
Es que tengo 00:15:18
Sí, aplicar, apply and close 00:15:18
No, no, no, es que no quiero marcarla 00:15:20
Lo que quiero es habilitar la opción 00:15:23
Y ahora ya la selecciono desde otro sitio 00:15:24
Pero voy a cerrar esto 00:15:26
Bueno, pues ahora ya 00:15:27
Si pincho lo de alternativas 00:15:30
Ya en el desplegable ya me salen dos 00:15:31
Que es lo que yo quería 00:15:33
Ahora en este desplegable 00:15:35
en este desplegable de aquí 00:15:36
ya me salen dos máquinas virtuales 00:15:45
ya puedo elegir 00:15:47
en cada proyecto que yo haga 00:15:49
puedo elegir con qué máquina virtual 00:15:51
quiero que lo ejecute el eclipse 00:15:53
entonces yo ahí se supone 00:15:55
si estoy ya trabajando en un 00:15:57
entorno real, tendré 00:15:59
ahí habilitadas 00:16:01
todas las máquinas virtuales 00:16:03
en las que puede que mis aplicaciones 00:16:05
se desplieguen en los diferentes servidores 00:16:07
con los que yo trabaje, ahí tendré 00:16:09
habilitadas todas 00:16:11
entonces yo cada proyecto 00:16:12
seleccionaré para mis pruebas en Eclipse 00:16:14
seleccionaré una máquina virtual 00:16:17
que sea igual a la del 00:16:19
servidor donde se va a ejecutar luego mi aplicación 00:16:21
cuando ya esté hecha 00:16:23
vamos a suponer que ahora este proyecto en particular 00:16:24
que estamos haciendo del case, este proyecto 00:16:27
yo quiero que mi Eclipse 00:16:28
lo ejecute con la JR1-8 00:16:30
quiero que lo ejecute con la JR1-8 00:16:33
porque en el servidor 00:16:36
en el que luego se va a desplegar 00:16:37
Tiene esta máquina virtual para ejecutarla 00:16:38
Pues marco aquí JR18 00:16:40
Y ya está, y le doy a finish 00:16:42
Y ahora veis 00:16:44
Aquí en el proyecto este 00:16:46
Vale 00:16:48
En el, no veía esta ventanita 00:17:01
Vale, entonces 00:17:03
Vuelvo a esta ventana 00:17:05
Veis, esta es con la que yo la quiero 00:17:11
Ejecutar con la jeta JR8 00:17:13
Y esta ya la quito 00:17:15
Esto no quiero que lo hagáis en vuestros ordenadores 00:17:17
Porque lo que quiero es que entendáis 00:17:19
Esa situación 00:17:21
que se da y lo que 00:17:22
las implicaciones que tiene 00:17:24
bueno, pues ya está, entonces ahora yo ya le doy 00:17:25
a la apply and close este 00:17:28
y si me vengo aquí a mi proyecto, este de aquí 00:17:30
¿veis? 00:17:32
esto 00:17:35
ya ha cambiado, ¿veis este proyecto de abajo? 00:17:35
pone aquí 00:17:40
se va a ejecutar con la 00:17:40
máquina virtual 20, ¿vale? 00:17:42
sin embargo este de arriba 00:17:45
yo he cambiado la configuración 00:17:46
para que se ejecute con la JR18 00:17:48
entonces cada proyecto 00:17:50
yo puedo elegir con qué máquina virtual 00:17:52
quiero que el eclipse simule su ejecución 00:17:54
¿vale? 00:17:56
puedo elegirlo, las diferencias 00:17:58
entre unas y otras son las versiones 00:18:00
bueno, pues entonces, esta 00:18:01
yo puedo creer que se ejecute con la 8, repito 00:18:04
porque lo necesito 00:18:06
porque el sitio del que va es la 8 y quiero simular 00:18:08
las pruebas reales, tal y como va a funcionar 00:18:10
pues ya lo he cambiado 00:18:12
el proceso de cómo agregar una máquina virtual 00:18:13
a mi eclipse para poder elegir unas y otras 00:18:16
ahora mismo nos da un poco igual 00:18:18
Porque no es algo que necesitéis hacer 00:18:19
Pero tenéis que entender 00:18:23
Las implicaciones de esto 00:18:24
Bueno, pues este en particular 00:18:26
Se va a ejecutar con la JR1 00:18:27
Ya lo hemos cambiado 00:18:29
Vale, pues venga, cerramos aquí la lupa 00:18:30
Ya para que se vea 00:18:34
Vale, bueno, pues este era mi proyecto 00:18:35
Este es mi proyecto 00:18:38
Que dio sentencia a IVE 00:18:39
Voy a cerrar esto 00:18:40
Que tengo aquí tanto abierto 00:18:43
Este era mi proyecto de aquí 00:18:44
Y ya está 00:18:48
Esto lo había comentado 00:18:51
Aquí tenía yo el switch nota 00:18:52
Este 00:18:55
Había agrupado estos 00:18:56
1, 2, 3, 4 00:18:58
Este 00:19:07
Ay, perdón, perdón 00:19:09
Ah, vale, vale, esto era 00:19:10
Sí, claro, es que con el 00:19:11
Vale, tenía estos 4 agrupados aquí 00:19:13
Luego el 5 y el 6 00:19:16
Podía haber puesto 5,6 00:19:17
Pero lo he puesto así 00:19:19
para, vale, 7 y 8 00:19:21
vale, pues esta es mi 00:19:23
mi switch case 00:19:25
entendemos los detalles y todo 00:19:27
que lo hemos ejecutado antes y nos ha funcionado 00:19:28
¿no? 00:19:31
bueno, vamos a volver a ejecutarlo 00:19:33
y nos sale este error 00:19:35
que sale tropecientas veces 00:19:43
y que se refiere a mil 00:19:45
cosas distintas 00:19:47
y una vez se puede volver loco 00:19:48
pero la gran mayoría 00:19:50
de las veces este error que es 00:19:53
absolutamente nada explicativo 00:19:55
nada explicativo 00:19:57
se debe a una situación que se da 00:19:59
continuamente y es 00:20:00
que estás compilando 00:20:02
con un nivel de compilación que es superior 00:20:04
al de la máquina virtual 00:20:07
que lo está ejecutando 00:20:09
entonces cada vez que veáis 00:20:10
esta ventanita casi seguro 00:20:13
que vuestro error viene por ahí 00:20:14
pero si lo familiarizando ya con la cantidad de errores que os pueden venir 00:20:16
claro que viene por ahí 00:20:19
pero si es que acabamos de cambiar la máquina virtual 00:20:20
hemos puesto que lo ejecuto con la 1.8 00:20:22
y yo mi proyecto 00:20:24
no le he cambiado el nivel de compilación 00:20:27
sigue compilando con el 1B 00:20:29
con la JDK20, no se lo he cambiado 00:20:31
entonces me sale este error 00:20:33
que no me explica nada 00:20:35
no me explica absolutamente nada 00:20:36
pero como a uno ya le salió una vez 00:20:38
y lo averiguó 00:20:41
de hecho 00:20:42
como está la traza de error 00:20:44
que es otra cosa que ya entenderemos 00:20:46
habilitada, si uno se va a las líneas rojas 00:20:48
pues aquí se lo explica más 00:20:51
le dice, oye, ejemplo case 00:20:53
ha sido compilado 00:20:57
a una versión de compilación más reciente 00:20:58
que la Java Runtime 00:21:01
que estás usando, te lo está diciendo 00:21:02
pero esta traza 00:21:05
uno podría no tener acceso a ella 00:21:07
porque podrías no tener acceso a la consola 00:21:08
verías la ventanita 00:21:10
bueno, pues significa eso 00:21:12
¿cómo arreglaríamos eso? 00:21:14
si uno tiene que compilar con esa máquina virtual 00:21:17
perdón, si uno tiene que ejecutar 00:21:19
con esa máquina virtual sí o sí, si eso no lo puede cambiar 00:21:20
porque esa es su restricción 00:21:23
tiene que cambiarlo, tiene que ejecutarlo 00:21:24
esa máquina virtual, lo que tiene que hacer es 00:21:26
bajar el nivel de compilación 00:21:28
vale, pues donde baja el nivel de compilación 00:21:29
bueno, pues lo mismo 00:21:32
botón derecho propiedades 00:21:36
donde 00:21:38
uno puede cambiar 00:21:40
muchas cosas de la configuración del proyecto 00:21:41
en botón derecho propiedades 00:21:43
está esta pestañita que hemos abierto antes 00:21:46
para cambiar la máquina virtual 00:21:48
y también hay una que es java compiler 00:21:49
y aquí te permite 00:21:52
Cambiar el nivel de compilación 00:21:53
Ahora lo tenemos al 20 00:21:55
Porque es el más alto 00:21:56
Que permite la JDK que tenemos 00:21:59
Tendría que cambiarlo al 1.8 00:22:01
Que es el de la máquina virtual 00:22:03
Que tengo, lo tendría que cambiar al 1.8 00:22:05
¿Vale? Porque mi máquina virtual es la 1.8 00:22:07
Una vez que ya lo he cambiado 00:22:10
Me dice 00:22:12
Para recompilar 00:22:18
Tengo que 00:22:19
Reconstruir el proyecto, si, si, reconstruye 00:22:21
Lo que quieras, vale 00:22:23
A ver 00:22:25
Vale, ya hemos cambiado el nivel de compilación 00:22:25
Y la hemos liado 00:22:29
Esto ya no lo podemos usar 00:22:31
¿Vale? Esto ya no lo podemos usar 00:22:33
Porque esto se incorporó como 00:22:35
Tontuna, como tantas otras 00:22:39
A partir de cierto nivel de compilación 00:22:41
Entonces ya no lo podemos usar 00:22:44
¿Vale? 00:22:46
Pero no pasa nada porque yo me pongo aquí 00:22:47
Me pongo esto 00:22:49
Me pongo esto 00:22:51
Como soy realmente, sé hacer las cosas 00:22:53
Y no soy un robot 00:22:55
Un tonto que busca en chat 00:22:58
GPT y 00:23:00
Nada, pues entonces yo me hago esto 00:23:01
Y digo, ala 00:23:04
Apañado 00:23:05
Ya lo tengo, que no me dejas usar la coma 00:23:08
Pues uso esto, que es lo mismo 00:23:10
¿Vale? 00:23:11
Que es poner todos los cases 00:23:14
Como aquí 00:23:16
Uno debajo de otro, me da igual 00:23:17
Los seguidos, y esto significa 00:23:20
Que es el caso uno 00:23:21
entras a la nada 00:23:23
y ya te haces todo hasta el break 00:23:25
¿qué es esto? 00:23:27
que no es el caso 1 pero es el 2 00:23:28
entras a la nada porque aquí hay vacío 00:23:30
y ya te haces todo hasta el break 00:23:32
¿qué es el caso 3? 00:23:35
entras a la nada porque aquí hay vacío 00:23:37
y ya te haces todo hasta el break 00:23:39
que es el 4 00:23:40
entonces es importantísimo 00:23:41
entender todo 00:23:45
lo que estamos haciendo 00:23:46
tenerlo todo entendido 00:23:48
y todo ahí almacenado en la cabeza 00:23:51
Que yo me puedo permitir 00:23:52
Trabajar con un nivel de compilación mayor 00:23:55
Porque no voy a trabajar con la máquina virtual 8 00:23:57
Si no con la que está en la JDK 20 00:23:59
Que no es lo habitual 00:24:02
Pues 00:24:04
Estupendo 00:24:05
Pongo las comitas y ya está 00:24:06
Voy a volver a hacer el proceso 00:24:09
De cambiar la máquina virtual 00:24:11
De la 8 a la que teníamos 00:24:13
Cambiar la máquina virtual 00:24:14
Una vez que no las tiene configuradas es más fácil 00:24:19
Le da aquí a botón derecho 00:24:21
Propiedades 00:24:23
Y te salen todas las que tienes 00:24:27
Pues esta 00:24:29
Y ahora 00:24:30
Vale, ya he cambiado a la JDK20 otra vez 00:24:36
Y ahora ya puedo cambiar el nivel de compilación 00:24:41
Ya lo puedo cambiar al 20 00:24:44
Lo cambio al 20 00:24:46
Y al cambiarlo al 20 ya 00:24:51
La tontuna esta 00:24:54
Pues ya está 00:24:57
Pues ya me deja esta y alguna otra chorrada 00:24:58
Que está incorporada después 00:25:01
Vale, pues entonces 00:25:04
Tenéis que aprender a programar 00:25:12
No tenéis que ser un catálogo de chorraditas 00:25:14
Que se pueden hacer con el lenguaje y se han incorporado 00:25:16
Eso me da lo mismo 00:25:18
Lo que tenéis es que aprender a programar 00:25:19
Bueno 00:25:22
Vale, pues el switch case 00:25:26
No tiene más historias que esta 00:25:29
Luego se trata de 00:25:32
seleccionarlo en una situación en la que me facilite 00:25:33
la tarea en vez de complicármela 00:25:35
y ya está 00:25:37
¿vale? alguien me había dicho de hacer un ejercicio 00:25:38
con el switch case, ¿verdad? 00:25:41
por ejemplo, tú 00:25:43
el 10 de aquí 00:25:44
venga, vamos a ver si el 10 de aquí se prestaría 00:25:46
a hacerlo con el 00:25:49
el switch case mínimamente 00:25:51
venga, vamos a ver como lo haríamos 00:25:53
este, el del triángulo 00:25:55
vamos a 00:25:57
a ver 00:25:59
ejercicio, sentencia y 10 00:26:00
ejercicio 10 00:26:05
vale, pues aquí 00:26:13
datos de entrada 00:26:55
tres lados 00:26:57
posibles salidas 00:26:58
estos tres lados no pueden formar un triángulo 00:27:00
o si pueden formar un triángulo 00:27:03
y en el caso de que puedan formarlo 00:27:06
ese triángulo es isósceles 00:27:07
es escaleno o es equilátero 00:27:09
vale 00:27:11
entonces 00:27:12
una vez entendido 00:27:13
las salidas que tiene ese programa 00:27:16
que es decir, no es triángulo 00:27:18
o es triángulo equilátero 00:27:20
o es isósceles o es escaleno, pues ahora ya es 00:27:22
ver qué condiciones me definen 00:27:24
cada una de esas salidas, ¿verdad? 00:27:26
¿Qué condiciones me definen cada una de esas salidas? 00:27:27
Vale, entonces, ahora ya es 00:27:30
cuando pues tenemos que ya 00:27:32
averiguar, indagar 00:27:34
conocimientos al margen de Java 00:27:35
que es dados los datos 00:27:38
de entrada, que en este caso son tres 00:27:40
lados, los datos de entrada 00:27:42
que me definen que sea que puedan formar un triángulo 00:27:43
o que no puedan formarlo 00:27:47
eso ya lo habréis buscado por ejemplo 00:27:48
y que conclusión habéis llegado 00:27:51
en lenguaje natural digo, no en Java 00:27:53
que condición tienen que cumplir 00:27:55
los valores de las tres longitudes 00:27:57
de un triángulo 00:28:01
para que realmente puedan formarlo 00:28:03
porque no todo puede formar un triángulo 00:28:04
obviamente 00:28:06
si te dan este lado 00:28:07
Te da en este lado 00:28:15
Y te da en este lado 00:28:20
Con esto 00:28:23
A mi ojo me resultaría imposible hacer un triángulo 00:28:25
¿Verdad? 00:28:28
¿Dónde coloco este? 00:28:29
Este lo podría colocar aquí 00:28:33
Ah, ya se me va a borrar esto, bueno, da igual 00:28:34
Pero entonces, ¿con el otro qué hago? 00:28:38
El otro no me llega al otro lado 00:28:40
¿Cómo los coloco? Para hacer un triángulo 00:28:41
Entonces, es cierto 00:28:44
Que cualesquiera tres longitudes 00:28:46
No me valen 00:28:48
Cualesquiera tres no me valen 00:28:49
Entonces como cualesquiera tres no me valen 00:28:50
Tiene que haber una condición 00:28:53
Para que tres longitudes puedan formar un triángulo 00:28:54
Vale, pues cuando habéis buscado esa conclusión 00:28:57
Condición a la conclusión habéis llegado 00:29:01
Que alguien me la diga 00:29:02
Tú por ejemplo 00:29:04
Vaya por Dios 00:29:05
Pues esto yo no contaba con que estuviera 00:29:11
Bueno, pues habéis 00:29:16
Leyendo el enunciado habéis encontrado eso 00:29:19
¿Vale? 00:29:21
Vale 00:29:23
leyendo el enunciado, y si no hubiera sido 00:29:24
leyendo el enunciado, pues lo habría buscado por ahí 00:29:26
vale, la condición 00:29:28
aquí ya está expresada 00:29:35
habrá un lado que sea el mayor 00:29:36
de los tres, el mayor 00:29:39
o habrá 00:29:41
y puede ocurrir que los otros dos 00:29:43
sean iguales que él, o alguno sea igual que él 00:29:45
pero habrá una longitud que sea la mayor 00:29:48
pues la longitud mayor 00:29:49
vale, tiene que ser más pequeña 00:29:51
que la suma de los otros, está claro, ¿no? 00:29:53
para que así los otros dos lados 00:29:55
lleguen a juntarse, cuando hacemos así, ¡pam! 00:29:56
Lleguen a juntarse y no se queden ahí separados 00:29:59
¿Vale? 00:30:01
Bueno, pues entonces esa condición 00:30:02
Vamos a leer las 00:30:04
Y luego 00:30:06
Los datos de entrada 00:30:07
Vale, datos de entrada 00:30:10
Lado 1, lado 2, lado 3 00:30:24
Venga 00:30:26
Para 00:30:27
Pues venga, vamos a 00:30:29
Meterle el programa 00:30:42
Estaría mucho mejor, le ponemos un mensajito 00:30:43
Introduzca lado 1, introduzca lado 2, introduzca lado 3 00:30:45
Estaría mucho mejor 00:30:47
Pero bueno, por comodidad vamos a pedir los lados sin más 00:30:48
Entonces lado 1 sería scan.nextIn 00:30:54
Lado 2 lo mismo 00:31:01
Vale, bueno pues entonces como de forma más cómoda nos plantearíamos esto 00:31:07
Sería decir primero, voy a ver si puede ser triángulo o si no puede serlo 00:31:23
porque si no puede serlo 00:31:29
ya tengo la respuesta 00:31:32
y en el caso 00:31:34
de que pueda serlo, ahora ya 00:31:36
puedo distinguir tres opciones 00:31:38
puedo distinguir tres opciones 00:31:40
entonces la primera condición que sería interesante 00:31:42
plantearse es la condición 00:31:44
de que el lado mayor sea 00:31:46
mayor 00:31:48
a la suma, sea más pequeño 00:31:50
que la suma de los otros dos 00:31:52
¿vale? entonces esa condición 00:31:53
¿cómo la habéis hecho? 00:31:56
¿cómo lo habéis planteado esa condición? 00:31:59
la condición 00:32:05
¿cómo habéis hecho la condición de 00:32:06
no ser triángulo? 00:32:08
o de serlo, me da igual porque es la negada 00:32:10
que el lado mayor sea menos a los otros 00:32:12
a la suma de los otros dos 00:32:14
¿cómo lo habéis planteado? 00:32:16
vale, esa sería la forma 00:32:31
quizás más sencilla de planteárselo 00:32:32
el lado mayor va a ser uno de los tres 00:32:34
entonces uno podría haber dicho 00:32:37
bueno, primero voy a sacar el lado mayor 00:32:38
No es que tengo el lado mayor, mira a ver si es mayor que la suma 00:32:40
Pero es que el proceso de sacar el lado mayor 00:32:42
Ya es casi más engorroso 00:32:45
Que plantearte las tres opciones 00:32:46
¿Verdad? Es casi más engorroso 00:32:48
Entonces, el lado mayor va a ser uno de los tres 00:32:50
Pues entonces efectivamente 00:32:52
Si el lado uno 00:32:54
¿Vale? Sería una opción 00:32:55
Entonces, por ejemplo 00:32:58
Podríamos haber hecho aquí 00:33:00
Boolean 00:33:02
Es triángulo 00:33:03
Y esta condición podría ser 00:33:06
Si lado 1 es mayor que lado 2 más lado 3, o, y aquí o, lado 1 y aquí lado 3, lado 2 y lado 1, perdón, lado es menor, estoy poniendo mayor, ¿no? 00:33:12
vale, entonces si es un triángulo 00:34:18
uno de los lados 00:34:25
tiene que ser menor que la suma de los otros dos 00:34:27
¿verdad? uno de los lados 00:34:29
tiene que ser menor que la suma de los otros dos 00:34:31
¿es esta? 00:34:32
¿pero te hace falta? 00:34:47
hacer eso antes 00:34:50
vale, pero vamos a completarlo 00:34:51
vale, entonces esta sería la condición 00:34:55
de ser triángulo, ¿verdad? 00:34:57
al menos uno de los lados 00:34:59
tiene que ser menor 00:35:01
Que la suma de los otros dos 00:35:03
¿Verdad? 00:35:04
Entonces, ahora ya sé que podríamos hacer 00:35:06
Si no es triángulo 00:35:08
Entonces podríamos poner 00:35:19
Si son 00:35:22
Ahora, que no ha entrado en este 00:35:23
Que no ha entrado en este 00:35:32
Será porque es triángulo 00:35:34
Pues ahora ya nos podemos plantear el resto de las condiciones 00:35:35
La de equilátero, por ejemplo 00:35:38
Lado 1 00:35:41
Igual a lado 2 00:35:43
Y lado 2 igual a lado 3 00:35:46
Que no ha entrado aquí 00:35:51
Porque no son iguales 00:36:00
Pues entonces la opción que nos vamos a plantear 00:36:02
Isósceles, pues isósceles 00:36:04
La condición de isósceles ya la hicimos en otro ejercicio 00:36:05
La condición de isósceles la podemos simplificar poniendo 00:36:09
Si lado 1 es igual a lado 2 00:36:16
O lado 2 es igual a lado 3 00:36:20
O lado 1 es igual a lado 3 00:36:29
Si se cumple cualquiera de estos 00:36:34
Será isósceles 00:36:38
Que tampoco 00:36:40
Sí, es el 10 creo 00:36:48
¿Eh? 00:36:54
Sí, él le ha pedido que lo hiciéramos en switch case 00:36:59
Para ver cómo podríamos plantear esto así 00:37:01
Pero primero vamos a ponerlo como lo haríamos 00:37:03
Porque este ejercicio a switch case no le aplica 00:37:05
Entonces hombre 00:37:08
Podemos hacer una transformación 00:37:09
Y tratar de hacerlo como switch case 00:37:11
Para practicar con el switch case 00:37:12
Pero no es un ejercicio en el que aplicaría 00:37:14
No usaríamos el switch case aquí 00:37:16
Porque las condiciones no son 00:37:18
Directamente que una variable tome 00:37:21
Uno de varios valores 00:37:23
Entonces podemos echarle imaginación 00:37:24
Si queréis para practicar con el switch case 00:37:27
Pero nunca haríamos este ejercicio con el switch case 00:37:30
Bueno, imagino que 00:37:31
Habréis resuelto algo parecido a esto 00:37:33
¿no? supongo 00:37:35
¿lo pusiste con un? 00:37:36
bueno, si da igual, si es que me da igual 00:37:41
yo lo he hecho para no poner toda esta condición aquí dentro 00:37:43
¿vale? 00:37:45
simplemente lo he sacado 00:37:48
fuera 00:37:49
pues porque es una condición muy larga para no meterla 00:37:50
toda aquí dentro, ¿vale? 00:37:53
pero en cualquier caso 00:37:58
lo que habréis es distinguido 00:37:59
tres o cuatro condiciones, ¿no? 00:38:01
si no lo habéis 00:38:04
hecho con él, tres o cuatro condiciones 00:38:06
Me da igual que las hayáis sacado antes a una variable, bulean o no, pero el programa en cualquier caso es cuatro ramas, son cuatro ramas, no triángulo, isósceles, equilátero y escaleno. 00:38:07
Lo importante aquí es identificar que son cuatro ramas. 00:38:18
¿Cómo lo programemos ahora? Es lo de menos, o sea, siempre y cuando sea más o menos claro y legible, pero lo que es inevitable es que aquí hay cuatro ramas, que hay que programar. 00:38:21
cuatro ramas puedo hacer con if, else, anidados 00:38:32
puedo arrastrar todas las condiciones 00:38:35
dentro, sacar las condiciones 00:38:37
a boolean, en lugar de if, else, anidados 00:38:39
if, else, if, else, if 00:38:41
luego tengo varias opciones 00:38:43
yo aquí he sacado la condición de ser 00:38:44
triángulo fuera 00:38:47
pues simplemente para que esto 00:38:48
no quede tan largo 00:38:51
también podría haber sacado fuera 00:38:52
esta y haberla llamado aquí 00:38:55
equilátero y haber sacado esta 00:38:57
fuera y haberla llamado es isósceles 00:38:59
y haberla metido, y a lo mejor el programa queda más claro 00:39:01
si lo saco a boolean separado 00:39:03
es triángulo, es equilátero, es isósceles 00:39:05
hay muchas formas de hacer lo mismo 00:39:06
entonces aquí 00:39:09
en este caso en que las condiciones 00:39:11
son tampoco homogéneas 00:39:14
entre sí 00:39:16
esa de arriba no tiene nada que ver con la de abajo 00:39:17
pues no es un programa 00:39:20
que uno hiciera con un switch case 00:39:22
un switch case uno lo planta 00:39:23
cuando lo que tiene que distinguir es en función 00:39:26
del valor de una variable, acá pon 00:39:28
entonces para una variable tiene que distinguir 00:39:29
entonces planta un switch case 00:39:31
¿vale? entonces ¿cómo transformaríamos 00:39:32
esto a un switch case? pues bueno 00:39:35
tendríamos que echarle imaginación 00:39:36
¿cuál es la idea 00:39:39
que teníais de partida? 00:39:41
trabajar con el switch ¿a qué variable 00:39:43
le pondríamos? 00:39:45
claro pero el switch necesita una variable 00:39:50
pero el switch necesita 00:39:53
una única variable aquí 00:39:55
o sea el switch y las decisiones 00:39:57
se tienen que hacer siempre en función de una única variable 00:39:58
y esas condiciones involucran varias 00:40:01
entonces tienes que transformarlo todo 00:40:03
para que las decisiones se tomen en función de una única variable 00:40:05
entonces hombre, esa variable puede ser un boolean 00:40:08
que tú has construido con las otras 00:40:12
pero entonces el switch solo tendría verdadero o falso 00:40:14
entonces sería un if 00:40:17
o puede ser una variable que contenga diferencias relativas entre lados 00:40:17
pero el switch case, la condición 00:40:22
tiene que estar formulada 00:40:25
en función exclusivamente de una variable 00:40:27
entonces 00:40:30
que contenga la condición 00:40:31
claro, pero entonces haces un switch en función de un boolean 00:40:40
que es switch, en el caso de true esto 00:40:43
entonces es un if, es igual que un if 00:40:44
un switch donde metes ahí un boolean 00:40:46
case true, case false, solo tendría dos case 00:40:49
case true, case false, entonces un switch con un boolean 00:40:51
case true, case false 00:40:53
no lo vas a ver, es un if 00:40:54
if se da esto, si no lo otro 00:40:57
no harías nunca un switch con un boolean 00:40:59
porque solo tiene dos case, true, false 00:41:01
entonces 00:41:03
formularlo con un switch case 00:41:06
es que se complica innecesariamente 00:41:09
claro, yo es que 00:41:11
no, hay que elegir 00:41:13
la sentencia que aplica en cada situación 00:41:15
entonces del switch case 00:41:17
la condición tiene que formularse en función 00:41:18
de una única variable, entonces si a ti 00:41:21
tu problema te está pidiendo eso 00:41:23
en función de una única variable pasan 00:41:24
cosas, entonces tengo un switch case 00:41:27
en función de una única variable, pero es que aquí 00:41:29
las condiciones dependen de tres variables 00:41:30
entonces de esas tres variables 00:41:33
tendría que mediante una fórmula 00:41:35
transportarlas a una única variable 00:41:37
y ser capaz de distinguir en función 00:41:39
de los diferentes valores 00:41:40
que podría ocurrir, podría hacerse 00:41:42
pero el programa sería mucho más complicado de entender 00:41:44
para el que lo viera 00:41:46
a mi no se me ocurre al menos, dime 00:41:48
si, si, si, claro, claro 00:41:49
vale 00:41:52
Aquí podríamos decidir a lo mejor 00:41:57
Vale, que mi switch decida en función del lado 1 00:42:15
Por ejemplo, en función del lado 1 00:42:18
Y luego, switch 00:42:20
Lado 1 00:42:22
Case igual a lado 2 00:42:23
Dentro del case me podría meter 00:42:29
Y también lado 3, equilátero 00:42:30
Pero es que se complica mucho 00:42:33
¿No? 00:42:35
La clave aquí es decidir en función de qué variable decido 00:42:37
es que tengo tres 00:42:40
en la que involucra mi decisión 00:42:41
la uno, la dos, la tres, decide en función de la uno 00:42:43
vale, si la uno es esto 00:42:45
pero no solo si es esto 00:42:47
porque además tiene que ser lo otro 00:42:49
entonces el case ya empieza a anidar cosas 00:42:50
no podemos trabajar así 00:42:52
tenemos que evitar 00:43:01
si es true o es false 00:43:02
si empezamos con es true o es false no hay nada 00:43:08
alternativo a ser true o false 00:43:10
es que no hay default 00:43:13
o es true o es false, nunca va a haber un default 00:43:15
Las cosas o son true o son false 00:43:17
Al default no entraría jamás 00:43:20
Tú puedes poner un default 00:43:21
Pero al default no entraría nunca 00:43:24
Porque o se es true o se es false 00:43:25
Ese default lo puedes poner 00:43:28
Pero jamás 00:43:31
De hecho el compilador te diría 00:43:32
Código inaccesible 00:43:34
Nunca jamás entraría lo que hay en ese default 00:43:36
Porque una condición 00:43:38
O es true o es false 00:43:42
Y si no es ni true ni false 00:43:43
Entonces esto 00:43:45
¿vale? entonces he organizado un poquito 00:43:46
el pensamiento para que 00:43:51
los códigos que resulten 00:43:52
sean un poquito organizados y en este caso 00:43:54
la diferencia entre if, else if 00:43:56
y switch case 00:43:59
ambos son sentencias 00:44:00
que hacen uno de varios caminos 00:44:02
pero el if, else if 00:44:05
las condiciones son todo lo abiertas 00:44:07
que uno quiera, con el switch case 00:44:09
la condición tiene que estar formulada 00:44:11
en función del valor de una única variable 00:44:13
en función del valor de una única variable 00:44:14
¿vale? entonces en función del tipo 00:44:16
de problema que yo tenga 00:44:18
¿vale? como 00:44:19
a ver, otro ejemplo raro 00:44:21
por ejemplo, vale, a ver 00:44:31
más cosas, por ejemplo 00:44:41
vamos a seguir jugando con el switch case 00:44:43
una transformación 00:44:47
que podríais hacer, pero es 00:45:03
hiper mega retorcida 00:45:04
y ya veréis en lo que va a parar 00:45:06
pero a ver 00:45:08
está bien que la entendamos 00:45:10
Para este mismo ejercicio de aquí 00:45:12
Vamos a hacer una transformación extrañísima 00:45:14
Pero vosotros lo habéis querido 00:45:16
Vale 00:45:19
Hemos dicho que el switch case 00:45:19
Tiene que decidir en función 00:45:23
De una única variable, ¿verdad? 00:45:25
Vamos a poner aquí 00:45:29
Otra forma rara 00:45:30
El switch case sería en estas ramas 00:45:32
Que es lo que fuera 00:45:44
Esto es lo que vosotros queréis, ¿no? 00:45:46
Hacer algo así 00:45:51
Que las ramas se vayan a diferentes keys 00:45:52
Ya, ya me imagino 00:45:54
Pero vamos a 00:46:03
Seguir jugando con el keys 00:46:04
Vale 00:46:06
Vamos a terminarlo 00:46:08
Este 00:46:20
Y este 00:46:27
Variable 00:46:29
¿Eh? 00:46:36
Eh, bueno, da igual 00:46:46
Da lo mismo 00:46:49
Pero, o sea, el default se pone siempre al final 00:46:50
Que si no es de los anteriores 00:46:53
Entonces por defecto eso 00:46:55
A ver 00:46:56
en el orden en el que pongas 00:46:57
equiláteros, pero eso da igual 00:46:58
entonces cambian las condiciones 00:47:00
espera, espera, que sí 00:47:01
a ver 00:47:08
lo que nosotros queremos es esto 00:47:11
queremos 00:47:13
tenemos cuatro ramas 00:47:14
un programa que sale por cuatro sitios 00:47:16
¿vale? cuatro condiciones asociadas 00:47:18
en función de cada una de ellas 00:47:21
o tres y la otra la que no es esa 00:47:23
me da igual, poner cuatro condiciones 00:47:26
que poner tres y la cuarta que sea 00:47:27
la que no es, o sea, el solo de forma 00:47:29
¿vale? me da igual 00:47:31
vale, entonces el programa 00:47:33
que son cuatro ramas 00:47:35
con cuatro condiciones asociadas 00:47:37
o le ponemos el if, el seif 00:47:39
con las condiciones 00:47:41
o decís, ¿y no lo puedo hacer con un switch case? 00:47:42
vale, si lo hacemos con un switch case 00:47:45
tenemos aquí las cuatro ramas 00:47:47
pero la condición sí o sí 00:47:48
tiene que estar formulada 00:47:51
en función de una única variable, ahí no hay tutía 00:47:52
entonces en función de una única variable 00:47:55
y del valor de esa variable, te debes ir por una rama 00:47:57
o por otra 00:47:59
vamos a hacer una cosa 00:47:59
vamos a hacer una variable que 00:48:01
le asignemos 0 00:48:03
si se cumple esta condición 00:48:05
esta 00:48:07
1 si se cumple esta 00:48:09
2 si se cumple esta 00:48:11
y 3 si se cumple esa 00:48:12
en función de si es 0, 1, 2 y 3 00:48:14
en la única transformación que podemos hacer 00:48:16
¿no? pues venga 00:48:19
vamos a hacerlo 00:48:21
¿os acordáis del operador ternario de asignación condicionada? 00:48:23
si se cumple la condición 00:48:27
asignamos un valor, vamos a asignar 0 00:48:28
si se cumple otra 00:48:30
asignamos otro valor, 1 00:48:32
si se cumple otra, asignamos otro valor, 2 00:48:34
y si se cumple otra, asignamos 3 00:48:36
y ahora ponemos ya en los case 0, 1, 2 y 3 00:48:38
y ya lo tenemos 00:48:40
pero tenemos que hacer 00:48:41
esa asignación condicionada 00:48:44
vamos a hacerlo 00:48:46
primera condición 00:48:48
la tenemos en un boolean 00:48:50
es comodilla, vale 00:48:52
acordados del operador ternario 00:48:53
Si no es triángulo 00:48:57
Si no es triángulo 00:49:00
Le voy a asignar un cero 00:49:03
Y ese va a ser mi caso cero 00:49:04
Vale 00:49:07
En el caso de que 00:49:08
Esta condición no se dé 00:49:11
Abro la siguiente 00:49:13
Que es esta de aquí 00:49:15
Abro la siguiente 00:49:16
Vale 00:49:22
Me falta la interrogación esta 00:49:25
Que esta se cumple 00:49:28
Pues entonces 00:49:33
le asigno el 1 00:49:35
que no se cumple 00:49:36
voy a evaluar la siguiente condición, que es esta 00:49:38
control Z 00:49:41
la siguiente condición, que es esta 00:49:44
no sé si he cogido el 00:49:47
paréntesis 00:49:58
voy a 00:50:00
lado 3 00:50:01
me hago la pregunta 00:50:06
que se cumple 2, que no 3 00:50:09
vale, y me falta el 00:50:11
paréntesis 00:50:13
ala, ya lo tenemos 00:50:15
Y ahora aquí ponemos el 0, 1, 2 y 3 00:50:17
Ahora ya lo hemos reconvertido en una única variable 00:50:23
En función de si una variable vale 0 o me voy por aquí 00:50:28
Si vale 1 me voy por aquí 00:50:31
Si vale 2 me voy por aquí 00:50:33
Si vale 3 me voy por aquí 00:50:34
Y a esa variable yo le asigno 0, 1, 2 y 3 en una de las condiciones 00:50:35
Que no es triángulo, le asigno 0 00:50:39
Recordad el operador este ternario 00:50:43
que si es triángulo, o sea que esta es falsa 00:50:46
pues entonces abro condición otra vez 00:50:50
abro condición 00:50:52
que es equilátero 00:50:54
le asigno 1 00:50:55
que no lo es 00:50:56
abro condición otra vez 00:50:58
que es isósceles 00:51:00
le asigno 2 00:51:02
que no lo es, le asigno 3 00:51:04
luego, todo lo que he puesto aquí 00:51:06
en realidad es una expresión 00:51:09
que se evalúa en una única variable 00:51:11
que es o 0 o 1 o 2 o 3 00:51:14
en función de la condición que yo le quiera poner 00:51:16
pero claro 00:51:18
esto 00:51:20
es más confuso 00:51:21
es más confuso que el if 00:51:23
pero lo importante es que nos quede 00:51:26
claro que el switch case lo usamos 00:51:28
cuando queremos decidir en función de una 00:51:30
única variable 00:51:32
aquí yo decido 00:51:33
en función de 3, de lado 1, lado 2 y lado 3 00:51:36
le decido en función de 3 00:51:38
entonces para convertirlo a una única variable 00:51:39
lo acabo de convertir 00:51:42
a una única variable que se convierte 00:51:44
en 0, en 1, en 2 o en 3 00:51:46
dentro de la condición, entonces ahora ya sí 00:51:48
¿vale? 00:51:49
pero si la decisión no es en función de una única 00:51:52
variable, sino que es una condición que involucra 00:51:54
varias, pues plantaré un if el save 00:51:56
sobre todo de esto, lo interesante es que 00:51:58
entendáis esto que he hecho yo aquí, porque es otra vez 00:52:06
practicar lo de siempre, es practicar este operador 00:52:08
entonces esto es una expresión 00:52:11
y las expresiones se supone 00:52:13
que ya no son cómodas, esto es una expresión 00:52:15
esta es una expresión que se evalúa 00:52:16
con 0 o con 1 00:52:18
o con 2 o con 3, es una expresión 00:52:21
bueno, pues en función del valor de esa expresión 00:52:23
lo que yo pongo aquí 00:52:27
pues hace esto, hace esto, hace esto y hace esto 00:52:28
bueno, vamos a parar aquí un momentito 00:52:30
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
5
Fecha:
16 de octubre de 2023 - 13:32
Visibilidad:
Público
Centro:
IES ROSA CHACEL
Duración:
52′ 38″
Relación de aspecto:
1.78:1
Resolución:
1280x720 píxeles
Tamaño:
1004.70 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid