Saltar navegación

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

Clase 6-10-23 - 1 - 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 6 de octubre de 2023 por Raquel G.

12 visualizaciones

Más información Transcripción

Descargar la transcripción

Bueno, pues de cara simplemente a mencionarlo, para que no nos vayamos de aquí sin saber lo que es. 00:00:01
Los operadores para construir expresiones. 00:00:11
Ya el otro día hicimos un repaso más o menos de todos los aritméticos que involucran números y nos dan números. 00:00:13
Había pequeños, matices 00:00:25
Y el de división en particular 00:00:28
Pues que funcionaba de dos maneras diferentes 00:00:30
Si divide enteros o si divide decimales 00:00:31
Pero bueno, son los que más fáciles nos resultan 00:00:33
Porque sumar, restar, multiplicar, dividir 00:00:36
Y hacer el resto o el módulo lo hemos hecho toda la vida 00:00:38
Pues es lo mismo pero plantado aquí 00:00:40
Ya está, eso en cuanto a los aritméticos 00:00:42
Los relacionales 00:00:44
Los relacionales mezclan 00:00:46
Números o cosas ordenadas 00:00:48
Cosas ordenadas 00:00:50
Que hasta ahora para nosotros son números solo 00:00:51
porque no hemos visto más tipos de datos, pues mezclan números o cosas ordenadas y nos dan booleanos o condiciones, 00:00:54
el menor que, mayor que, eso también nos es fácil usarlos porque los hemos usado toda la vida, 00:01:03
el menor que, mayor que, menor, igual y distinto nos es fácil, pues es lo mismo plantarlo pero aquí, 00:01:07
mezcla números para obtener condiciones y luego ya los operadores lógicos o booleanos 00:01:13
que a lo mejor son los que menos familias nos resultan 00:01:19
porque si no hemos estudiado en matemáticas 00:01:24
pues álgebra de bulo, lógica 00:01:27
pues a lo mejor no estamos acostumbrados al AND y al OR 00:01:29
muchos a lo mejor si lo estáis 00:01:33
porque habéis estudiado lógica en matemáticas 00:01:35
pero el que no lo haya estudiado no se acuerde 00:01:37
te ha dado un sofoco, ¿a que sí? 00:01:40
te ha dado un sofoco 00:01:43
pues el que no haya estudiado lógica 00:01:44
el AND, el OR y el NOT 00:01:49
a lo mejor le suena menos 00:01:50
pero ahora es el momento de que entendamos 00:01:52
de que esos operadores lógicos 00:01:54
el AND, el OR y el NOT 00:01:56
lo que hacen es combinar condiciones 00:01:58
cosas que a la vez 00:02:01
que a su vez son verdad o mentira 00:02:02
para obtener una condición más grande 00:02:04
el AND ya sabemos lo que combina 00:02:06
dos condiciones 00:02:09
las combina con el AND 00:02:10
si ambas son ciertas 00:02:11
la total es cierta 00:02:13
y solo con que alguna de las dos sea falsa 00:02:15
pues entonces la total es falsa 00:02:17
y el OR combina dos condiciones 00:02:18
para dar una condición más compleja 00:02:21
y la condición compleja 00:02:23
será verdadera 00:02:25
solo con que una de las dos lo sea 00:02:26
me da igual cual o las dos 00:02:28
bueno, pues eso es lo que 00:02:30
vimos el otro día 00:02:33
y luego ya, según uno ya va formando expresiones 00:02:34
para hacer programas, pues ya se va familiarizando 00:02:37
con ello 00:02:39
y nos dejamos en el tintero 00:02:40
los operadores que trabajan a nivel de bits 00:02:42
que tiene una utilidad 00:02:45
bueno, relativa 00:02:48
pero a veces pueden ser prácticos 00:02:50
¿vale? vamos a revisarlos 00:02:52
muy rápidamente aquí en la pizarra 00:02:54
y no es que nos olvidemos de ellos 00:02:55
pero es raro que nos surjan algún ejercicio 00:02:57
es raro 00:03:00
¿vale? 00:03:00
vale, como va a ser muy rápido 00:03:13
ni voy a borrar el proyector 00:03:14
para no cargármelo 00:03:16
de tanto encender y 00:03:17
apagar y ya está 00:03:19
uy, os he sacado 00:03:21
me podríais denunciar, pero no me habéis dado 00:03:28
ah, si me disteis la autorización, ah no, me dijisteis 00:03:30
que nos importaba la voz 00:03:32
pero la imagen no, ¿quién no me la ha dado? 00:03:33
de palabra sí lo pregunté 00:03:36
me dijisteis todo, no ha pasado nada, así que sí 00:03:38
bueno, pues 00:03:40
ahí se queda 00:03:47
¿quién quiere salir? 00:03:53
Bueno, pues muy rapidito 00:04:01
Entonces, vosotros 00:04:08
Os tenéis que quedar en la cabeza 00:04:09
Todas estas cosas que os digo tienen que estar en la cabeza 00:04:11
Que existen operadores a nivel de bits 00:04:13
Que tienen ese aspecto 00:04:15
Y si alguna vez 00:04:17
De repente tenéis que hacer operaciones a nivel de bits 00:04:18
Sabemos a qué me refiero con eso 00:04:21
Pues decir, ah, vale, tengo estos operadores 00:04:22
Igual simplifico mi programa si los uso 00:04:23
Voy a ver cómo funcionaba 00:04:26
Eso es lo que tenéis que dejaros aquí registrado. 00:04:28
Vale, pues esos operadores son los que, si yo tengo una variable, por ejemplo, una variable entera, 00:04:32
tengo una variable, esa variable entera, en este caso por ser int, ya sabemos que está formada por 32 bits, los que sean. 00:04:46
¿Vale? Bueno, 32 bits, los que sean. 00:04:54
Bueno, todos los operadores que hemos visto trabajan con esta variable en su conjunto, si es un número y representa el 27, pues trabaja con el 27, para sumarlo, para restarlo, lo que sea, pues los operadores a nivel de bit son capaces de trabajar con cada bit por separado, simplemente. 00:05:01
¿Para qué puede ser interesante eso? 00:05:19
Pues a lo mejor para aplicaciones en las cuales a mí me interesa registrar información binaria del tipo 00:05:21
tengo un conjunto de sensores y quiero registrar qué sensor está activo, 00:05:27
este está activo, este no, este está activo, este no. 00:05:32
Entonces dedicar una variable con un montón de bits para indicar si un sensor está activo o no, 00:05:34
a lo mejor es un desperdicio, podemos dedicar una única variable 00:05:39
y cada bit tiene su significado por separado. 00:05:42
Cada bit tiene su significado por separado. 00:05:46
Este asociado al primer sensor, este al segundo 00:05:47
Entonces, en algún tipo de aplicaciones 00:05:50
Podría tener su interés 00:05:52
Pero las aplicaciones industriales 00:05:53
En realidad se harían con otro software 00:05:56
No se harían con este 00:05:58
Entonces, por eso lo mencionamos por encima 00:05:59
Pero, ¿cuáles son? 00:06:01
Pues ahí estaban escritos en el 00:06:03
Documento 00:06:05
Estos 00:06:08
Desplazamiento izquierda-derecha 00:06:11
Y derecha sin signo 00:06:14
Y luego esto es de aquí y listo. 00:06:17
Y nos quedamos tan tranquilos. 00:06:19
Vale. 00:06:24
Este. 00:06:26
Este lo usaríamos de esta manera. 00:06:28
Desplazamiento a la izquierda y aquí una cantidad. 00:06:32
3, por ejemplo. 00:06:35
Pues esta es una expresión que uno asigna a otra variable, como siempre. 00:06:36
¿Vale? 00:06:42
Es un operador, con lo cual este operador sirve para formar una expresión con él. 00:06:43
Por ejemplo, esto. 00:06:47
Y el resultado se lo asignamos a algún lado 00:06:48
Los resultados de las expresiones van a alguna parte 00:06:51
Suponer que a esa variable, me da igual 00:06:54
Bueno, pues esta expresión lo que significa 00:06:56
Cogemos esta variable 00:06:58
Y desplazamos a la izquierda sus bits 00:06:59
Tantas posiciones como me diga este 00:07:03
Es decir, si n fuera esa variable 00:07:05
Se caerían estos tres, se caerían 00:07:08
Y por aquí entrarían ceros 00:07:11
¿Vale? 00:07:14
Se hace un desplazamiento 00:07:16
entonces, para eso sirve 00:07:18
se hace el desplazamiento a la izquierda 00:07:21
de tantos bits cayéndose los de aquí 00:07:23
y aquí rellándose con 0 00:07:25
y esa nueva variable que obtenemos 00:07:26
pues se asigna donde yo quiera 00:07:28
vale 00:07:30
puede tener 00:07:32
esta operación en realidad 00:07:34
es una forma rápida 00:07:37
de hacer 00:07:39
multiplicaciones por potencias 00:07:41
de 2, ¿verdad? 00:07:43
porque cada vez que hacemos un desplazamiento a la izquierda 00:07:44
estamos multiplicando por 2 00:07:47
en binario 00:07:48
uno tiene este número 00:07:50
este número es el 1 00:07:52
si desplazamos a la izquierda se convierte en este 00:07:53
2, si lo desplazamos a la izquierda otra vez 00:07:56
se convierte en este 00:07:58
4, si lo desplazamos a la izquierda otra vez 00:07:59
se convierte en este, 8 00:08:03
entonces en realidad cada desplazamiento 00:08:04
a la izquierda es como multiplicar por 2 00:08:06
entonces esto sería igual a 00:08:08
multiplicar por 2 elevado a 3 00:08:10
es una forma rápida de hacer 00:08:13
multiplicaciones por potencias exactas de 2 00:08:14
No va a ser habitual que lo veáis 00:08:16
¿Quién me ha hablado? 00:08:21
¿A eso? 00:08:26
Sí, pero está explicado en el documento de habla virtual 00:08:28
Está ahí, está explicado el significado de eso 00:08:30
¿Vale? Entonces 00:08:36
Este es lo mismo 00:08:38
Desplazamiento a la derecha 00:08:41
Si lo cambiamos aquí 00:08:43
Pues lo mismo 00:08:44
Pero van a la derecha 00:08:50
Se caen estos, se caen estos 00:08:52
¿Y por aquí qué entra? 00:08:55
Pues por aquí entra depende de lo que valga el bit de signo 00:08:57
No sé si en sistemas informáticos 00:09:00
Habéis visto ya si la codificación complemento a 2, complemento a 1 00:09:03
Pues ya sabéis que este bit es el bit de signo 00:09:07
Que es 1 si es negativo 00:09:09
Entonces, si este es un 1 00:09:11
Lo que se mete por la izquierda son unos 00:09:13
Y eso se hace así para conservar el signo 00:09:16
Del numerito resultante, para conservarlo 00:09:19
Si esto fuera un cero, lo que se mete por aquí son ceros 00:09:21
Simplemente, y lo que salga por aquí se cae 00:09:24
Entonces, el desplazamiento a la derecha 00:09:26
En realidad es como si dividiéramos 00:09:29
Ahora, en potencias hasta el de dos 00:09:32
Es lo mismo, ¿no? 00:09:34
Si yo desplazo a la derecha 00:09:35
Voy dividiendo entre dos 00:09:37
Cada vez que desplazo uno, va, divide entre dos 00:09:39
Bueno, pues esos son los desplazamientos 00:09:41
Luego hay un desplazamiento a la derecha 00:09:44
Que es este 00:09:46
Que es, con tres cositas 00:09:46
Que es sin signo 00:09:49
que es cuando estamos usando la variable 00:09:50
no como si fuera un número 00:09:53
sino a lo mejor la interpretación que os he dicho antes 00:09:54
que cada bit significa una cosa 00:09:56
entonces es desplazamiento a la derecha también del 3 00:09:57
pero aquí se mete ceros 00:10:00
independientemente de lo que valga el bit S 00:10:03
independiente de lo que valga 00:10:05
se meten ceros 00:10:06
entonces podría interesar 00:10:07
si esto no representa un número 00:10:10
sino que representa el estado de sensores 00:10:12
por ejemplo, pues yo quiero meter aquí ceros siempre 00:10:14
no 1 00:10:16
pues es la diferencia entre este y este 00:10:17
lo que se mete por la izquierda 00:10:19
¿vale? 00:10:22
bueno, esos son los operadores de desplazamiento de bits 00:10:23
que nos permiten mover bits 00:10:25
entonces, esos, nosotros no 00:10:27
claro, pero 00:10:29
Java, la librería de Java 00:10:31
que acompaña y que hace cosas y nosotros saberlo 00:10:33
o sea, cada vez que llamamos 00:10:35
un system.app.println, cada vez que llamamos 00:10:37
ahora mismo estamos llamando a pocas 00:10:39
sentencias ya hechas, pero cada vez que 00:10:41
llamamos a un montón de sentencias de Java 00:10:43
la máquina virtual necesita 00:10:44
llamar a programas 00:10:47
que ya están hechos, que están 00:10:49
en la JRE. Pues 00:10:51
esos programas sí que usan 00:10:53
esto, porque para construir sus variables 00:10:55
pues va llevando los bits de un lado a otro. 00:10:57
Entonces, claro que los usa, 00:11:00
pero esto se usa a muy bajo nivel. 00:11:01
Entonces nosotros 00:11:03
tan a bajo nivel no llegamos. Nosotros 00:11:04
nos interesa el numerito entero, normalmente. 00:11:07
¿Vale? Pero esto 00:11:10
sí que lo usa. 00:11:11
Las clases de Java de las que tiramos nosotros 00:11:13
lo tenemos más adelante, así que lo usan 00:11:15
porque ya sí que trabajan a bajo nivel 00:11:18
vamos a ver los datos 00:11:19
vale, esto en cuanto a los operadores de desplazamiento 00:11:20
que lo dejamos aquí 00:11:24
y luego están 00:11:26
los que no lo veis 00:11:28
pero los 00:11:30
los operadores 00:11:31
comparación de bits 00:11:35
estos 00:11:38
los escribo aquí y ahora 00:11:41
a ver 00:11:43
Este, este 00:11:45
Y este, este 00:11:51
¿Vale? Estos cuatro operadores 00:11:55
Vale 00:12:00
Estos se parecen 00:12:09
Bueno, más que se parecen 00:12:13
Este y este es que son el mismo 00:12:14
De hecho, a los operadores lógicos 00:12:17
Que habíamos ya visto el otro día 00:12:19
¿Verdad? El otro día ya habíamos visto 00:12:21
Que si yo tengo una condición 00:12:23
Esta, por ejemplo 00:12:24
La condición C1 00:12:26
Que tiene el valor que tenga 00:12:28
tengo otra condición 00:12:30
la condición c2 00:12:34
que tiene el valor que tenga 00:12:36
ahora yo puedo hacer por ejemplo 00:12:37
c1 igual a c1 00:12:40
a c2 00:12:43
esto es perfectamente válido 00:12:45
¿verdad? 00:12:47
este operador lógico 00:12:48
es el AND de dos cosas lógicas 00:12:50
de dos condiciones 00:12:53
si esta es verdad y esta es verdad 00:12:53
el resultado final es verdad 00:12:56
y ese true va ahí 00:12:57
Ese es el uso que habíamos visto 00:12:58
Bueno, pero es que este operador 00:13:01
También funciona 00:13:03
También lo puedo poner yo combinando números 00:13:05
Es decir, esto también sería válido 00:13:07
N1 lo que sea 00:13:10
Igual a 7 00:13:12
N2 igual a 5, por ejemplo 00:13:12
Y ahora yo hago esto 00:13:15
N1 igual a 00:13:17
And 00:13:22
N1, por ejemplo 00:13:23
Con lo que sabemos hasta ahora diríamos 00:13:26
A ver, este es un operador lógico 00:13:29
Que hace el AND lógico 00:13:31
Entre dos cosas que son condiciones 00:13:33
Como aquí 00:13:35
Pero esto no son condiciones, son números 00:13:36
¿Cómo es que puedo poner este operador? 00:13:39
Vale, pues es que este operador tiene otra interpretación 00:13:42
Funciona de otra manera 00:13:45
Cuando combina números 00:13:47
Cuando combina números 00:13:49
Funciona de otra manera 00:13:51
Cuando combina condiciones 00:13:52
Funciona tal y como hemos visto el otro día 00:13:54
Pero cuando combina números 00:13:57
Funciona de otra manera 00:13:59
¿Y cómo funciona? 00:14:01
Bueno, pues 00:14:04
Si aquí tuviéramos N1, por ejemplo 00:14:06
Con sus bits 00:14:08
Y aquí tuviéramos 00:14:10
Este es N1 00:14:14
Y este es N2 00:14:17
Por ejemplo, ese es N1 y ese es N2 00:14:21
vale, pues que hace el AND este 00:14:36
opera a nivel de bits 00:14:39
es un operador a nivel de bits, lo hemos dicho 00:14:41
y que es lo que hace, va bit por bit 00:14:42
haciendo una operación de AND 00:14:45
entre ceros y unos, como si el cero fuera 00:14:47
false y el uno fuera true 00:14:49
es lo que hace, entonces va uno por uno 00:14:51
cero y uno 00:14:54
cero y uno, el AND 00:14:55
vale, es cero 00:14:57
uno y cero 00:14:59
imaginaos que el uno es true 00:15:01
y el cero es false, pues uno y cero 00:15:03
es cero, uno y cero es cero 00:15:06
uno y uno, aquí tengo dos true 00:15:08
pues uno, y así va bit por bit 00:15:10
por separado, cero y cero, cero, uno y uno 00:15:12
uno, uno y uno, y uno 00:15:14
cero y cero, cero y uno 00:15:15
cero, cero, cero 00:15:18
cero y uno 00:15:20
eso es lo que hace 00:15:21
va bit por bit como si hiciera 00:15:23
un and donde el uno es true y el cero 00:15:26
es false 00:15:28
entonces esto en realidad se puede interpretar 00:15:28
como por ejemplo 00:15:35
apagar y encender. Es decir, si tú haces un AND con 0, por ejemplo, pues obviamente 00:15:36
estás poniéndolo todo a 0. Pero si quieres poner todos los sensores o lo que fuera a 00:15:44
0 menos el último, pues harías un AND con 1. Si haces un AND con 1, este lo dejas como 00:15:53
está y los demás los pones todos a 0. ¿Verdad? Si haces un AND con 1, estás haciendo 00:16:01
un AND con esto, con todo esto. Entonces, ¿eso qué significa? Que este sensor de aquí 00:16:06
se va a quedar con el estado que tuviera, si tenía un 0 se quedaba con 0, si tenía 00:16:19
un 1 se quedaba con 1 y los demás todos a 0. Más o menos se podría hacer la relativa 00:16:22
utilidad que pudiera tener este operador. Pero a vosotros lo que se os tiene que quedar 00:16:28
es que este operador AND funciona tanto para combinar condiciones de la manera que vimos 00:16:32
el otro día, como para combinar 00:16:40
números, en realidad. 00:16:42
Ese es el uso más extraño que vais a ver, pero sí que podéis 00:16:44
verlo. Y cuando combina 00:16:46
números, lo que hace es 00:16:48
va bit por bit 00:16:49
haciendo el AND 00:16:51
interpretando el 1 como true y el 0 como false. 00:16:53
Es como si hiciera una suma. 00:16:57
Como si hiciera una suma. 00:16:58
Porque 0 y 0 es 0, 0 y 1 es 1 00:17:00
y 1 y 1, pues, una suma binaria. 00:17:02
Y el OR 00:17:07
que es este, 00:17:08
el OR lo mismo 00:17:11
Pero 00:17:13
Haciendo un or 00:17:14
0 y 0 sería 0 00:17:16
1 y 0 sería 1 00:17:18
0 y 0 sería 0 00:17:19
1 y 0 sería 1 00:17:20
Lo mismo 00:17:22
A 1 por 1 00:17:23
¿Vale? 00:17:24
Y luego está el negado 00:17:32
Por ejemplo 00:17:34
Yo podría hacer n1 igual al negado de n2 00:17:35
De ese otro operador que está en la lista 00:17:38
El negado 00:17:40
El negado es cambio 00:17:41
Cojo n2 00:17:43
Y cambio los bits 00:17:44
El que tenga 0 se pone a 1 00:17:45
y el que tiene 1 se pone a 0 00:17:47
el resultado va a la variable que yo quiera 00:17:48
bueno, eso es un poco 00:17:50
por encima de estos operadores 00:17:55
que tenéis que registrar que hay operadores 00:17:57
que actúan a nivel de bits 00:18:00
porque en algunas aplicaciones 00:18:01
os podéis encontrar que están ahí 00:18:06
y luego ya 00:18:07
las peculiaridades de uso de cada uno 00:18:10
pues si lo necesitáis 00:18:12
ya podéis ir a ver, este es exactamente como funcionaba 00:18:13
pero os tenéis que tener identificados en la cabeza 00:18:15
y sobre todo lo que no tenéis es que volveros loco 00:18:17
que en un código veis un AND 00:18:19
que combina números, es decir, pero ¿cómo puede ser 00:18:22
si el AND es de condiciones? 00:18:24
Puede ser, entonces se interpreta 00:18:25
como hemos dicho. 00:18:27
¿Vale? Vale. 00:18:30
Pues, bueno, 00:18:33
pues entonces, para construir expresiones 00:18:47
ya sabemos 00:18:49
las herramientas que tenemos. 00:18:51
Porque tenemos las variables 00:18:53
de los tipos que hemos dicho 00:18:55
y los operadores. 00:18:56
Y podemos combinar variables 00:18:59
variables y operadores para construir expresiones. Ahora ya el problema real es, cuando yo tengo 00:19:01
una situación real, construir la expresión que la refleja. Ese es el problema, porque 00:19:08
eso ya se trata de que yo lo piense. Pero las herramientas que tenemos, que son los 00:19:14
operadores y las variables con los tipos que conocemos, ya los conocemos todos. Eso es 00:19:18
lo que tenemos para hacer expresiones. Ahora se trata de que nuestras expresiones reflejen 00:19:22
el problema que yo estoy resolviendo. Que lo reflejen bien y que no me equivoco yo poniendo 00:19:27
poniéndolas, que te da cuidado con 00:19:31
la precedencia de los operadores 00:19:33
que ponga paréntesis si hacen falta, etc. 00:19:35
Ahora se trata de eso. 00:19:37
¿Vale? 00:19:39
Bueno, pues entonces 00:19:40
cerramos ya esto 00:19:42
de los operadores 00:19:45
y ahora 00:19:51
siguiente 00:19:52
de todos los ejercicios que habéis 00:19:54
hecho, que en principio 00:19:57
serían estos primeritos que en el aula virtual 00:19:59
que los puse yo ahí para que practicarais 00:20:01
un poco 00:20:03
a ver, estoy aquí con los distintos tokens 00:20:03
que debería decir los distintos elementos 00:20:06
para que familiarizarais 00:20:08
pues esta línea hay que poner al principio 00:20:10
esta es la declaración de una variable 00:20:11
y este es su tipo de dato 00:20:13
vale, bueno, estos ejercicios 00:20:15
que los dejé ahí 00:20:19
para que practicarais a los que no hemos hecho referencia 00:20:21
estaban por un lado 00:20:23
y luego por otro lado estaba 00:20:24
estos del lunes 00:20:26
vale 00:20:29
bueno pues a ver 00:20:30
ahora es el momento de 00:20:32
que hagamos algunos, de que me digáis que dudas 00:20:34
habéis encontrado algún ejercicio 00:20:37
de que trabajemos sobre ellos 00:20:38
antes de empezar 00:20:41
ya el tema siguiente 00:20:42
entonces hay alguien que sienta que no lo tiene todo 00:20:44
absolutamente bajo control 00:20:48
todo el mundo lo tenéis todo bajo control 00:20:50
que suerte 00:20:54
o sea nadie tiene ninguna duda 00:20:55
¿todo el mundo ha hecho todos los ejercicios exactos bien? 00:20:58
¿nadie quiere que hagamos ninguno aquí? 00:21:00
vale, o sea, estos 00:21:08
a ver, el problema de estos últimos es 00:21:08
que efectivamente 00:21:11
ya hay que elaborar 00:21:13
condiciones y combinar 00:21:15
esas condiciones con operadores booleanos 00:21:17
y luego ya como 00:21:19
el código ya va a depender 00:21:20
va a hacer unas cosas u otras de esa condición 00:21:22
pues tengo que tener un operador alternativo 00:21:24
entonces ahí se hace un poquito más 00:21:25
dioso, vale, a ver 00:21:28
¿Cuál podemos hacer? 00:21:31
¿Cuál queréis que hagamos? 00:21:33
¿Cuál os ha dado más 00:21:35
Ansiedad? 00:21:37
Si es que alguno os ha dado ansiedad 00:21:38
¿Por qué estáis tan pasivos? 00:21:40
A ver, por ejemplo 00:21:52
El 20 00:21:53
¿Alguien tendría algún problema en hacer el 20? 00:21:54
A ver, vamos a ver 00:21:59
Vamos a hacer algunos sueltos 00:22:15
A modo de repaso 00:22:18
Y sobre todo con la intención de que 00:22:20
os despertéis 00:22:22
venga, vamos a poner aquí 00:22:24
a ver, que ya estoy liando 00:22:26
demasiado el proyecto 00:22:36
vale, venga, pues voy a hacer 00:22:37
otro proyecto diferente, este de primeras pruebas 00:22:42
es en el que he ido recogiendo todo lo que hemos probado 00:22:45
aquí en clase, que es el caso de una aula virtual 00:22:47
pues 00:22:49
voy a, ahora empezamos otro proyecto 00:22:50
donde vamos a meter los ejercicios varios 00:22:53
que a lo mejor revisemos ahora 00:22:55
y lo subo como proyecto separado 00:22:57
venga, pues este proyecto 00:22:59
se va a llamar 00:23:01
Ejercicios varios, tema 1 00:23:02
Ahora, ejercicios varios, tema 1 00:23:13
Venga, ya está 00:23:16
Vale, pues venga, por ejemplo 00:23:17
Hemos dicho, este de aquí 00:23:26
Voy a copiar esto 00:23:30
Y este es el 20 00:23:32
Espera 00:23:49
Ejercicio 20, lunes 00:23:55
vale, juicio 20 00:23:59
lunes, y vamos a poner aquí 00:24:02
venga 00:24:07
esto de aquí 00:24:14
mejor así porque no es jabalón 00:24:15
vale, pues venga 00:24:17
primero de siempre 00:24:30
uno lo ha denunciado, se asegura 00:24:32
de que entiende bien lo que tiene que hacer 00:24:33
y cuando lo tiene ya claro, porque está 00:24:35
bien especificado y no necesita más aclaraciones 00:24:37
ya se plantea como construirlo 00:24:39
Y de nuevo no se lo plantea en secuencia, al menos que sea muy sencillo, esta a lo mejor podría plantearse en secuencia, pero bueno. 00:24:42
Aquí, resultado del programa, resultado del programa, mostrar un mensaje, resultado del programa. 00:24:50
Decir si el estudiante aprobó al menos una de ellas o no aprobó al menos una de ellas. 00:25:02
Luego el resultado es uno de dos posibles mensajes, ¿verdad? El resultado este de aquí se mueve entre dos posibilidades, se mueve entre decir aprobó o no aprobó, ¿vale? 00:25:08
Entonces, pues esto es lo de siempre 00:25:31
Resultado va a ser una cosa u otra 00:25:33
Va a ser una cosa u otra 00:25:35
En función de una condición 00:25:38
Va a ser una cosa u otra en función de una condición 00:25:42
Y esa cosa u otra, ¿cuál va a ser? 00:25:44
Aprobó al menos una 00:25:47
No aprobó ninguna 00:25:50
No aprobó ninguna 00:25:54
¿Vale? Entre estas dos posibilidades se mueve 00:26:03
La condición cuál va a ser 00:26:09
Aprobar al menos una de dos notas 00:26:12
Que son los datos de entrada al programa 00:26:16
Luego el programa tiene datos de entrada 00:26:18
Bueno, pues vamos a leerlos 00:26:21
Vale 00:26:23
Vale, pues venga, los leemos 00:26:43
Introduzca nota primera 00:26:48
nota1 00:26:57
igual a scan.nextint 00:27:02
e introduzca 00:27:07
nota2 00:27:09
joder, esto no era 00:27:09
vale 00:27:13
introduzca 00:27:16
nota2 00:27:19
vale, datos de entrada 00:27:19
ya están, no hay más 00:27:22
datos de entrada, son estos dos 00:27:24
uno, una cosa que uno hace 00:27:26
a menudo y no hay que hacer 00:27:28
es inventarse información 00:27:29
uno tiene que tener muy claro su programa 00:27:31
qué información de partida tiene 00:27:33
y no inventarse la información adicional 00:27:36
este solo tiene como información 00:27:37
de partida dos notas 00:27:40
las pide y las lee 00:27:42
y ya no se puede inventar más información 00:27:44
entonces con esas dos notas 00:27:46
tiene que ser capaz de 00:27:48
construir el resultado 00:27:50
ya hemos dicho que el resultado es 00:27:51
o este string 00:27:54
o este string 00:27:56
vale, pero depende entonces de una condición 00:27:57
que yo tengo que ser capaz 00:28:00
de construir 00:28:02
con los datos que tengo 00:28:03
y los datos que tengo son nota 1 y nota 2 00:28:05
no tengo más datos 00:28:08
vale, pues esa condición 00:28:08
ahora es cuando la leemos despacio 00:28:11
y esa condición nos dice 00:28:13
la condición que yo tengo que elaborar 00:28:15
es una condición que tiene que ser verdad 00:28:17
si al menos una de las dos notas 00:28:19
es mayor o igual que 5 00:28:21
y falsa en caso contrario 00:28:23
pues ahora ya entendiendo ese enunciado 00:28:24
tenemos que trasladarlo a una expresión 00:28:27
que combine los datos de entrada y los operadores que conocemos. 00:28:30
Pues venga, ¿cómo expresamos en código la condición 00:28:34
al menos una de las dos notas es mayor o igual que 5? 00:28:37
¿Cómo lo escribiríais, Claudia? 00:28:43
Díctame la tal cual. 00:28:45
Lo que acabo de decir, que es, 00:28:48
díctame cómo escribo yo aquí la condición Java 00:28:50
que expresa esa idea, que al menos una de las dos es mayor o igual que 5. 00:28:54
Repite 00:29:00
Esta es la condición que expresa 00:29:08
Para ti que al menos una de las dos 00:29:18
Sea mayor o igual que 5 00:29:20
Claro, no es lo mismo I o O 00:29:21
No, no es lo mismo 00:29:26
¿Vale? 00:29:28
Entonces, aquí en esta condición 00:29:33
Parece más o menos claro 00:29:35
Pero muchas veces en otro tipo de condiciones 00:29:36
Más elaboradas 00:29:39
No es tan fácil distinguir 00:29:40
Si es un AND o un OR lo que nos interesa 00:29:42
Aquí sí, aquí de 00:29:44
Al menos una de las dos 00:29:46
Lo tenemos que traducir nosotros al idioma 00:29:48
O una o la otra 00:29:50
O una y la otra 00:29:53
Tenemos que traducirlo a ese idioma 00:29:55
A lo o a li 00:29:57
Aquí traducirlo a lo o a li es fácil 00:29:58
Si es al menos una de las dos 00:30:00
O la primera o la segunda 00:30:01
Pues traducirlo o la primera o la segunda 00:30:03
Es el or lógico y el operador 00:30:06
Or, lo booleano or 00:30:08
¿Vale? 00:30:09
Entonces, ¿puedo ponerlo así? 00:30:13
O puedo ponerlo así 00:30:16
¿Verdad? 00:30:17
¿cómo lo pondríais? 00:30:18
¿qué elegiríais? 00:30:21
¿ponerlo con uno o con dos? 00:30:23
¿con dos? 00:30:25
¿por qué elegirías con dos? 00:30:26
ya que estás lanza 00:30:28
dime 00:30:29
no, mala respuesta 00:30:30
o sea, si alguien ha elegido con dos 00:30:36
tendrá un criterio para elegir con dos 00:30:40
no pasa nada, que podéis contestar mal 00:30:42
o decirlo mal, pero mejor si estáis vivos 00:30:44
¿por qué podría tener sentido poner dos 00:30:47
en vez de uno? 00:30:50
Lo dijimos el día anterior. 00:30:53
¿Cómo es que no lo tenéis en la cabeza? 00:30:55
¿Que por qué? 00:30:59
A ver, el operador 00:31:01
os dijimos que yo lo podría escribir así. 00:31:03
¿Vale? ¿Y es válido? 00:31:05
O lo podría escribir así. 00:31:07
Y también es válido. Entonces, ya que hay dos alternativas, 00:31:08
primera pregunta, ¿cuál elegiríais? 00:31:11
Me habéis dicho que... 00:31:13
Con dos. 00:31:15
¿Perdón? 00:31:19
elegiríais esta, vale, y ahora la pregunta es 00:31:20
¿por qué? 00:31:23
a ver, en los dos 00:31:37
claro, los hay 00:31:40
o sea, no es que 00:31:42
hay casos en los cuales 00:31:43
procede 00:31:47
poner una de las versiones, otros casos en los cuales 00:31:49
procede poner la otra, pusimos un ejemplo 00:31:50
el otro día de un caso en el cual 00:31:53
había una diferencia muy grande entre poner la una y la otra 00:31:54
entonces, lo que está claro 00:31:57
lo que comparten las dos, lo que dijimos 00:31:59
el otro día es que el resultado 00:32:01
de la condición, final, resultado 00:32:03
de la condición, ponga yo 00:32:05
esto o no lo ponga 00:32:07
siempre va a ser la misma 00:32:08
siempre va a ser, en este caso, el or 00:32:11
o sea, me da igual poner una que dos 00:32:12
resultado va a valer 00:32:15
siempre igual, que será 00:32:17
true, si cualquiera 00:32:19
de las dos es true 00:32:21
o incluso las dos 00:32:22
o false, si lo son las dos 00:32:24
eso, ponga yo una o dos 00:32:27
eso va a ser así 00:32:29
Pero aparte pasaban cosas distintas 00:32:30
Aparte de la asignación sin más 00:32:33
Pasaban cosas distintas 00:32:36
Respecto a poner una o dos 00:32:37
Entonces, en esas cosas distintas que pasaban 00:32:38
Es donde está la explicación 00:32:41
De por qué me puede interesar ni poner uno solo o dos 00:32:43
En determinados casos 00:32:46
¿Me habéis dicho dos? 00:32:47
¿Alguien más me puede decir por qué podría tener sentido poner dos? 00:32:48
Ándate 00:32:54
Al revés 00:32:54
Vale, entonces 00:33:02
La historia va por ahí 00:33:04
Si ponemos solo uno, la máquina virtual evalúa las dos, una y la otra, evalúa las dos y ahora hace el oro, vale, está claro. 00:33:06
Si tiene los dos, va evaluando en secuencia, primero evalúa la primera, si con eso ya es capaz de hacer el resultado global, de la segunda pasa. 00:33:19
entonces 00:33:28
nos interesa más 2 00:33:29
porque si esta ya fuera true 00:33:32
si esta ya fuera true 00:33:34
puede ignorar esta 00:33:35
entonces es una evaluación menos que hay que hacer 00:33:37
más tiempo de procesamiento 00:33:40
ganado, o sea el programa más rápido 00:33:42
entonces por defecto 00:33:44
siempre poner 2 00:33:46
porque si yo aquí ya tengo 00:33:48
el resultado global 00:33:50
cuando esta sea true, solo lo voy a tener cuando esta sea true 00:33:51
claro, cuando esta sea false voy a necesitar evaluar esta 00:33:55
a ver si es true o false 00:33:57
pero en los casos, en las ejecuciones 00:33:58
en las ejecuciones en las que coincida 00:34:00
que nota uno es true 00:34:03
pues en esas ejecuciones voy a ir más rápido 00:34:04
porque de esta paso 00:34:06
entonces esa sería la explicación 00:34:07
de por qué poner dos en vez de una 00:34:11
si pongo una, aunque esta sea true 00:34:12
esta la voy a evaluar siempre 00:34:14
pues que pérdida de tiempo 00:34:16
¿vale? eso era 00:34:17
entonces, ahora cuando hacéis la pregunta 00:34:19
que también respondimos el otro día 00:34:22
pues entonces 00:34:23
¿por qué existen dos versiones? 00:34:25
¿por qué existen? 00:34:29
¿por qué existe esta versión? 00:34:30
¿tendría sentido? 00:34:32
hacerlo siempre en secuencia 00:34:35
y cuando ya tengo el resultado global 00:34:36
lo asigno y el resto deja de evaluarlo 00:34:38
¿por qué existe esta otra versión? 00:34:40
¿alguien le suele 00:34:45
recuerda del otro día? 00:34:46
os digo un ejemplo además 00:34:48
¿por qué tiene sentido que exista esta otra versión? 00:34:49
a ver, era porque hay veces 00:34:52
que una condición 00:34:58
además 00:35:00
hace cosas 00:35:01
¿no? ¿no recordáis lo de los 00:35:03
operadores incremento y todo eso? 00:35:06
yo aquí puedo añadir, en una expresión 00:35:08
siempre puedo añadir 00:35:10
si me da la gana, por ejemplo, un operador 00:35:12
incremento o decremento 00:35:14
puedo añadir esto 00:35:16
y estoy compactando 00:35:16
en esa expresión dos cosas 00:35:19
primera, la condición 00:35:21
y luego el incremento de este 00:35:23
lo estoy compactando en una 00:35:25
entonces, si yo le pongo dos 00:35:27
en las ejecuciones 00:35:30
en las cuales esto sea true 00:35:31
este incremento no se va a hacer 00:35:33
pero si yo le pongo uno 00:35:35
en todas las ejecuciones 00:35:37
independientemente de que esto sea true o false 00:35:39
esto se va a evaluar, con lo cual este incremento se va a hacer 00:35:41
entonces hay situaciones 00:35:43
en las cuales 00:35:45
el funcionamiento del programa es distinto 00:35:46
si yo pongo dos y una 00:35:49
y esa situación será cuando en las cláusulas 00:35:51
las condiciones pequeñitas que hay a continuación 00:35:54
además de la condición 00:35:56
se hagan cosas 00:35:58
además de la condición se hagan cosas 00:35:59
entonces ahí sí va a ser distinto 00:36:01
por ejemplo, ¿qué otra cosa podríamos hacer? 00:36:03
esto, que es una tontería 00:36:07
pero, a ver si 00:36:08
me deja 00:36:10
vale, esto 00:36:11
pero lo podríamos hacer 00:36:15
esto es una expresión 00:36:17
ya nos iremos familiarizando con ella 00:36:20
yo puedo, a la vez que uso 00:36:22
una variable, a la vez que la uso 00:36:25
en una expresión, a la vez que la uso 00:36:27
puedo de paso asignarle un valor 00:36:29
puedo hacer eso si me da la gana 00:36:31
a la vez que uso una variable 00:36:33
en una expresión, puedo asignarle 00:36:35
un valor, entonces 00:36:37
esto que me haría, esto me hace 00:36:39
nota 2 le asigna 7 00:36:40
y ahora ya hace la expresión 00:36:42
¿vale? en este caso es una tontería 00:36:45
¿no? porque esto va a ser siempre true 00:36:47
pero bueno, lo que me interesa a mí 00:36:49
indicar es que 00:36:50
incorporar que cuando en una 00:36:51
expresión usamos una variable, yo puedo además 00:36:54
en ese momento asignarle valor 00:36:56
por ejemplo aquí 00:36:58
asignarle un 7 sería una tontería 00:37:00
pero yo podría a lo mejor plantearme 00:37:02
leerla en ese momento y hacer eso 00:37:04
podría plantearme 00:37:06
hacer esto 00:37:11
y me ahorro el next in de arriba 00:37:12
es decir, la leo 00:37:15
en el mismo momento 00:37:17
que la leo, ya la evalúo 00:37:19
primero la leo y luego la evalúo 00:37:21
esto es válido 00:37:24
porque también es una asignación, en lugar del 7 00:37:25
le asigno esto 00:37:27
entonces, en resumen 00:37:29
una variable, en el momento 00:37:31
en el que la usamos en cualquier expresión 00:37:34
en la que sea, me da igual que sea una expresión 00:37:36
relacionar o la que sea, una variable 00:37:37
cuando yo la uso en una expresión 00:37:39
puedo de paso, si quiero, además asignarle valor 00:37:41
en esa expresión, puedo 00:37:44
aquí tenemos un ejemplo 00:37:45
¿vale? en la que 00:37:48
le asignamos un valor fruto de leer del teclado 00:37:49
y además ya la usamos en la expresión que sea 00:37:52
bueno, pues en este tipo de situaciones 00:37:54
aquí la diferencia obviamente es enorme 00:37:57
entre una barrita y dos 00:38:00
¿vale? si yo pongo dos barritas 00:38:02
esta lectura se va a hacer o no se va a hacer 00:38:06
en función de si esto es true o no es true 00:38:09
porque si pongo dos barritas 00:38:11
si esto es true, aquí no llego 00:38:13
pero si pongo solo una barrita 00:38:15
me da igual que esto sea truco falso 00:38:18
siempre voy a llegar aquí, siempre 00:38:20
en este caso 00:38:22
si yo estoy leyendo la nota 00:38:26
ahí, pondría una barrita 00:38:28
porque yo quiero leer las dos 00:38:30
entonces quiero que se ejecuten las dos condiciones 00:38:31
pero en el caso en el que yo estaba 00:38:34
que ya las tenía leídas y que yo no estoy 00:38:36
haciendo nada, nada más que evaluar la condición 00:38:38
en el caso en el que yo estaba 00:38:40
no, no, no, no, no, no 00:38:42
eso es otra cosa 00:38:51
si fuera aprobada las dos, tendría que ser un and 00:38:51
pero es otra cosa, no, no, no 00:38:53
están mezclando cosas 00:38:54
claro, pero 00:38:57
claro, entonces tienes que poner un and 00:39:02
pero es que eso es otro problema 00:39:04
ahora lo ponemos 00:39:05
en este caso, para expresar que al menos una de las dos 00:39:07
esté aprobada, tiene que ser uno 00:39:10
y una barra o dos 00:39:12
eso ya depende de si en alguna de las condiciones 00:39:14
haces algo 00:39:16
aparte de evaluar la condición 00:39:18
como asignar 00:39:20
como incrementar si haces algo 00:39:22
si no haces nada, que aquí no hacemos nada 00:39:24
solamente tenemos la condición 00:39:26
pues entonces dos barritas 00:39:27
¿vale? porque si esta ya es verdadera 00:39:29
no quieres entrar aquí 00:39:32
y si sí que haces algo 00:39:32
como asignar valor 00:39:35
entonces querrías entrar aquí también 00:39:36
porque además de la condición 00:39:40
además estás haciendo algo 00:39:41
entonces pondría solo una barrita 00:39:43
¿vale? 00:39:44
esa, vamos a 00:39:47
ponerlo aquí 00:39:49
Entonces el programa tal y sería este, hemos puesto el or doble barra porque aquí en esta condición no tenemos ninguna necesidad de entrar, si es falsa, perdón si es tú la primera y la dejaríamos así, esta versión ya estaría. 00:39:50
Vale, vamos a incorporar aquí, vamos a incorporar aquí, si ponemos el or como una, vamos a indicar aquí, solo evalúa, solo evalúa la segunda condición si es necesario, si es necesario. 00:40:06
En este caso será necesario 00:40:45
Si la primera es false 00:40:47
¿Vale? 00:40:51
Si la primera es false 00:40:58
Es cuando es necesario evaluar la segunda 00:40:59
Para ver como es la total 00:41:02
Pero si la primera es true no le hace falta 00:41:03
Vale, si ponemos 00:41:05
El or como una única barra 00:41:07
Como una única barra 00:41:10
Evalúa las dos 00:41:11
Entonces, por ejemplo, vamos a suponer que vamos a hacer 00:41:13
Vamos a hacer este programa con otra versión 00:41:20
Le decimos directamente 00:41:22
introduzca las dos notas 00:41:23
vamos a ponerle aquí 00:41:26
introduzca 00:41:27
las dos notas 00:41:32
por ejemplo, introduzca las dos notas 00:41:35
vale, y ahora 00:41:37
vamos a leer las notas 00:41:38
a la vez que hacemos la condición 00:41:41
vamos a hacer esto 00:41:43
vamos a hacer esto 00:41:44
voy a 00:41:51
cambiarlo para que 00:41:52
espérate 00:41:55
yo le doy a control c, vale 00:41:57
y ahora 00:41:59
voy a copiar aquí y lo voy 00:42:00
bajando para que 00:42:03
vale, pues entonces, introduzca 00:42:04
las dos notas, en la misma condición 00:42:11
en la misma condición 00:42:14
yo voy a asignarle valor a nota 1 00:42:15
leyéndola del teclado 00:42:17
del teclado, scan.nextint 00:42:18
así, y la otra 00:42:21
también, en la misma condición 00:42:25
a la vez 00:42:27
que la uso para la condición 00:42:30
a la vez que la uso 00:42:34
la leo, que lo puedo hacer perfectamente 00:42:35
¿vale? 00:42:38
o sea, a la vez 00:42:42
que uso la variable 00:42:44
para que forme parte 00:42:45
de la condición, a la vez le doy 00:42:48
un valor, le doy un valor y la uso 00:42:50
hemos dicho que es algo que podemos incorporar 00:42:52
el asignar valor 00:42:54
a una variable en el momento de usarla 00:42:56
en una expresión 00:42:58
¿vale? voy a ponerlo aquí 00:42:59
Podemos asignar 00:43:01
Valor a una variable 00:43:08
A la vez que la usamos 00:43:10
En una expresión 00:43:15
¿Qué es lo que estamos haciendo aquí? 00:43:17
A la vez que la usamos en la expresión 00:43:26
De ser mayor o igual que 5 00:43:28
Le damos valor 00:43:29
Aquí lo mismo 00:43:30
A la vez que la usamos en la expresión 00:43:32
De ser mayor o igual que 5 00:43:34
Le damos valor 00:43:36
Ese valor que le damos 00:43:37
Lo que pasa es que he leído del teclado 00:43:38
Pero me da igual, como si le diera yo 7 00:43:39
bueno, pues entonces 00:43:41
ahora ya esta versión del programa 00:43:44
si yo le pongo 00:43:47
doble barra 00:43:49
cuando la primera nota que meto 00:43:50
es aprobada, ya no me pide la segunda 00:43:52
pasa de la segunda completamente 00:43:55
entonces, hombre 00:43:56
si el programa continúa y yo necesito tener 00:43:58
las dos notas inicializadas, este programa no funcionaría 00:44:00
¿no? 00:44:03
por ejemplo, vamos a suponer 00:44:05
que además de mostrar el resultado 00:44:07
si es aprobó 00:44:09
Le vamos a poner antes que diga 00:44:11
Las notas que sacó son 00:44:13
Y luego nos diga, aprobó al menos una o no 00:44:15
Las notas son 00:44:18
Y le ponemos aquí 00:44:23
N1 más 00:44:26
N2, eh, nota 1, perdón 00:44:31
Nota 1 más 00:44:35
Nota 2, ¿vale? 00:44:39
Ahí 00:44:41
Vale, entonces este programa 00:44:45
Primero muestra las notas 00:44:47
Son, concatena con nota 1 00:44:49
Le da un string 00:44:51
Y ahora ya ese string lo vuelve a concatenar con nota 2 00:44:52
Vamos a poner un espacio entre medias 00:44:55
Para que 00:44:56
Ahora, las notas que sacó 00:44:59
Dirá, las notas son 00:45:03
Nota 1, lo concatenará con i 00:45:04
Y luego nota 2, vale 00:45:06
Y luego ya nos dirá si ha aprobado al menos una o no 00:45:08
Vale 00:45:11
Bueno, pues entonces 00:45:11
Ahora hacemos una versión del programa 00:45:15
Vamos a comentar esto 00:45:16
Vamos a comentar esto 00:45:19
Entonces 00:45:23
Este programita que hemos hecho 00:45:24
Vamos a probarlo 00:45:27
La versión donde hacemos, leemos antes 00:45:28
Y luego evaluamos 00:45:31
Venga, introduzca nota 1 00:45:33
Un 4, introduzca nota 2 00:45:38
Un 6, las notas son 4 y 6 00:45:40
Aproba al menos una, vale 00:45:42
Hombre, lo normal es que uno haga más casos de prueba 00:45:43
Por ejemplo, vamos a ponerle dos suspensos 00:45:46
No aprobó ninguna, vale 00:45:49
Vamos a ponerle dos aprobados 00:45:50
A ver si con dos aprobados también funciona bien el programa 00:45:52
Aprobó al menos una, vale 00:45:54
Bueno, después de una cantidad de pruebas 00:45:56
Esta versión que hemos hecho funciona 00:45:58
¿Vale? 00:46:00
Venga, vamos a comentar ahora esta versión 00:46:02
Y vamos a quedarnos con esta 00:46:05
¿Vale? 00:46:12
Nota 1, claro, tengo 00:46:21
La tengo que declarar arriba 00:46:23
Fuera del 00:46:26
Int nota 1 00:46:28
Y esto se queda aquí 00:46:31
Ahí 00:46:33
Nota 2 00:46:34
Y esto se queda así 00:46:37
Vale 00:46:38
Bueno, siguiente versión del programa 00:46:41
No os perdáis 00:46:44
Le decimos, introduzca las dos notas 00:46:45
Eso, silencio 00:46:48
introduzca las dos notas 00:46:51
y ahora ya 00:46:57
ponemos directamente la condición 00:46:58
pero aprovechamos en la condición 00:47:00
para de paso pedir la nota primero 00:47:02
la nota 1 00:47:04
o sea, se quedará esperando 00:47:06
la consola 00:47:08
cuando le hayamos dado el valor 00:47:09
lo leerá y lo llevará a nota 1 00:47:12
y luego hará el OR con esto 00:47:13
el OR con este 00:47:15
se quedará esperando 00:47:17
y después de leer nota 2 00:47:18
hace, vale, cuál 00:47:21
va a ser el problema de este 00:47:23
y ahora ya mostramos las dos notas 00:47:24
no, las notas son 00:47:26
y resultado 00:47:29
vale, cuál es 00:47:30
el problema de este código 00:47:36
pues que efectivamente el compilador 00:47:37
me dice, oye 00:47:40
perdona, que si 00:47:42
nota uno, la lees 00:47:44
y es verdadera 00:47:46
ya no voy a entrar ahí 00:47:48
ya no voy a entrar, porque como ya es 00:47:50
verdadera, el orden total 00:47:52
es verdadero, ya no voy a entrar 00:47:54
y te dice, y me estás diciendo 00:47:55
que hemos anotado dos, no tengo muy 00:47:58
claro que si voy a poder mostrarla, depende 00:48:00
la podré mostrar si 00:48:02
esta ha sido falsa y me has obligado a entrar 00:48:04
aquí, pero si esa ha sido verdadera, no 00:48:06
vale, entendéis el 00:48:07
problema, entonces en esta situación 00:48:10
aquí tendríamos que arreglarlo 00:48:12
y poner una barra 00:48:14
y ya el compilador se queda tranquilo 00:48:15
y dice, ah vale, ahora sé seguro 00:48:18
que me da igual que esta me dé falsa o true 00:48:19
voy a entrar en la otra 00:48:22
voy a entrar en la otra 00:48:24
entonces aquí el compilador 00:48:26
ya nos ha hecho ver la diferencia 00:48:28
entre poner doble barra y una 00:48:30
¿está claro? 00:48:31
bueno, a ver 00:48:43
la clave no es tanto poner la misma línea 00:48:43
sino entender la diferencia entre 00:48:45
María, explícaselo, anda 00:48:46
sí, o sea, pero la diferencia es 00:48:48
entre, no es tanto poner la misma línea 00:48:52
sino entre poner dos barras y una 00:48:54
claro, porque te las está preguntando 00:48:55
por separado 00:49:05
lo están preguntando por separado 00:49:06
eso 00:49:10
la pide a la vez que evalúa 00:49:13
entonces si no le hace falta evaluar 00:49:14
porque ya esta es true 00:49:16
vale, entonces aquí el compilador 00:49:17
entonces 00:49:20
aquí el compilador si no escribe esto rápido 00:49:24
y pone las dos barras 00:49:26
porque está acostumbrado y siempre pone las dos barras 00:49:27
si no lo escribe rápido 00:49:30
podría no darse cuenta de ese problema 00:49:32
podría no darse cuenta 00:49:34
pero aquí el compilador ya nos ha avisado 00:49:35
y nos ha dicho, al ponerse rojo no nos ha dejado seguir, y el compilador nos avisa. 00:49:38
Pero imaginaos que tenemos un programa en el cual esto se ha inicializado, 00:49:43
que suele ser la situación habitual, que uno cuando declara variables las inicializa 00:49:49
y luego ya le va dando valores según los usuarios van dando datos. 00:49:54
Entonces, si esto fuera un programa en el cual esto está inicializado, 00:49:59
porque por restricciones del procedimiento, por lo que sea, está inicializado, 00:50:04
Ahora ya el compilador no me va a avisar de que la estoy liando, no me va a avisar, porque yo pongo doble barra y él dice, vale, yo esto no lo voy a hacer, si esto es true, si esto es true no lo voy a hacer, con lo cual nota 2 se va a quedar con el valor de arriba, con el 0, no con el que le has metido, ¿me estoy explicando? 00:50:08
Vamos a ejecutarlo 00:50:26
Esta versión 00:50:28
Vale, introduzca las dos notas 00:50:30
Se queda esperando la primera 00:50:34
Un 3 00:50:35
Y se queda esperando la segunda 00:50:37
Porque la primera era falsa 00:50:39
Con lo cual, necesita la segunda 00:50:41
Se queda esperando un 6 00:50:44
Las notas son 3 y 6 es probablemente menos 1 00:50:45
Ahora vamos a darle una nota en la cual 00:50:47
Esta ya sea true 00:50:50
Como esta es true, ahí no entra 00:50:51
Vamos a volver a ejecutar 00:50:53
le damos 7 00:50:55
¿veis? ya ha pasado de pedir 00:50:58
la segunda nota, ha pasado y te dice 00:51:01
¿cuántas son 7 y 0? 0 porque 0 inicializamos 00:51:02
y de la segunda ha pasado 00:51:05
¿vale? 00:51:07
con lo cual el programa estaría funcionando mal 00:51:08
porque le estaría dejando la nota a 0 00:51:11
la segunda nota a 0 00:51:12
si ya la primera tiene aprobada pasaría 00:51:14
entonces 00:51:15
todos son pequeños matices 00:51:17
pequeñas cositas 00:51:20
que son muy básicas 00:51:22
pero que hay veces hacen que una aplicación 00:51:23
funcione mal 00:51:26
y no sabes por qué funciona mal 00:51:26
porque te crees que no, que es que en todo esto has hecho tu algoritmo mal 00:51:29
y no has hecho el algoritmo mal seguramente 00:51:31
sino es un error muy sencillo, muy básico 00:51:33
y a veces encontrar los errores básicos 00:51:35
es lo más difícil 00:51:38
¿vale? encontrar los errores sencillitos 00:51:39
vale, pues entonces, queda claro y clarísimo 00:51:42
la diferencia entre 00:51:46
lo ponemos aquí 00:51:48
lo ponemos aquí 00:51:51
si ponemos 00:51:53
doble barra 00:51:57
la segunda nota 00:51:59
no se lee 00:52:01
si la 00:52:04
primera 00:52:05
es mayor o igual 00:52:07
que 5 00:52:10
¿vale? entonces aquí en esta versión 00:52:11
si queremos las dos notas 00:52:13
porque luego el programa sigue haciendo cosas con las notas 00:52:16
pues si queremos las dos 00:52:18
porque sigue haciendo cosas con las notas 00:52:20
suponemos que es una aplicación más grande 00:52:21
pues si queremos las dos te voy a poner 00:52:22
¿vale? 00:52:23
vale 00:52:25
pues vamos a parar un segundito 00:52:27
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
12
Fecha:
6 de octubre de 2023 - 13:07
Visibilidad:
Público
Centro:
IES ROSA CHACEL
Duración:
52′ 30″
Relación de aspecto:
1.78:1
Resolución:
1280x720 píxeles
Tamaño:
1002.23 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid