Saltar navegación

Condicionales - 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 2023 por Stefano C.

15 visualizaciones

Más información Transcripción

Descargar la transcripción

Vale, estoy registrando, por lo tanto, todo lo que digáis implica que autorizáis que vuestra voz sea grabada 00:00:00
Y vamos a empezar hoy con estructuras de control, ¿vale? 00:00:07
Que son las estructuras de control 00:00:13
Sustancialmente, las estructuras de control son el nuevo paso, el nuevo avance 00:00:15
Que vamos a introducir al mundo de Java, al mundo de la programación 00:00:22
para por un lado complicarlo y por otro lado permitir hacer cosas mucho más avanzadas. 00:00:26
El primer elemento, la primera estructura que vamos a ver que será el IF 00:00:34
es muy parecido a lo que hemos hecho con el operador ternario, ¿vale? 00:00:39
Por favor, con el operador ternario, ¿vale? 00:00:47
Por lo tanto, algunas cosas os sonarán. 00:00:51
Solo que el IF es un poquito más potente con respecto al operador ternario básico, ¿vale? 00:00:54
Operador ternario básico, os recuerdo que al fin y al cabo es un operador, o sea que al final devuelve un resultado, una expresión, ¿vale? 00:01:00
Y además teníais dos opciones, o devuelves esto o devuelves esto de aquí, en base a una condición, pero las dos ramas tenían que tener el mismo tipo, ¿vale? 00:01:09
Si no tenía algún tipo de problemas, el IF veremos que es un poquito más potente, ¿vale? 00:01:18
¿Qué son las estructuras de controlo? 00:01:22
Son elementos del lenguaje que nos permiten romper el flujo lógico de ejecución de instrucciones 00:01:25
¿Vale? 00:01:30
Hasta ahora, nosotros estamos acostumbrados a que empiezo desde la primera sentencia 00:01:31
El primer comando de mi programa Java 00:01:37
Y voy ejecutando una línea, otra línea, otra línea, otra instrucción, otra instrucción, otra instrucción 00:01:42
De forma secuencial 00:01:47
Nosotros lo que hemos visto hasta ahora son bloques secuenciales de código 00:01:49
Ahora la idea es que introduzcamos algunas estructuras, algunos comandos, algunas palabras mágicas 00:01:55
Que lo que nos hacen es decir, vale, no sigas la secuencia desde arriba abajo siempre 00:02:04
En determinadas circunstancias te puedes saltar un trozo de código 00:02:12
Puedes hacer una parte pero no otra 00:02:17
O puedes volver a rehacer el mismo trozo de código 00:02:20
Una y otra vez y otra vez y otra vez 00:02:24
¿Vale? 00:02:26
Entonces también hay la posibilidad de 00:02:27
Desde aquí salta a otro trozo de código que está escrito en otro lado 00:02:30
Ejecuta ese trozo de código 00:02:35
Y luego vuelve desde donde había saltado 00:02:36
¿Vale? 00:02:39
Hay varias opciones que me permiten 00:02:40
En vez de ser lineal, de ser secuencial en mis programas 00:02:43
Romper cuál es el flujo lógico de esto va detrás de eso 00:02:47
Y hacer cosas distintas, ¿vale? 00:02:51
Por ahora no sabemos cuáles son y por lo tanto lo vemos 00:02:55
El flujo de ejecución sería el orden con el que se ejecutan los determinados conjuntos de instrucciones o sentencias 00:02:58
Y la idea de romper ese flujo de información quiere decir que estoy rompiendo el orden, ¿vale? 00:03:05
Ya lo que está escrito se ejecuta siempre en orden, pero cuando hay estas estructuras, pues ese orden se cambia, ¿vale? 00:03:10
Hay un orden un poquito distinto. 00:03:17
Vale, flujo normal es de arriba abajo y de izquierda a derecha, ¿vale? 00:03:21
Entonces, existen tres tipos, existen más, ¿vale? 00:03:25
Pero por ahora nosotros trabajamos con tres tipos de sentencias de control, ¿vale? 00:03:29
Lo que son los condicionales, lo que son las sentencias de control iterativas y lo que son los llamados a métodos, vale 00:03:33
Los condicionales son el if, vale, el if que nosotros ahora vamos a aprender es parecido a lo que hemos visto del operador ternario, vale 00:03:42
Y es un condicional, en base a una condición ejecuto un código o no lo ejecuto, vale 00:03:54
En su forma más básica 00:04:02
Y luego está la forma un poquito más avanzada 00:04:04
Que es el if-else 00:04:07
Que es, si la condición es verdadera 00:04:07
Ejecuto un determinado código 00:04:10
Si es falsa, ejecuto un código distinto 00:04:12
¿Vale? 00:04:15
También existe otro condicional 00:04:17
Que es el switch 00:04:19
Que lo veremos 00:04:20
¿Vale? 00:04:21
Que es comparar un cierto valor 00:04:22
O sea, una variable 00:04:25
Con muchos valores posibles 00:04:27
¿Vale? 00:04:29
Imaginaos que yo tenga un int 00:04:30
Y diga, si este x es 1 00:04:32
Hace esta cosa, si x es 2 00:04:35
Hace esta otra cosa, si x es 3 00:04:36
Hace esta otra cosa, como si se fuera un if 00:04:38
Pero multivalor 00:04:40
Multiopción 00:04:43
¿Sí? 00:04:44
La verdad es que if switch 00:04:45
Y if else 00:04:49
Son exactamente iguales 00:04:50
Son estructuras 00:04:53
Condicionales 00:04:54
Todo lo que se hace con un switch 00:04:55
Se puede hacer con un if, todo lo que se hace con un if 00:04:58
Se puede hacer con un switch 00:05:00
La idea es que 00:05:02
En determinados casos 00:05:04
Uno de estos es 00:05:06
Más cómodo que el otro 00:05:08
Y por lo tanto nosotros aprenderemos 00:05:10
Cuando usamos uno y cuando usamos el otro 00:05:12
Pero eso no quita que 00:05:14
Lo que en realidad necesitamos 00:05:16
Es lo que se llama un condicional 00:05:19
Un método 00:05:21
Un mecanismo 00:05:24
Una herramienta 00:05:27
Que lo que me permite hacer es 00:05:28
Decidir si un trozo de código se puede ejecutar 00:05:30
O no 00:05:32
Con eso es suficiente 00:05:33
Hay lenguajes que me proporcionan 00:05:34
Varios tipos de condicionales 00:05:38
Hay lenguajes que me proporcionan menos tipos de condicionales 00:05:39
Pero me da igual con que se pueda ejecutar 00:05:42
Un condicional 00:05:44
Pues ya puedo hacer todos los programas 00:05:45
Que podría hacer con otros programas 00:05:48
Con otros lenguajes que a lo mejor me dan más condicionales 00:05:50
Pero lo que nos interesa 00:05:53
Es la estructura de control 00:05:54
Esta que me permite decir 00:05:56
Si una condición es válida ejecuta ese trozo 00:05:57
Si no, no 00:05:59
Los iterativos 00:06:00
Que son el while, el do while, el for 00:06:03
¿Vale? 00:06:06
Que son varias estructuras distintas 00:06:06
Y misma cosa 00:06:09
¿Vale? 00:06:11
Lo que permiten hacer los iterativos es 00:06:12
Repetir un trozo de código 00:06:14
Un bloque de código 00:06:16
Una y otra vez, y otra vez, y otra vez 00:06:18
Mientras 00:06:20
While 00:06:21
Una condición es verdadera 00:06:22
Yo tendré while y una condición 00:06:24
Y mientras esta condición se permanezca como verdadera 00:06:28
Yo seguiré ejecutando el bloque que viene a continuación 00:06:32
Una y otra vez y otra vez 00:06:35
Cuando lo acabo, empiezo desde el principio 00:06:37
Cuando lo acabo, empiezo desde el principio 00:06:39
Cada vez que empiezo otra vez 00:06:41
Vuelvo a comprobar que la condición que he puesto sea verdadera 00:06:43
Si sigue verdadera, lo ejecuto otra vez 00:06:47
Si no, no 00:06:49
¿Vale? 00:06:50
El do while, lo mismo 00:06:52
¿Sí? 00:06:53
Con un matiz que una vez siempre lo ejecuto 00:06:54
Y luego chequeo si es verdadero o falso 00:06:57
Mientras aquí, si fuera falsa la condición 00:06:59
No lo ejecutaría nunca 00:07:02
Y el for es más de lo mismo 00:07:03
Pero normalmente se suele utilizar cuando 00:07:07
Sabemos cuantos ciclos quiero hacer 00:07:10
En plan, quiero hacer 10 veces este ciclo 00:07:13
Pues uso más un for que un while 00:07:15
Aún así, lo veremos con detalle más adelante 00:07:17
Aún así, si yo tuviera solo el while 00:07:21
Puedo hacer todo 00:07:24
Me interesa 00:07:25
Una sentencia de control iterativa 00:07:27
Con el for se puede hacer 00:07:32
Todo lo que hace el while 00:07:34
Y con el while se puede hacer todo lo que hace el for 00:07:35
Eso es indiferente 00:07:37
Simplemente que en determinados casos 00:07:39
El for es mucho más cómodo 00:07:41
Y en determinados otros casos el while es mucho más cómodo 00:07:43
Entonces tengo las dos opciones 00:07:46
Y la llamada 00:07:47
SamMethods es lo que me permite 00:07:49
Saltar desde 00:07:51
El punto donde estoy 00:07:53
a otro trozo de código marcado 00:07:55
con un nombre, lo que será un método 00:07:57
¿vale? ejecutar ese 00:07:59
trozo de código y volver a donde 00:08:01
estaba antes de llamar este 00:08:03
método, vosotros habéis visto un ejemplo 00:08:05
con por ejemplo el println 00:08:07
cuando vosotros hacéis system.auto.println 00:08:08
lo que hace vuestro código 00:08:11
es pararse allí 00:08:13
ejecutar un código que está escrito 00:08:14
en otro lado, que es el método 00:08:17
println que no habéis escrito vosotros, que nos han 00:08:18
dado, ya ha hecho 00:08:21
quien sabe quien, ¿vale? 00:08:22
Una vez ejecutado ese código allí 00:08:24
Que imprime algo en pantalla 00:08:26
Vuelve el control 00:08:29
A mi secuencia 00:08:31
De instrucciones y se ejecuta 00:08:33
Justo la 00:08:35
La sentencia después 00:08:36
¿Vale? Cuando nosotros hacemos 00:08:39
System.println 00:08:40
Dame un número y luego leemos un número 00:08:41
Ese println es un método 00:08:45
Que está escrito en otro lado que se ejecutará 00:08:47
Por otro lado y luego 00:08:49
El control vuelve a mi programa 00:08:50
Y pasa al scan que ejecuta otro método 00:08:52
También el scan.nexint 00:08:55
Es otra cosa más 00:08:57
Igual, ¿vale? 00:08:58
Yo no lo he escrito, ¿qué hace el nexint? 00:08:59
El nexint es una llamada 00:09:02
A un método 00:09:04
Scan.nexint 00:09:05
Como aquí, objeto.metodo 00:09:08
Y esto me permite ejecutar 00:09:10
Código de otro lado y lo vuelve 00:09:12
¿Sí? 00:09:14
Entonces, estas tres cosas 00:09:16
Lo que tienen en común 00:09:18
Es que ahora, en vez de ejecutar 00:09:19
Uno tras otro 00:09:22
Todos los comandos que yo tengo 00:09:24
Puedo cambiar el orden 00:09:26
Con que se ejecutan 00:09:28
¿Vale? En el caso del if 00:09:30
Puedo decidir si un trozo, si un bloque 00:09:32
Se ejecuta o no 00:09:34
En el caso de las iterativas, puedo decir que un bloque 00:09:35
Se ejecute varias veces 00:09:38
Y en el caso de las llamadas métodos, puedo decir 00:09:40
Cuando llegas a este punto, ejecuta 00:09:42
Un trozo de código que está en otro lado 00:09:44
Y luego vuelve 00:09:46
¿Dudas? 00:09:47
Entonces 00:09:54
esta es el if 00:09:54
¿vale? el if existe 00:09:56
en dos formados 00:09:59
el if a secas y el if else 00:10:00
¿vale? en algunos programas 00:10:03
en algún lenguaje de programación 00:10:05
es conocido también como 00:10:06
if then else 00:10:07
si, entonces 00:10:10
y si no 00:10:12
¿vale? pero por ejemplo en java 00:10:13
el then no se usa 00:10:16
en lenguajes viejos si que había que escribir 00:10:17
también then 00:10:20
Entonces, miramos antes el IFASECAS 00:10:20
Aquí viene mi flujo de información normal de ejecución 00:10:28
Y llega una condición 00:10:34
Si esta condición es verdadera 00:10:36
Entonces se ejecuta lo que está en este bloque de aquí 00:10:39
Todas las instrucciones que están aquí se van a ejecutar 00:10:42
Si es falsa, me salto este bloque y sigo adelante 00:10:46
En los dos casos seguiré adelante haciendo las cosas que vienen después, pero sostancialmente me está diciendo que si esta condición es verdadera, entonces se ejecutará también este bloque y si no, no. 00:10:50
¿Sí? ¿Dudas? 00:11:03
En el caso del if-else, en vez tengo dos bloques separados y ejecutaré o uno o el otro en base a si la condición es verdadera o falsa. 00:11:07
Y esto nos suena muchísimo a lo que ya hemos hecho, al operador ternario, ¿vale? 00:11:19
Si la operación, si la condición es verdadera, entonces ejecuta el bloque a la izquierda, 00:11:25
si el rango sigue hacia adelante, si la condición es falsa, ejecutarás el bloque a la derecha y sigue hacia adelante. 00:11:30
¿Qué diferencia fundamental hay entre el IF y el operador ternario? 00:11:38
No tiene que mostrar un tipo de datos 00:11:44
Sí 00:11:57
¿Qué más? 00:11:57
¿Qué? 00:12:00
Estos son bloques de instrucciones 00:12:07
Aquí no va una instrucción 00:12:09
O una expresión 00:12:11
¿Vale? 00:12:13
En el ternario estaba la condición 00:12:14
Y luego la rama verdadera 00:12:18
Y la rama falsa eran expresiones 00:12:20
Podía poner expresiones booleanas 00:12:22
Podría poner expresiones numéricas 00:12:24
Pero eran expresiones, era un cálculo 00:12:26
Y de allí sacaba un valor 00:12:28
Y ese es el valor que devolvía el operador 00:12:29
Es una operación al fin y al cabo 00:12:31
Como la suma, 5 más 3 te devuelve 8 00:12:33
Y ya está 00:12:35
Pues el operador ternario es una cosa compleja 00:12:36
Pero te devuelve 5 o te devuelve 7 00:12:39
O te devuelve válido 00:12:42
O te devuelve no válido 00:12:44
¿Sí? 00:12:46
Sin embargo, el IF 00:12:47
Es una versión más potente 00:12:48
De esa idea 00:12:52
¿Vale? Yo no es que tengo que aquí en estos bloques hacer solo una sentencia, hacer solo una operación 00:12:52
¿Vale? Yo aquí en estos bloques puedo hacer un programa entero si quiero 00:12:58
Yo puedo hacer que aquí al principio esta condición sea un menú donde pida al usuario 00:13:03
¿Qué quieres hacer? ¿Quieres jugar a este juego o jugar a este otro juego? 00:13:09
Y si tú eliges uno, pues ejecutará el juego a la izquierda 00:13:13
Y si tú eliges dos, ejecutará el juego a la derecha 00:13:18
Y es un programa entero el bloque del I 00:13:21
¿Sí? 00:13:23
O no lo sé 00:13:25
Lo que nos ocurre, ¿vale? 00:13:27
Tened en cuenta que hay estas dos versiones 00:13:30
Que son iguales 00:13:33
Porque si yo pillo el else 00:13:34
En el bloque de la derecha 00:13:36
Pongo nada 00:13:38
Pues estoy haciendo esto 00:13:39
Estoy haciendo lo que viene a la izquierda 00:13:40
¿Sí? 00:13:43
Me acuerdo que si este bloque es paréntesis 00:13:44
Llave abierta, llave cerrada 00:13:47
Pues este se está portando 00:13:49
Exactamente como este de aquí 00:13:51
Entonces, en el caso en que yo tenga que hacer 00:13:52
Dos cosas distintas, si la condición es verdadera 00:13:54
O falsa, pues tengo leafels 00:13:57
Normalmente, si yo digo 00:13:59
Simplemente que si la condición es verdadera 00:14:01
Entonces se joda algo, y si no, no hagas nada 00:14:03
Pues esto de aquí 00:14:05
O uso este con un bloque vacío 00:14:06
Pero es más feo 00:14:09
Sí 00:14:10
En el leafels solo puedes hacer dos cosas 00:14:11
Por ejemplo, en las notas 00:14:14
La condición es única 00:14:16
Ahora, nadie te prohíbe 00:14:33
Dentro de un bloque 00:14:36
De poner otro if 00:14:37
Entonces 00:14:39
Empiezas a anidar if 00:14:40
Hacer if en cascada 00:14:43
Un if dentro de otro if dentro de otro if 00:14:45
Que es parecida a la idea que hemos hecho nosotros 00:14:47
Cuando metíamos en una de las ramas 00:14:49
De los 00:14:51
De los operadores ternarios 00:14:52
Otro operador ternario 00:14:54
¿Sí? 00:14:56
Hasta un cierto nivel 00:15:00
¿Vale? 00:15:01
Se suele aconsejar que no haya 00:15:02
Demasiado anidación de un if 00:15:05
Dentro de un if, dentro de un if, dentro de un if 00:15:07
También porque, y lo veréis con la experiencia 00:15:09
Cuando llegáis a hacer 00:15:11
demasiados if uno dentro de otro 00:15:13
es que os estáis equivocando 00:15:15
y la solución va por otro lado 00:15:17
¿vale? pero aún así 00:15:18
que se pueda poner if dentro de if 00:15:21
sí, se hace 00:15:23
y que nosotros lo haremos sobre todo en los primeros ejercicios 00:15:24
que serán ejercicios de if 00:15:27
¿vale? entonces sí que habrá 00:15:28
como no podemos utilizar 00:15:31
otros mecanismos 00:15:33
y otras herramientas 00:15:35
porque todavía no las hemos visto 00:15:37
pues entonces nos saldrán monstruos 00:15:38
que por ahora son aceptables 00:15:41
Y dentro de un rato veremos que no 00:15:43
Que hay soluciones más 00:15:45
Más elegantes 00:15:46
¿Más dudas? 00:15:49
Sí 00:15:51
No, cuando es falso sigue adelante 00:15:51
Aquí no estamos en la iterativa 00:15:59
Aquí no repetimos código 00:16:04
Aquí es una condicional 00:16:05
En base a una condición 00:16:07
O hago una cosa o hago otra 00:16:09
Que podría ser no hago nada 00:16:11
¿Sí? 00:16:13
Pero es condición y me permite elegir, ¿hace esto o hace esto? 00:16:15
Con el if no, en la estructura que estamos viendo ahora, ¿cuál estructura me permitiría volver a hacer el mismo? 00:16:23
La iterativa, que todavía no la he visto, ¿vale? 00:16:37
Con un while, yo puedo decir que cuando llegue a este punto, pues vuelva arriba mientras una condición sea verdadera. 00:16:39
Ejemplo de if. 00:16:48
¿Vale? Entonces, tengo una variable x que vale 5, if, ¿vale? 00:16:50
Palabra reservada, que no está diciendo un sí, paréntesis, que dice que aquí va la condición, ¿vale? 00:17:00
La condición va entre paréntesis después del if. 00:17:06
Si x es menor que 5, pues entonces escribe esta cosa aquí, punto y coma. 00:17:09
System.org.lf, ¿vale? 00:17:16
¿Qué escribe este código de aquí? 00:17:19
fin. ¿Por qué? Porque el bloque del if es desde aquí hasta aquí. O sea, solo la primera 00:17:22
línea. Entonces, si esta condición es verdadera, me escribe menor que fin. Y luego, en cualquier 00:17:37
caso, me escribe fin 00:17:45
esto 00:17:47
es la izquierda o la derecha? 00:17:49
azul, vale? 00:17:54
es un if 00:17:57
con solo 00:17:58
si es verdadero o azal 00:17:59
nosotros hemos dicho 00:18:00
que aquí en el if 00:18:05
lo que puede ir es un bloque 00:18:07
de instrucciones 00:18:09
un bloque, lo vimos cuando vimos 00:18:10
El ámbito de una variable 00:18:13
¿Os acordáis? 00:18:17
Es un trozo de código 00:18:18
Una serie de instrucciones 00:18:20
Que están delineadas 00:18:22
Que están enmarcadas 00:18:24
Entre una llave y otra llave 00:18:26
¿Vale? 00:18:27
Entonces en este caso de aquí 00:18:29
Por ejemplo yo tengo 00:18:30
Si esta condición es verdadera 00:18:31
X es menor que 6 00:18:34
Entonces ejecuta todas estas instrucciones de aquí 00:18:35
Ejecuta este bloque 00:18:39
¿Si? 00:18:41
Cuidado, esto es correcto, pero si no pongo las paréntesis, solo ejecuta, o sea, el bloque es una sola instrucción, ¿vale? 00:18:43
Entonces esta, esta no está en el if, la que pone fin no está dentro del if, es después del if, la que pone fin está aquí, aquí donde la flecha, ¿vale? 00:18:55
Ya hemos hecho el if 00:19:08
Y hemos llegado aquí 00:19:09
La única parte que está dentro 00:19:10
Es esa de es menor que 5 00:19:12
Y está aquí en el bloque 00:19:14
¿Vale? 00:19:15
Entonces si esta es verdadero 00:19:17
Ejecuto esa 00:19:18
Y luego ejecuto aquí debajo 00:19:19
La fin 00:19:20
Si en vez de esta es falsa 00:19:21
Me salto 00:19:23
Ejecutar esta 00:19:24
Y va a dar 00:19:25
Esquivo fin 00:19:26
O sea que 00:19:27
En este caso de aquí 00:19:27
Fin se ejecuta siempre 00:19:29
De hecho lo pone 00:19:30
¿Sí? 00:19:31
Si pero yo quiero ejecutar 00:19:33
Si esta 00:19:36
Si la condición es verdadera 00:19:36
Más de una sentencia 00:19:37
Más de una 00:19:40
Instrucción, pues entonces 00:19:41
Tengo que marcar que si esto 00:19:43
Es verdadero, haz todo esto 00:19:45
Entonces sí que pongo las llaves 00:19:48
¿Vale? Consejo mío 00:19:49
Poned las llaves aquí 00:19:52
También, siempre 00:19:54
¿Vale? Asumid 00:19:55
Que la estructura 00:19:57
De un if, paréntesis 00:19:59
Condición, paréntesis, llave 00:20:01
Bloque, llave 00:20:03
Siempre, hasta si es solo una 00:20:05
Solo una condición, hasta si no hay condición 00:20:07
Ya, o sea, si no hay sentencias 00:20:09
¿Vale? Llave, cierre y llave 00:20:11
¿Está? Entonces, ¿qué pondría 00:20:13
Este de aquí? Pues, como 00:20:17
X es menor que 6, porque X es 00:20:19
Igual a 5, escribiría resultado 00:20:21
Que es esta aquí, escribiría 00:20:23
Menor que 6, y escribiría 00:20:25
Fin, ¿sí? 00:20:27
Claro, o sea, y fin, este ya fuera del hit 00:20:31
Porque se sale del corchete 00:20:33
Este y, de hecho 00:20:34
Si yo pusiera que X es 10 00:20:37
¿Qué escribiría? 00:20:39
Solo fi, porque 10 no es menor que 6, me salto todo el bloque, escribo esto. 00:20:41
¿Dudas? 00:20:48
No, porque está dentro del bloque. 00:20:54
Entonces, yo esto lo ejecuto solo si x es menor que 6. 00:20:58
Y en este caso x es menor que 6, por lo tanto ejecuto estos dos. 00:21:01
Si yo tuviera x es igual a 10, como 10 no es menor que 6, saltaría todo el bloque, 00:21:04
Escribiría solo fin 00:21:10
O sea, no escribiría ni resultado ni menor que 6 00:21:11
Es solo para que ponga 2 00:21:14
Y aquí podéis hacer 00:21:22
Todo lo que da la gana 00:21:24
Aquí podéis leer una letra 00:21:25
Podéis leer de teclado 00:21:28
Podéis escribir en pantalla 00:21:29
Podéis hacer sumas 00:21:31
Podéis utilizar operador ternario 00:21:32
Podéis hacer lo que os da la gana 00:21:35
Dentro de un bloque 00:21:37
Es un bloque 00:21:37
Es la parte del programa 00:21:38
Que tienes que ejecutar 00:21:44
Cuando esta condición es verdadera 00:21:45
Si yo creo una variable 00:21:47
Dentro del bloque if 00:21:58
Fuera del bloque if 00:22:00
No se ve esa variable 00:22:02
Porque es el ámbito de la variable 00:22:04
Y si yo quiero verla fuera 00:22:07
Pues la declaro antes del if 00:22:09
La actualizo dentro del if 00:22:11
Y fuera sigo viéndola 00:22:14
Porque sigue existiendo 00:22:16
Como está aquí 00:22:17
Fijaos también que 00:22:19
Bueno, aquí no la uso 00:22:22
Si la variable la creo fuera 00:22:23
Mucho del if 00:22:26
Sí, porque si la creo 00:22:26
O sea, el bloque este allí del if 00:22:29
Está incluido en el bloque más grande 00:22:32
Donde he declarado esta 00:22:34
Sí, por lo tanto 00:22:35
El ámbito de la variable incluye también el if 00:22:38
Más preguntas 00:22:40
¿Qué pasaría 00:22:41
Si no pusiera estas dos 00:22:51
ya ves 00:22:53
¿qué escribe? 00:22:55
no, escribiría 00:23:00
resultado menor que 6 fin 00:23:02
pero si pusiera 00:23:04
x igual a 10, ¿qué escribiría? 00:23:06
menor que 6 fin 00:23:09
porque ahora if 00:23:11
solo sería la primera 00:23:14
sentencia, entonces esta se la salta 00:23:15
pero esta aquí la escribiría 00:23:18
¿Sí? Entonces cuidado con 00:23:20
Lo que hacéis con las 00:23:23
Pero si os acostumbráis a 00:23:25
Poner llaves y pensar 00:23:28
Que todo lo que tengo que hacer si este es verdadero 00:23:30
Lo pongo aquí dentro y ya está, ningún problema 00:23:32
Más ejemplo 00:23:34
Este es un ejemplo 00:23:36
De Ifells 00:23:38
Si x 00:23:39
Es menor que 5 00:23:42
Entonces ejecuta 00:23:44
Este bloque de aquí, veis que es un bloque 00:23:46
¿Ok? 00:23:48
Si no 00:23:49
Ejecuta este bloque de aquí 00:23:51
Y luego ejecuta esto 00:23:53
Sí 00:23:57
Sí 00:23:58
Claro, esta es una sentencia 00:24:01
La sentencia 00:24:06
Exactamente como antes, como se escribía de afuera 00:24:09
De hecho tú has escrito siempre en un bloque 00:24:11
Porque tú pones 00:24:13
Public static void main string 00:24:15
Y abres una llave 00:24:17
Y allí pones punto y coma como te haga gana 00:24:18
¿Sí? 00:24:21
Fijaos que el if por sí mismo 00:24:24
No tiene un punto y coma al final 00:24:26
Porque si tú lo piensas así 00:24:29
Este es el bloque, luego está el se 00:24:31
Y luego este bloque, aquí iría un punto y coma 00:24:33
Pero no, ¿vale? 00:24:35
El if es una sentencia de comando 00:24:37
Simplemente que dice por un lado o por el otro 00:24:38
No hace falta 00:24:40
Si os olvidáis y ponéis un punto y coma aquí 00:24:40
No pasaría nada 00:24:43
Sería una instrucción vacía que no hace nada 00:24:43
Pero no hace falta 00:24:45
¿Sí? 00:24:47
Y entonces 00:24:48
Si aquí yo pongo x igual a 5 00:24:52
Como x 00:24:54
No es 5, no es menor que 5 00:24:56
Pues entonces ejecutaría 00:24:58
La rama else 00:25:00
Y entonces me escribiría mayor o igual que 5 00:25:00
Y luego 00:25:03
Acaba el if y me escribe 00:25:05
Fin 00:25:08
Puede haber el if 00:25:12
Pero 00:25:14
Por ahora pensarlo con esto 00:25:15
Si quiero hacer varios else 00:25:18
Pues en el else 00:25:20
Pongo e if no sé qué no sé cuánto 00:25:21
Else no sé qué no sé cuánto 00:25:24
¿Tiene sentido que haya varios else? 00:25:25
Yo te digo 00:25:31
Si x es menor que 5 hace esto 00:25:32
Si no esto 00:25:34
Y si no este otro 00:25:35
¿Tiene sentido? 00:25:37
Si no a qué 00:25:38
O sea, aquí hay una condición que puede ser o verdadero o falso 00:25:39
O esto, si no, esto 00:25:42
No puede haber un otro y si, si no 00:25:45
No sé si me explico 00:25:48
Lo que sí puede hacer es 00:25:49
Si x es menor que 5, hace esto 00:25:51
Y si no, si x es igual a 5 00:25:53
Hace esto 00:25:57
Y si no a todos esto, pues hace otra cosa 00:25:57
Y eso se puede hacer con 00:26:00
Otro if o con el else if 00:26:04
Es sustancialmente lo mismo 00:26:07
Else 00:26:08
El ese se puede poner en esa línea de arriba 00:26:09
O tiene que ir abajo 00:26:14
Si yo empecé diciendo 00:26:15
Si no, hace esto 00:26:18
¿Qué tiene sentido? 00:26:20
Si lo lees de izquierda a derecha 00:26:22
El if y lees esto 00:26:24
El el se puede poner ahí 00:26:26
En la línea de arriba 00:26:28
Pero detrás del corchete 00:26:31
¿Aquí? 00:26:32
¿Dónde te da la gana? 00:26:34
Normalmente 00:26:36
Por claridad 00:26:37
Se hace una cosa así 00:26:40
El if y luego todo lo que está en el if 00:26:41
Intentado a la derecha 00:26:45
Luego el else al mismo nivel del if 00:26:46
Y todo el bloque del else 00:26:49
Movida hacia la derecha 00:26:51
Con sangría 00:26:53
Sangrilla 00:26:54
¿Sí? 00:26:55
Otro ejemplo de if, ¿vale? 00:27:00
¿Qué hace esto? 00:27:03
Lo que acabamos de decir, ¿no? 00:27:06
Si x es menor que 5, este bloque 00:27:15
Si no 00:27:17
Y aquí en vez de un bloque 00:27:19
He puesto una sola instrucción 00:27:21
¿Y qué instrucción es? Un if 00:27:23
¿Vale? Entonces, toda la parte roja 00:27:24
Si esto es un rojo 00:27:27
¿Vale? 00:27:29
Estaría dentro como bloque del else 00:27:30
Como única instrucción del else 00:27:33
¿Vale? ¿Y qué hago allí? 00:27:35
Pues otro if 00:27:37
Si es igual a 5, escribe que es igual a 5 00:27:38
Y si no 00:27:41
Este si no se ejecutará 00:27:42
Si y solo si 00:27:44
Esto es falso y esto es falso 00:27:45
¿Vale? 00:27:48
Porque está dentro del else 00:27:50
Yo nunca llegaré a la parte roja 00:27:52
Si la parte azul es verdadera 00:27:56
Si la condición azul es verdadera 00:27:59
¿Vale? 00:28:01
Entonces para llegar a mayor que 5 00:28:01
Tiene que ser que la condición azul sea falsa 00:28:04
Entonces me voy a la rama else 00:28:07
Y que dentro de 4 otro if 00:28:08
Y que esta condición, la condición roja 00:28:10
También sea falsa 00:28:12
Y entonces me voy a este else 00:28:14
Y aquí explico 00:28:15
Sí 00:28:16
Ahí 00:28:19
Si quisiera esto 00:28:26
Toda la línea 00:28:30
Pero entonces 00:28:34
Si pusiera así 00:28:37
No puedo dar dos alternativas 00:28:38
Negativas a la misma condición 00:28:43
Ponme que has quitado esto 00:28:45
Tienes dos sets 00:28:48
¿No? 00:28:49
Ok, este es verdadero 00:28:50
Ejecuto esto 00:28:51
Este es falso 00:28:52
¿Cuál hago? ¿Esto o este? 00:28:53
Acordaros que 00:28:57
Estamos en booleano 00:28:58
Verdadero o falso, no hay un tercer valor 00:28:59
No tengo ni idea 00:29:01
Entonces no puedo poner dos else 00:29:02
A una misma condición 00:29:05
Es o esto o esto 00:29:06
Se acabó, no hay otra opción 00:29:08
Si yo quisiera 00:29:10
Imprimir estas dos a la vez 00:29:13
Pues quito esto, quito este else 00:29:15
Y como else digo que es igual a 5 00:29:16
Es mayor que 5 00:29:19
Eso no tiene sentido 00:29:20
En este ejercicio 00:29:23
¿Dudas? 00:29:25
Tened en cuenta que esto se ejecuta siempre 00:29:27
¿Vale? Y aquí había tres casos 00:29:29
Pongamos que esto sea cuatro 00:29:31
Pues entro aquí 00:29:33
Cuatro es menor que cinco 00:29:35
Sí, me escribe menor que cinco 00:29:37
Y sale del if azul 00:29:39
Que sería aquí 00:29:42
Esto no debería ser rojo 00:29:44
Sería, si está en punto alto 00:29:46
En fin, que está fuera del top 00:29:48
¿Vale? Y lo escribiría 00:29:50
Si yo pongo cinco 00:29:52
Pues cinco es menor que cinco 00:29:54
Falso, iría al else 00:29:56
Y se preguntaría, 5 es igual o igual a 5 00:29:58
Verdadero, entraría aquí dentro 00:30:00
Pone igual que 5 00:30:03
Y luego sale fuera 00:30:05
Escribe este 00:30:07
Y finalmente 00:30:07
Si fuera 6, x igual a 6 00:30:10
Pues entonces 6 es menor que 5 00:30:12
Falso, me voy al else azul 00:30:14
Que me dice, si 6 es igual a 5 00:30:16
Falso, me voy al else rojo 00:30:19
Escribo 00:30:22
Es mayor que 5 00:30:23
Y luego después escribo fin 00:30:24
Esto de aquí 00:30:26
Debería ser negro 00:30:30
Y esto de aquí negro 00:30:32
Para ser más claro 00:30:33
¿Lo veis? 00:30:35
Más claro así 00:30:57
¿O así? 00:30:59
¿Hace más claro? 00:31:04
Bastante más completo 00:31:08
Aquí yo veo los dos bloques 00:31:09
Verdadero y falso 00:31:16
De la primera condición 00:31:18
Y si entro en el falso veo 00:31:19
Verdadero o falso en la condición 00:31:22
¿Vale? Además fijaos que 00:31:23
Esto está todo alineado 00:31:26
Mientras lo que está dentro de un bloque 00:31:28
Está como empujado un poco a la derecha 00:31:30
Entonces veo fácilmente donde empieza 00:31:32
Y donde acaba el bloque, el C por ejemplo azul 00:31:34
Cosa que aquí 00:31:36
Me cuesta un poquito más 00:31:38
¿Sí? 00:31:40
Luego haremos ejemplos 00:31:43
¿Qué devuelve? 00:31:46
Yo escribo esto 00:31:51
¿Qué pasa? 00:32:13
¿Dónde está el problema aquí? 00:32:17
¿Es necesario el else? 00:32:22
¿Es necesario el else? 00:32:27
Pues ya está 00:32:30
¿Dónde está el problema aquí? 00:32:31
¿Cómo no? 00:32:44
Tiene un if 00:32:45
El problema aquí es 00:32:46
Porque yo entiendo que si es menor que 1 00:32:53
¿Vale? 00:32:55
Entonces aquí iría la instrucción de este if 00:32:57
Que es esta 00:33:00
¿Vale? 00:33:00
Entonces si he puesto dentro del if como instrucción 00:33:02
Un bloque con este if 00:33:04
Pero la pregunta es 00:33:06
¿Es este else? 00:33:08
¿Es el else de este if? 00:33:10
¿O es el else de este if? 00:33:13
Porque si 00:33:18
o sea, es 00:33:19
y fíjate que uno hace todo esto 00:33:23
¿por qué no? 00:33:26
de hecho lo hemos hecho 00:33:28
cuando hemos hecho esto 00:33:29
es y hemos puesto un if entero 00:33:31
¿por qué no? 00:33:33
esto es 00:33:38
por pantalla 00:33:39
no saldría nada 00:33:44
¿vale? 00:33:46
La que la sentencia if 00:33:46
Tiene dos formas, if e if else 00:33:48
¿Vale? Y cuando se mezclan ambas 00:33:51
No se puede saber a cuál de los dos 00:33:53
Se hace referencia 00:33:55
¿Vale? Aquí es un poco un caos 00:33:56
¿Cómo soluciona este caos? 00:33:59
Con las llaves 00:34:02
Por lo tanto, de aquí el consejo de antes 00:34:02
Usad siempre las llaves 00:34:05
Si yo pongo una llave aquí y una llave aquí 00:34:06
O sea, después de 00:34:09
De i menor que 1 00:34:11
Y al final del todo 00:34:13
Pues lo que estoy diciendo 00:34:14
Es que si este es verdadero 00:34:17
Haz todo lo que hay aquí 00:34:18
El else se refiere al segundo if 00:34:19
Si yo en vez de pongo 00:34:21
Una paréntesis aquí 00:34:24
Y luego otra paréntesis aquí 00:34:26
O sea una llave aquí 00:34:28
Estoy diciendo que si este es verdadero 00:34:29
Haz esta cosa de aquí 00:34:31
Y si no, haz esta otra cosa 00:34:32
¿Sí? 00:34:34
Entonces usad las llaves 00:34:37
¿Se pueden usar? 00:34:38
Sí, usadlas siempre 00:34:41
O sea evita problemas 00:34:42
¿Dudas? 00:34:44
¿El método main lo puedo meter dentro del main? 00:34:52
Todo esto va dentro del método main 00:34:57
Siempre nosotros escribimos dentro del main 00:34:59
Por ahora nosotros no sabemos 00:35:03
Escribir fuera del método main 00:35:05
Todo lo que hacemos es dentro del bloque main 00:35:07
Sí, pero 00:35:10
¿Por qué el método main? 00:35:11
No puede meter dos main 00:35:18
Por ahora 00:35:20
Olvida 00:35:22
Por ahora simplemente te escribes dentro del main 00:35:23
Todo lo que viene antes y después 00:35:27
Son cosas que tengo que escribir 00:35:29
Porque programación es un objeto 00:35:30
Pero por ahora no te interesa 00:35:32
Y escribes tu if allí dentro 00:35:34
Y esto es 00:35:36
La primera sentencia condicional 00:35:39
Que vamos a ver 00:35:43
Es un if 00:35:44
Si la condición es verdadera 00:35:45
Hace el primer bloque 00:35:48
Si no es verdadera 00:35:49
Hace el segundo bloque 00:35:50
Y luego sigas adelante 00:35:51
¿Dudas? 00:35:53
¿Qué puedo poner como condición? 00:35:58
No os lo digo 00:36:10
Buleano, ¿buleano qué? 00:36:11
Me falta una palabra antes de bulear 00:36:16
Exacto, una expresión buleana 00:36:18
¿Vale? 00:36:30
Es decir, todo lo que nosotros hemos visto 00:36:32
dentro del operador ternario, es decir, operadores de comparación, and, or, not, whatever, ¿vale? 00:36:34
Todas esas cosas de allí, puede ser una condición compleja cuanto os da la gana, 00:36:42
y grande cuanto os da la gana, que al final me dará un true o un false. 00:36:46
Entonces, efectivamente, allí dentro va un boolean, ¿sí? 00:36:52
Pero un boolean no es un poco limitante, es una expresión booleana, 00:36:55
una expresión compleja cuanto te da la gana, que cuando yo la resuelvo, 00:36:58
Me dará un valor de true o false 00:37:03
Si es true, hago esto 00:37:06
Si es false, hago esto 00:37:07
¿Dudas? 00:37:09
Se ha entendido muy bien el if 00:37:13
Ahora practicamos 00:37:15
Antes de ir a practicar con el if 00:37:17
Veamos la otra sentencia 00:37:26
Condicional que vamos a ver 00:37:29
Que es el switch 00:37:31
O switch case 00:37:32
Esta también es condicional 00:37:33
Porque dependiendo del valor de una cierta variable 00:37:36
Hago una cosa o hago otra 00:37:40
¿Vale? 00:37:43
O hago varias cosas 00:37:43
Ahora lo veremos 00:37:45
¿Vale? 00:37:46
Se puede hacer lo mismo que hace el switch 00:37:47
Con una serie de if 00:37:50
Uno dentro de otro, dentro de otro, dentro de otro, dentro de otro 00:37:51
¿Vale? 00:37:55
Imaginaos un menú textual 00:37:57
Algo que dice 00:38:00
Bienvenido a mi programa 00:38:02
Si quieres añadir un alumno 00:38:04
Pulse 1 si quieres borrar un alumno 00:38:06
Pulse 2 si quieres 00:38:09
Borrar todos los alumnos 00:38:10
Pulse 3 si quieres 00:38:13
Añadir una clase 00:38:15
Pulse 4 00:38:16
¿Cómo haría yo eso con if? 00:38:17
Sería varios if de 00:38:21
Si la variable que has leído 00:38:23
Es 1, entonces haz todo lo que sea al 1 00:38:25
Si no 00:38:28
Si la variable es 2 00:38:29
Haz todo lo que haría al 2 00:38:32
Si no 00:38:33
Si la variable es 3 00:38:34
¿Se entiende? 00:38:35
O sea que serían varios if uno dentro de otro 00:38:38
Dentro de otro, dentro de otro 00:38:40
Si yo tengo 25 opciones 00:38:41
Sería un problema 00:38:44
Y entonces en casos como estos 00:38:45
Donde yo tengo una variable 00:38:48
Y puede valer varias cosas 00:38:50
Y yo quiero hacer acciones distintas 00:38:53
Dependiendo de 00:38:55
Una cosa u otra 00:38:56
Uso el switch case 00:38:58
El switch case funciona así 00:39:00
Switch 00:39:02
Y aquí le pongo una variable 00:39:04
X, nombre, edad, lo que sea 00:39:06
¿Vale? 00:39:09
Funciona con tipos primitivos 00:39:10
¿Sí? 00:39:12
Y un bloque 00:39:14
¿Sí? 00:39:17
A partir de este bloque digo 00:39:20
¿Qué es valor 1? 00:39:21
Si esto vale 1, por ejemplo 00:39:24
¿Qué es 1? 00:39:27
O si esto es la letra A 00:39:28
¿Qué es A? 00:39:29
Entre ápices 00:39:30
O si esto... 00:39:31
No sé 00:39:34
Es un número, normalmente el número si char es suficiente, ¿vale? 00:39:34
Entonces, haz esta cosa aquí. 00:39:40
Si en vez es el caso que vale 2, haz esta cosa aquí. 00:39:45
Si es el caso que vale n, haz esta cosa aquí. 00:39:52
¿Sí? Es una situación como esta aquí. 00:39:56
Y aquí me pregunta, la variable que veo está aquí. 00:39:59
Vale 1, si es verdadero ejecuta esto. 00:40:02
La variable vale, si no es verdadero 00:40:06
Va a preguntar, vale 2 00:40:09
Vale el segundo valor que he puesto aquí 00:40:11
La B 00:40:13
O 2, o 37 00:40:14
O lo que sea, se entiende 00:40:17
Más o menos 00:40:19
Ahora, ¿qué es este break? 00:40:20
Este break 00:40:24
Me dice que si llega a un break 00:40:25
Dejo de ejecutar 00:40:27
Todo el resto de lo que viene debajo 00:40:29
Y me voy 00:40:31
Fuera del switch 00:40:33
Y sigue adelante 00:40:34
Break rompe este switch 00:40:36
Entro un break 00:40:39
Sigue adelante 00:40:41
Y si no pongo el break 00:40:42
Eso quiere decir que cuando 00:40:43
Por ejemplo, quitando el primer break 00:40:46
Si case vale el valor 1 00:40:48
Que por ejemplo es 1 00:40:51
Vale, ok, perfecto, es este de aquí 00:40:52
Ejecuto esta sentencia 00:40:54
Y también esta 00:40:56
Ejecuto no solo el caso 1 00:40:57
Sino todos los casos 00:41:01
A partir del que es verdadero 00:41:03
Para abajo 00:41:05
Hasta que encuentre un break 00:41:06
O hasta que se acabe 00:41:08
En determinados casos 00:41:10
Puede que esto me sirva 00:41:14
Si yo quiero que estos sean 00:41:15
Independientes uno de otro 00:41:18
Por cada uno de estos bloques 00:41:20
Pongo un break 00:41:22
Hace esto y luego ya está, se acabó 00:41:23
No hagas lo que habrías hecho 00:41:26
Si valías otro valor 00:41:28
Existe también 00:41:29
Una opción final 00:41:36
Que se pone al final 00:41:37
Que es la opción default 00:41:38
Esta es como un else 00:41:40
¿Vale? Es decir, tú compruebas 00:41:43
Si esta variable vale esto 00:41:45
O si vale esto, o si vale esto 00:41:47
Si no vale ninguno de estos 00:41:49
De aquí, pues entonces por defecto 00:41:51
Hace esta cosa aquí 00:41:53
¿Ve? 00:41:55
Que sería esto 00:41:58
Si encuentro el valor, intento hacerlos todos 00:42:00
Mas si encuentro un break, salgo 00:42:02
¿Ve? 00:42:04
Si no hubiese break, pues las haría todos 00:42:05
Si no encuentro ninguno 00:42:08
Son todos falsos, pues siempre 00:42:10
Hace esta cosa de aquí y luego sigue adelante 00:42:12
¿Lo veis? 00:42:14
Si no pongo el default 00:42:18
Cuando 00:42:20
Si son todas falsas, no hago nada 00:42:22
Y sigo adelante 00:42:24
Y aquí es de donde estos break 00:42:24
Llegan aquí 00:42:28
Y sigo adelante 00:42:28
Si en vez 00:42:30
He puesto el default 00:42:32
Si son todas falsas 00:42:35
Al final hago esto y sigo adelante 00:42:36
¿Sí? 00:42:38
Y si no he usado ningún break 00:42:40
Pues haría todos los verdes 00:42:42
Incluido este de aquí y sigo adelante 00:42:43
¿Sí? 00:42:45
Este es un ejemplo 00:42:49
Real 00:42:50
No se lee 00:42:51
Tengo una variable nota 00:42:52
Hago switch nota 00:43:01
¿Vale? 00:43:04
Entonces compruebo nota 00:43:05
¿Qué es 5? 00:43:06
O sea, si nota vale 5 00:43:08
Escribe aprobado 00:43:10
Break 00:43:11
Si es 6 00:43:13
Escribe bien 00:43:16
Si es 7 00:43:17
O si es 8 00:43:20
Porque aquí no he puesto break 00:43:22
Entonces, tanto si entraron en el 7 00:43:24
Como si entraron en el 8 00:43:26
Ejecutaría esto, que es notable 00:43:27
¿Sí? 00:43:30
Si es 9, sobresaliente 00:43:32
Si es 10, matrícula de honor 00:43:34
de honor y en 00:43:36
método default 00:43:38
pues suspenso, vale 00:43:40
como he puesto break aquí, pues esto me lo 00:43:42
escribe solo si es menos que 5 00:43:44
si es distinta de 00:43:46
los valores que he puesto aquí 00:43:48
no, aquí 00:43:49
lo está haciendo él, está haciendo un 00:43:55
igual igual 00:43:58
está haciendo un igual igual entre esto 00:43:58
y esto, pero porque el switch 00:44:02
se utiliza en casos de 00:44:04
en estos casos, no cuando tengo una variable 00:44:06
con una expresión compleja y quiero saber si sí o si no, sino que 00:44:10
tengo una variable que puede tener varios valores 00:44:14
y quiero hacer cosas distintas en base a este valor. El ejemplo 00:44:18
típico es un menú. Yo me hago una cosa así 00:44:22
con menú, si has pulsado 1, entonces llama el método 00:44:26
ejecuta1, si es 2, llama el método ejecuta2, o haz lo que debería 00:44:30
peden dos. Si esto no estuviera, él escribiría aprobado, luego bien y 00:44:34
seguiría hasta encontrar un break. Cuando encuentre un break, se va. 00:44:49
Si ha quitado este break de aquí y este lo ha dejado, se pararía aquí y 00:44:54
seguiría adelante, seguiría aquí, lo que hay aquí abajo, es como aquí, veis, como no he puesto un break aquí, que yo te de 7 o te de 8, lo que hará es empezar a ejecutar todo hasta encontrar un break, entonces tanto con 7 como con 8, me va a escribir notado, 00:45:00
Sí, el default siempre va al final 00:45:24
Es como el else 00:45:30
Tú pruebas todas estas cosas 00:45:32
Y en caso por defecto 00:45:34
De que esta cosa no está bien valida 00:45:35
Pues vas a hacer esto 00:45:37
Cerrarlo 00:45:37
No necesariamente 00:45:43
Porque como es la última cosa 00:45:46
Aunque hasta si no se pone break 00:45:48
Pues seguirá adelante y acaba 00:45:50
Si lo has puesto último 00:45:51
¿Más? 00:45:53
Acordaos con esto de break 00:45:56
Porque si se os olvida 00:46:00
Cuando entra en uno hace todo 00:46:01
Entonces a lo mejor no es lo que queréis 00:46:03
Si yo me hubiese olvidado 00:46:05
De poner los break 00:46:08
Al entrar por ejemplo aquí me habría puesto 00:46:09
Bien, notable, sobresaliente, antiguo honor, suspenso 00:46:11
Y esto es 00:46:14
Nosotros lo usaremos principalmente con enteros 00:46:25
O con 00:46:28
chara, chara, chara 00:46:29
¿vale? ya, ya, string 00:46:32
sufre 00:46:34
¿vale? casi, no lo sé 00:46:36
no lo he probado nunca, porque luego después 00:46:38
switch case se usa ahora 00:46:40
luego después se pierde un poco de 00:46:42
¿vale? pero 00:46:44
los string debería 00:46:46
comprobarlo, pero me da miedo 00:46:50
con los string 00:46:52
con doble anos tiene 00:46:53
poco sentido 00:46:56
Con decimales 00:46:57
También, tú puedes poner 00:46:59
Si es 7,5 00:47:01
Hace esto, si es 7,4 00:47:03
Pero como es un valor concreto 00:47:04
Exacto 00:47:06
Los enteros para valores 00:47:08
Exactos 00:47:10
Si tú has creado 00:47:11
Fuera del switch una variable 00:47:28
En todo el switch la puedes ver 00:47:29
Si tú has creado una variable 00:47:31
Dentro del switch, fuera del switch 00:47:34
No la puedes ver 00:47:36
Si tú al case 5 00:47:37
Has creado un bloque 00:47:39
Que se cierra aquí 00:47:41
¿Vale? 00:47:43
Y aquí dentro creas una variable 00:47:44
Esta no se ve en los otros bloques 00:47:46
Sería switch 00:47:49
Inicial 00:47:59
Case 00:48:01
Apóstrofe a apóstrofe 00:48:02
Haz algo 00:48:05
Case apóstrofe b a apóstrofe 00:48:05
Haz algo 00:48:08
Ten en cuenta que son mayúsculas y minúsculas 00:48:09
Asumamos que no 00:48:11
Si yo por ejemplo quisiera hacerlo 00:48:18
Case not case sensitive 00:48:21
Es decir, que me da igual mayúscula o minúscula 00:48:23
Lo podría hacer así 00:48:25
Case a mayúscula, case a minúscula 00:48:26
Haz lo mismo 00:48:29
Si quieres leer, si 00:48:31
Si no quieres leer, no 00:48:36
Si yo hago char 00:48:38
Iniciales igual a 00:48:42
Es que 00:48:44
Es otro tipo de problema 00:48:47
Está claro que si tú quieres hacer algo 00:48:50
Que funciona y que es el usuario 00:48:52
Que se vente allí a trabajar 00:48:54
Pues posiblemente tienes que dialogar con el usuario 00:48:55
¿Vale? Pero 00:48:57
Es independiente del switch 00:48:58
El switch funciona tanto con escáner como sin escáner 00:49:00
Tú me preguntas 00:49:03
¿Es indispensable usar escáner para hacer esto? 00:49:04
Pues no 00:49:07
Podría ser que esta nota 00:49:07
Sea leída como posición 00:49:10
en una string. Yo voy a hacer el charat 37, que es un simbolito y ese simbolito luego lo miro, ¿sabes? 00:49:13
Haremos ejemplo. No sé si hay algo más. Ejercicio 3.1, ¿sabes? Entonces aquí nos paramos, hemos 00:49:22
Autor/es:
Stefano Chiesa
Subido por:
Stefano C.
Licencia:
Reconocimiento
Visualizaciones:
15
Fecha:
9 de octubre de 2023 - 13:13
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
49′ 33″
Relación de aspecto:
4:3 Hasta 2009 fue el estándar utilizado en la televisión PAL; muchas pantallas de ordenador y televisores usan este estándar, erróneamente llamado cuadrado, cuando en la realidad es rectangular o wide.
Resolución:
960x720 píxeles
Tamaño:
122.84 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid