Saltar navegación

20241001 ProgrEstruct-Ejercicios_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 2 de octubre de 2024 por Raquel G.

11 visualizaciones

Más información Transcripción

Descargar la transcripción

¿Vale? Como conocemos la variable string que sirve para guardar cadenas de texto, pues vamos a guardar el resultado en una variable string, porque el resultado es si se cumple o no se cumple, una cadena en cualquier caso, pues vamos a guardar el resultado aquí. 00:00:01
¿vale? hasta ahora no lo podíamos 00:00:18
hacer, lo metíamos directamente en el system out 00:00:21
porque no conocíamos la variable string 00:00:23
pero esa opción es más complicada 00:00:25
y no es más complicada, sino que es peor 00:00:27
por un concepto 00:00:29
que empezamos a introducir, pero que 00:00:32
tenéis que ir incorporando 00:00:33
como otro término técnico más en el mundo 00:00:35
del desarrollo, dime 00:00:37
¿si usamos la del system también es válida? 00:00:38
a ver 00:00:44
si haces lo que tiene que hacer 00:00:44
el programa y no hemos puesto 00:00:47
ninguna restricción específica 00:00:48
pero ahora no pienses en esos términos 00:00:50
no pienses en términos de yo lo voy a hacer así pero aprendí a hacerlo así 00:00:53
no, piénsalo en términos de tengo que incorporar 00:00:55
a mi programación todo lo que voy aprendiendo 00:00:57
vale, pues entonces si conocemos 00:00:59
la variable string vamos a usarla que para eso 00:01:01
la conocemos, entonces 00:01:03
este tipo de dato tenéis 00:01:04
que verlo simplemente como un tipo de dato 00:01:07
para guardar cadenas de texto, nada más 00:01:09
no tiene mayor complicación, entonces 00:01:11
como mi resultado en este caso es 00:01:13
o la cadena 00:01:15
si al menos dos son mayores de 21 00:01:16
o no, no son al menos 00:01:18
dos mayores de 21 00:01:21
como mi resultado es un texto 00:01:21
vamos a guardar el resultado aquí, como cuando hacíamos 00:01:23
un programa cuyo resultado era la suma de dos 00:01:26
números, pues decíamos, el resultado es un número 00:01:28
pues me declaro una variable int 00:01:30
para el resultado y luego ya 00:01:32
guardo en esa variable lo que sea 00:01:34
vale, pues entonces 00:01:36
ahora 00:01:38
estaba diciendo 00:01:40
¿por qué es 00:01:42
¿por qué es mucho mejor guardar 00:01:44
el resultado así en lugar de mostrarlo 00:01:46
directamente. En este programa tan 00:01:48
pequeñito y conociendo tan poco, quizá no 00:01:50
es un buen ejemplo, pero 00:01:52
pues por términos de desarrollar 00:01:54
siguiendo el principio 00:01:57
básico de 00:01:59
separación de códigos, 00:02:00
desacoplamiento. 00:02:03
Me explico, me explico. 00:02:05
Nuestros programas ahora son programas 00:02:06
muy cortitos, son cinco líneas, seis 00:02:08
líneas y están todos metidos en una única 00:02:10
clase, en un main. 00:02:12
Entonces ahí poco hay que separar 00:02:14
Porque es que son seis líneas. 00:02:16
Pues las meto todas ahí juntas y ya está. 00:02:18
Vale. 00:02:20
Pero en aplicaciones grandes, que hay muchísimo código, 00:02:20
ahí yo tendría que separarlo por partes, 00:02:24
que cada una se ocupara de su cosa. 00:02:26
Porque así, si me falla una parte, pues yo me voy a esa 00:02:28
y arreglo esa parte y las otras no tengo que mirármelas enteras. 00:02:31
¿No? 00:02:35
Si me falla algo relacionado con esta parte, 00:02:36
me voy a esta parte y lo arreglo. 00:02:39
Las otras no tengo que mirarlas. 00:02:40
Entonces, separar el código en partes es un principio básico. 00:02:41
vale, pues en concreto, por ejemplo 00:02:45
toda la parte del código 00:02:47
que se ocupa de lo que 00:02:49
llamamos la vista, o lo que es lo mismo 00:02:51
lo que ve el usuario, el que está usando la aplicación 00:02:53
pues eso se meterá aparte 00:02:56
se meterá aparte y se dirá 00:02:57
esta parte es la que se ocupa de mostrar por pantalla 00:02:59
o mostrar una interfaz 00:03:01
lo que sea, es la que se ocupa 00:03:03
pues entonces, esta parte nuestra 00:03:04
sería la parte que hace la lógica 00:03:07
y el resultado lo mete aquí 00:03:09
y el resultado se lo da a la otra 00:03:11
parte y la otra parte ya que decida 00:03:13
si esta 00:03:16
cadena la queremos usar en consola 00:03:17
o de repente dentro de cuatro días 00:03:19
la queremos usar en una interfaz, pero esa parte 00:03:21
lo cambia y coge ese stream y una interfaz 00:03:23
y a esta parte le da lo mismo 00:03:26
esta parte lo que hace es 00:03:28
guardo mi resultado en un stream 00:03:29
y se la paso 00:03:31
a la parte del código que se ocupa de trabajar 00:03:33
con ella para mostrarla 00:03:35
y esa parte que haga lo que le dé la gana 00:03:37
si hay cambios en esa parte 00:03:39
a esta le da igual, porque está unido 00:03:41
que haces meterlo aquí, esta no cambia 00:03:43
será la otra la que cambie 00:03:45
entonces nosotros hasta ahora 00:03:47
que metíamos en el system out ya directamente 00:03:49
el mensaje, si me cambiaban 00:03:51
el método de mostrar 00:03:54
la información, yo me tenía 00:03:55
que ir dentro del system out 00:03:58
a cambiar ahí la condición, a cambiarlo 00:03:59
todo, porque tenía todo el código mezclado 00:04:01
tenía mezclada la parte de mostrar 00:04:03
por pantalla con la parte de la lógica 00:04:05
de operar, lo tenía mezclado 00:04:07
entonces cualquier cambio implica retocarlo 00:04:09
todo, ¿vale? 00:04:11
Bueno, pues entonces iros quedando con la idea de códigos desacoplados, que significa, voy a separar en partes, y si tengo que cambiar algo, actualizar algo de mi software, actualizarlo, me voy a esa parte y lo demás ni lo miro, porque están separados, cada uno hace su parte y entrega el resultado. 00:04:13
pues este hace su parte y entrega el resultado 00:04:31
el resultado 00:04:34
lo que pasa es que nosotros ahora lo estamos 00:04:36
cogiendo, aquí dentro también 00:04:37
lo estamos cogiendo y luego lo mandaremos a un system out 00:04:39
vale, nosotros ya nuestro resultado 00:04:41
cogeremos y lo mandaremos 00:04:44
aquí, vale 00:04:45
pero lo podríamos haber mandado a otro código 00:04:47
vale, bueno 00:04:50
pues entonces, estamos en esto 00:04:51
ahora, siguiente 00:04:53
¿qué pensamos? vale 00:04:55
el resultado que yo luego mandaré al system out 00:04:57
¿qué tiene que tener? 00:05:00
pues no lo sé, tiene dos posibilidades 00:05:02
o esta 00:05:04
a ver, esto lo 00:05:06
vamos a, vale 00:05:09
tiene dos posibilidades, mi mensaje resultado 00:05:14
al menos dos 00:05:20
o menos de dos, ¿veis? aquí estamos 00:05:22
haciendo una asignación 00:05:25
a la variable string 00:05:27
recordad 00:05:29
que como vimos ayer, una variable 00:05:31
string que recibe en las 00:05:33
asignaciones, recibe cadenas de 00:05:35
caracteres, es lo único que puede recibir 00:05:37
una variable string en sus asignaciones 00:05:39
cadenas de caracteres 00:05:41
las cadenas de caracteres son texto 00:05:43
entre comillas dobles, luego esto 00:05:45
que recibe mi variable string está 00:05:47
bien, es perfectamente compatible 00:05:48
¿vale? podría 00:05:50
recibir también otra variable string, por supuesto 00:05:53
o sea, imaginaos que yo hago esta cosa 00:05:55
tan retorcida, podría 00:05:56
no pasa nada 00:05:58
sintácticamente es verdad 00:05:59
imaginaos, yo hago aquí texto 1 00:06:02
y el texto 1 es 00:06:05
como es muy largo, para que no me quede línea muy largo 00:06:06
mi texto 1 que sea este 00:06:08
al menos 2 00:06:10
y ahora me hago otro string 00:06:14
texto 2 00:06:19
y en texto 2 00:06:23
guardo esto 00:06:25
exacto 00:06:26
entonces, estas asignaciones 00:06:32
se ven más claras, son dos asignaciones 00:06:34
a dos variables string 00:06:36
dos variables string sirven para guardar 00:06:37
cadenas de texto 00:06:40
vale, entonces a una variable string 00:06:40
le puedo asignar también 00:06:43
otra variable string porque también es una 00:06:45
cadena de texto, bueno pues 00:06:47
entonces yo he cambiado 00:06:49
este código, podría haberlo decidido así 00:06:51
de cara a que esta línea sea más corta 00:06:53
y decirle, oye 00:06:55
a mensaje resultado tenemos 00:06:57
dos posibilidades 00:06:59
le asigno o texto 00:07:01
uno o texto dos 00:07:03
una de dos 00:07:07
o le asigno el texto de arriba 00:07:08
o le asigno el texto de abajo 00:07:11
una de dos, esas son mis 00:07:12
posibilidades con el mensaje resultado 00:07:14
¿verdad? no hay más que esas 00:07:17
vale, ¿y de qué depende 00:07:18
que le asigne texto 1 o texto 2? 00:07:21
depende de una condición 00:07:24
de la condición 00:07:25
al menos dos edades 00:07:27
ser mayor de 21 00:07:29
vale, pues ahora yo ya 00:07:31
como conozco muchos operadores 00:07:33
booleanos, relacionales y de todo 00:07:35
mi único problema es 00:07:37
poner en esta variable booleana 00:07:38
la condición de al menos 2 00:07:41
ser mayor que 21 00:07:43
y ahora ya no lo traduce 00:07:44
bueno, pues entonces tenemos 3 edades 00:07:46
¿cómo lo podemos traducir 00:07:49
con los operadores booleanos 00:07:51
AND y OR, que son los que conocemos 00:07:53
AND y OR, bueno y el negado 00:07:55
la condición de al menos 00:07:57
2 ser mayor que 21 00:07:59
lo primero que nos sale es decir, vale 00:08:00
yo tengo 3 edades, las que he llamado 00:08:03
E1, E2, E3, para que sea más corto 00:08:05
pues puede ser que E1 sea mayor que 21 00:08:07
y E2 mayor que 21 00:08:10
E1 mayor que 21 y 00:08:13
E3 mayor que 21 00:08:15
o E1 mayor que 21 00:08:17
y E3 mayor que 21 00:08:19
ya está, ya he recogido la condición que me han dado 00:08:21
con los operadores AND y OR 00:08:23
pues es nuestro problema 00:08:25
cuando me expresa una condición en lenguaje natural 00:08:27
que puede ser cualquier cosa, que al menos dos sean mayores 00:08:29
que 21 pero uno tenga un cuñado 00:08:32
en no sé dónde y el otro en no sé qué 00:08:33
pues yo todo eso lo traduzco 00:08:35
a ans y a or 00:08:37
que me queda muy larga, me ha quedado muy larga 00:08:38
pues eso mismo que yo he dicho 00:08:41
que la primera y la segunda 00:08:43
sean mayores que 21 00:08:45
o que la primera y la tercera sean mayores que 21 00:08:46
o que la segunda y la tercera 00:08:49
sean mayores que 21 00:08:52
esa es la traducción exacta 00:08:52
de al menos dos mayores de 21 00:08:55
¿verdad? 00:08:57
bueno, pues eso codificado 00:08:59
Sería 00:09:02
Esta condición de aquí arriba 00:09:13
Yo meto esa condición en un boolean 00:09:15
Para que no me quede luego este condicionado 00:09:19
Aquí gigante 00:09:21
Lo meto en un boolean 00:09:22
Y es lo que 00:09:24
Son 3 or 00:09:25
De esto 00:09:28
Entonces yo voy anidando con paréntesis 00:09:29
No pasa nada 00:09:32
Esta condición que significa 00:09:32
Que la primera sea mayor que 21 00:09:34
y la segunda mayor que 21. 00:09:36
¿Que esto no ocurre? 00:09:41
Pues entonces, o que esta sea mayor que 21 00:09:43
y esta mayor que 21. 00:09:46
O si no, que esta sea mayor que 21 00:09:48
y esta sea mayor que 21. 00:09:50
Entonces, esa condición recoge exactamente eso. 00:09:52
Si los tres son mayores que 21, 00:09:56
esta ya va a ser true. 00:09:59
Entonces, el total es true. 00:10:01
¿Vale? 00:10:04
y si solo es una 00:10:04
mayor que 21, solo una 00:10:07
estas tres van a ser falsas 00:10:09
las tres 00:10:11
tengo una pequeña duda 00:10:12
si yo en vez de poner edad 00:10:14
21 pusiera un boolean 00:10:17
no tendría que poner 00:10:18
o sea, esto lo hubieras metido a su vez 00:10:20
en tres booleans, tuvieras tres booleans 00:10:23
este, este y este 00:10:25
pues ya está, lo sustituyes y ya está 00:10:27
no tengo que poner que sea true 00:10:29
la condición ya asume que eso tiene que ser true 00:10:30
Claro, claro. O sea, si tú lo hubieras desglosado en algo así, por ejemplo, C1 igual a E1 mayor que 21. Y lo mismo con las otras. 00:10:32
Claro 00:10:45
Si se trata de 00:10:50
Cómo lo ve uno más claro 00:10:53
Yo creo 00:10:55
Y ahora ya pones aquí 00:10:58
C1, aquí C2 00:11:00
Aquí C1 otra vez, aquí C3 00:11:03
Aquí C2 y aquí C3 00:11:05
Es lo mismo, exactamente lo mismo 00:11:07
Se trata de cómo queda el código más claro 00:11:09
Entonces 00:11:11
Cuando uno ve 00:11:12
si uno ve esta condición 00:11:14
que es la condición que va aquí metida 00:11:16
que es la que va aquí 00:11:18
¿no? si uno 00:11:20
cuando ve aquí la condición dice, uy ¿de qué depende 00:11:22
que haya dos mensajes? ¿de qué depende? pues se va 00:11:25
a esta condición aquí arriba 00:11:27
y lo ve escrito así 00:11:28
la ve enseguida y dice, ah vale 00:11:30
lo que me está expresando es que me va a 21 00:11:33
pero si empieza a ver aquí C1, si C2, si C3 00:11:34
ya le obligas a ir para arriba 00:11:37
¿y esto qué significa? entonces 00:11:39
hombre, si la condición queda muy larga 00:11:41
y viene bien para cortar códigos, sí. 00:11:43
Pero si dificulta que entendamos exactamente qué significa esto, 00:11:45
pues es mejor no hacerlo. 00:11:49
Aunque es lo mismo, efectos prácticos es lo mismo. 00:11:50
¿Vale? 00:11:54
Vale, pues entonces se trata de usar el no lógico, 00:11:55
el and y el or, para expresar lo que nos estén diciendo. 00:12:00
Recordad que esto es que ambas sean true simultáneamente, 00:12:06
Y el or es o una o la otra, o una o la otra, o ambas, ¿vale? 00:12:11
Vale, o las dos, el or trajo las dos, ¿vale? Porque el or exclusivo también no. 00:12:28
Vale, entonces esta yo creo que es la condición más clara para expresar la idea de que al menos dos a mayores que 21, ¿vale? 00:12:33
entonces 00:12:42
a lo mejor alguno 00:12:45
podría haber llegado a esta condición 00:12:47
por un camino más largo 00:12:49
o porque está un poco 00:12:51
embrollado en ese momento 00:12:52
entonces vamos a ver ese ejemplo para ver 00:12:54
un poco la aritmética de estos operadores 00:12:57
no os liéis 00:12:59
no os volváis locos, pero si quiero que 00:13:01
se quede la idea de que estos operadores 00:13:03
igual que las sumas y las restas, tienen una aritmética 00:13:04
la propiedad conmutativa 00:13:07
la distributiva, etc. 00:13:09
Vale 00:13:12
Bueno, a ver, como está a punto de tocar 00:13:13
Lo paramos aquí 00:13:19
Y lo decimos luego 00:13:21
Subido por:
Raquel G.
Licencia:
Dominio público
Visualizaciones:
11
Fecha:
2 de octubre de 2024 - 17:35
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
13′ 25″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
49.46 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid