Saltar navegación

20240924 ProgrEstruct-Variables-ejercicios_2 - Contenido educativo

Ajuste de pantalla

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

Subido el 24 de septiembre de 2024 por Raquel G.

9 visualizaciones

Más información Transcripción

Descargar la transcripción

vale, si quiero 00:00:00
que el resultado no me quede tan feo 00:00:02
lo que me muestra, como habéis 00:00:04
hecho muchos, como ya sabemos 00:00:06
que el operador más concatena 00:00:08
cosas en la consola, las concatena 00:00:10
pues algunos ya habéis 00:00:12
hecho esto, ¿no? 00:00:14
la suma es 00:00:16
y habéis hecho la concatenación 00:00:17
del mensajito 00:00:21
con el contenido de la variable 00:00:22
¿vale? algunos ya habéis hecho esto 00:00:24
para que lo que me muestre por la consola 00:00:26
quede un poco más bonito 00:00:28
ya queda la suma es 8 00:00:31
que parece que bueno 00:00:34
y también algunos 00:00:35
lo que a lo mejor 00:00:37
habéis hecho es, siguiente paso 00:00:40
no usar esta variable 00:00:42
intermedia, en lugar de 00:00:44
guardar el resultado en una 00:00:46
variable intermedia y luego mostrar la variable 00:00:48
a lo mejor 00:00:50
con una variable intermedia 00:00:51
a lo mejor algunos lo que habéis hecho es 00:00:53
voy a pasarle al system out y a la suma 00:00:55
Directamente 00:00:58
Y a pasarle la suma, ¿no? 00:00:59
Por ejemplo, algunos a lo mejor habéis 00:01:01
Obviado esta línea 00:01:03
Y habréis puesto aquí 00:01:05
Y habéis puesto aquí 00:01:09
Número 1 00:01:12
Más número 2 00:01:15
Yo prefiero pasarle 00:01:17
La variable 00:01:19
Yo declaro la variable de resultados 00:01:20
Efectivamente 00:01:23
Por un lado es más organizado 00:01:26
quizá, y el código se hace más claro 00:01:28
porque si tú, el que ve este código 00:01:30
se ve aquí ya directamente 00:01:32
una variable resultado, además con el 00:01:34
nombre bien elegido, resultado 00:01:36
pues ya sabe que hay tres datos con los que juega 00:01:37
las dos entradas y la salida 00:01:40
que la tiene ahí, y cada vez que 00:01:42
vea esa variable por algún lado sabe que se refiere 00:01:44
a eso, si no 00:01:46
ya de buenas a primeras no sabe muy bien 00:01:47
que este código va a tener un resultado, lo va 00:01:50
a tener que ver luego aquí cuando lo vea, entonces 00:01:52
está bien para que el código sea más legible 00:01:53
una variable para cada cosa 00:01:56
y ya no solo eso, sino que nos pueden salir 00:01:57
luego efectos secundarios, porque bueno 00:02:00
con esto así puesto 00:02:01
no pasa nada 00:02:04
no pasa nada porque el programa te sigue mostrando 00:02:05
la suma, recordad que esto 00:02:08
es una expresión suma y como yo 00:02:10
aquí tengo un número entero y otro número 00:02:12
entero, esta de aquí 00:02:14
pues la suma 00:02:15
de dos enteros es un entero 00:02:18
luego el sistema me va a mostrar la suma 00:02:20
entonces yo vuelvo a hacer la prueba con esta 00:02:22
variación que he hecho quitándole esto, pues la he querido 00:02:24
quitar, vuelvo a hacer la prueba 00:02:26
de este código, a ver si sigue 00:02:28
funcionando, y le digo 00:02:30
3 y 4, 7, ah pues 00:02:31
sigue funcionando, con este cambio que he hecho 00:02:34
vale, pero yo como estoy todavía 00:02:36
en fase de mantenimiento de este código 00:02:38
lo estoy manteniendo, voy a hacerle otro 00:02:39
cambio, que es, como 00:02:42
ojo, es muy feo 00:02:44
que me dé el 7 sin más, yo el 7 que es 00:02:46
3 más 4 00:02:48
3 menos 4 más 5 00:02:49
o sea, el 7 que es 00:02:52
mejor si me dice 00:02:53
la suma es 00:02:55
para que tú veas que lo que te está mostrando 00:02:56
es la suma 00:02:59
bueno, pues entonces, a ver 00:03:00
me estáis haciendo caso todos, incluso los que no les veo 00:03:03
las caras 00:03:05
porque es que solo veo las caras a los de adelante 00:03:07
pero de la segunda fila para atrás no veo las caras de nadie 00:03:08
vale 00:03:11
bueno, sois todos guapos 00:03:13
pero vamos 00:03:15
lo interesante es que me hagáis caso y me escuchéis 00:03:16
por Dios santo bendito 00:03:19
porque 00:03:20
La zona de atrás está maldita 00:03:21
Los que se ponen atrás 00:03:25
Suelen suspender siempre 00:03:27
Conclusión, romped la tradición 00:03:29
¿Vale? 00:03:31
Los que os ponéis atrás 00:03:32
Escuchadme y atendedme 00:03:34
¿Vale? 00:03:37
Y si no veis 00:03:39
O no oís porque no grito 00:03:40
O el sitio no os gusta porque no se ve nada 00:03:42
Pues ya movemos la mesa 00:03:45
Hacemos lo que haga falta 00:03:46
¿Vale? Pero por favor, los de atrás que me escuchen 00:03:47
y me atienden igualmente. 00:03:50
Porque si no, van a suspender. 00:03:51
¿Vale? 00:03:53
Bueno, pues entonces, 00:03:55
no aprovechen la coyuntura. 00:03:56
Callado. 00:03:58
Vale. 00:03:59
Bueno, pues entonces, 00:04:00
esta variante de código que hemos hecho, 00:04:03
poniendo aquí directamente la expresión, 00:04:05
nos ha funcionado. 00:04:08
Y así no uso una variable intermedia. 00:04:10
Bueno, vale. 00:04:12
Pero ahora resulta que seguimos haciendo modificaciones. 00:04:14
Porque un código, una vez, Mario, 00:04:16
o no, Andoni quería decir 00:04:19
no, Mario 00:04:21
pero Mario se movía pero estaba callado 00:04:25
y tú estabas quieto pero hablabas 00:04:27
o sea, tú peor 00:04:30
silencio, vale 00:04:30
y todos los que hablen también, por favor 00:04:33
vale, entonces 00:04:35
este código ya está hecho y funciona 00:04:37
pero una aplicación cuando está hecha 00:04:42
y ya funcionando, desplegada en un servidor 00:04:43
ejecutándose, no se le ha acabado 00:04:46
la vida, ese código 00:04:48
seguirá ahí para las 00:04:50
modificaciones que nos vayamos 00:04:52
dando cuenta que interesa hacer 00:04:54
porque son más bonitas, entonces 00:04:56
el usuario de este programa me dice 00:04:57
oye, que me diga el 7 sin más no me gusta 00:04:59
porque yo no sé si se refiere 00:05:02
a la suma, se refiere al factorial 00:05:04
se refiere a la potencia 00:05:06
no lo sé, porque si yo le meto 2 y 2 y me saca 00:05:07
4, que me ha hecho, 2 elevado a 2 00:05:10
2 más 2, dicen, este programa 00:05:12
vale, funciona 00:05:14
pero por favor arreglalo un poco 00:05:15
y que me diga, la suma es 7 00:05:17
para que yo vea que está sumando 00:05:20
no pasa nada, vamos a cambiarte el programa 00:05:22
vamos a cambiártelo, porque un programa se va actualizando 00:05:25
todos los software tienen sus versiones, la 1, la 2, la 3 00:05:28
vale, pues entonces venimos aquí 00:05:32
y hacemos alegremente 00:05:35
no pasa nada, como yo sé lo de la concatenación 00:05:37
te hago, la suma es 00:05:40
y concateno, vale 00:05:43
Y ya está, y ha actualizado el programa 00:05:47
¿Vale? 00:05:50
¿Está claro? 00:05:52
¿Nadie tiene nada que decirme? 00:05:54
Por supuestísimo 00:06:00
Estáis absolutamente solos 00:06:01
Solo tenéis el ordenador 00:06:03
No tenéis ningún tipo de internet 00:06:04
Ni de documentación, ni de nada 00:06:06
Más que las que yo os dé 00:06:07
¿Vale? 00:06:09
¿Nadie tiene nada que decirme? 00:06:11
¿Me refiero a esto que he escrito? 00:06:12
Muy bien dicho 00:06:13
Vale, entonces yo he hecho una actualización 00:06:17
Así alegremente 00:06:20
Y ahora me pongo a hacer las pruebas 00:06:21
De este código 00:06:23
¿Estáis situados y conectados? 00:06:24
Como alguna vez me hagáis ser relacionados con esto 00:06:27
No os explico lo que os hago 00:06:29
Porque es muy doloroso 00:06:32
¿Vale? 00:06:34
¿Eh? 00:06:36
Efectivamente 00:06:39
Vamos a hacer la prueba a ver qué pasa 00:06:40
Muy bien 00:06:42
Introduja número entero 00:06:43
3, 3 00:06:45
La suma es 33 00:06:47
O sea, poniendo un string para concatenar 00:06:48
Claro, yo me creo 00:06:51
Que lo que he hecho es simplemente 00:06:53
Que muestre un mensaje antes y luego ya la suma 00:06:54
Y le ha cagado 00:06:57
¿Por qué le ha cagado? 00:06:58
Porque ya sabemos cómo funciona el operador 00:07:00
Concatenación en las 00:07:02
Él va de izquierda a derecha 00:07:04
Lo primero que hace, esto y esto 00:07:06
Como esto es un string 00:07:09
la concatenación 00:07:10
el operador suma entre esto y esto 00:07:13
será una concatenación 00:07:15
con lo cual medida la suma es 3 00:07:16
y ahora ya 00:07:19
a ese 3 me concatena 00:07:21
lo que venga después que es otro 3 00:07:23
entonces el efecto es la suma es 00:07:24
33 y no lo es 00:07:27
la suma es 6 00:07:28
entonces ¿cuál ha sido aquí 00:07:29
el problema? 00:07:33
claro, no poner paréntesis 00:07:34
porque las expresiones se evalúan siempre 00:07:36
de izquierda a derecha, de izquierda 00:07:39
a derecha, a menos que yo 00:07:41
ponga un paréntesis, que entonces lo que gana es el paréntesis 00:07:43
entonces yo lo primero que quería 00:07:45
que se hiciera, era esta suma 00:07:47
esto es lo primero que quería que se hiciera 00:07:49
esta antes que esta 00:07:51
entonces si quiero que esta se haga 00:07:52
antes que esta, tengo que poner un paréntesis 00:07:55
y desde el momento 00:07:57
en que pongo aquí 00:07:59
un paréntesis 00:08:01
ya he cambiado 00:08:02
el orden 00:08:05
en el que 00:08:06
se evalúan las sumas 00:08:08
en esta expresión, primero 00:08:10
la del paréntesis 00:08:12
como es número, número 00:08:13
eso sí que es una suma entera 00:08:16
6, 7, la que sea 00:08:17
y ahora una vez esta suma 00:08:19
hecha, ya va esta 00:08:22
y esta ya sí que es cadena 00:08:24
número 00:08:26
cadena número es concatenación 00:08:27
concatenación, pues ahora ya 00:08:30
con este arreglo 00:08:32
esto ya, si vuelvo a hacer 00:08:33
la misma prueba, 3, 3, este ya sí 00:08:36
¿vale? 00:08:39
bueno, pues este error podríamos haberlo tenido 00:08:43
vale, entonces todas estas cosas 00:08:45
que estoy diciendo están claras hasta aquí bien 00:08:49
muy bien 00:08:51
¿qué otro error 00:08:53
ahora ya de ejecución? 00:08:57
bueno, el otro, el error que he dicho antes 00:08:59
cuando decía la suma es 33 00:09:01
no era un error de 00:09:02
ejecución, porque el programa 00:09:05
no ha fallado, el programa ha hecho 00:09:07
exactamente lo que tenía que hacer 00:09:09
Si tú le has dicho que haga esto, sin paréntesis, pues él ha cogido y te ha hecho eso. Luego el error que hemos visto antes no era un error de ejecución, era un error de funcionamiento del programa, de que el código estaba mal hecho, ¿vale? Hacía otra cosa, pero se ejecutaba perfectísimamente. 00:09:10
lo que pasa es que hacía otra cosa 00:09:30
bueno 00:09:32
ese mal funcionamiento 00:09:34
porque el código estaba mal 00:09:37
porque hacía otra cosa diferente a la que yo le pedía 00:09:38
lo hemos arreglado con el paréntesis 00:09:41
vale, bueno vamos a hacer ahora 00:09:43
vamos a forzar un error 00:09:45
de ejecución 00:09:46
el error de ejecución es otro tipo de error, es un error que yo arranco 00:09:48
el programa y ¡paf! explota, ha fallado 00:09:51
es distinto que yo ejecute 00:09:53
el programa y funcione perfectamente 00:09:55
pero lo que haga no es lo que yo quiero 00:09:57
es distinto eso a que yo ejecute el programa 00:09:59
y pum, explote, es distinto 00:10:01
esto último que he dicho es error 00:10:03
de ejecución, lo anterior no 00:10:05
es error, es que el programa 00:10:07
está mal diseñado, nada más 00:10:09
bueno, pues por ejemplo 00:10:11
algunos habéis encontrado algún error de ejecución 00:10:12
con este código 00:10:16
que dice 00:10:17
algo así, imaginaos que 00:10:20
ahora ya este código compila 00:10:21
pero este de compilación no tiene, vamos a volver a ejecutarlo 00:10:23
introduzca un número 00:10:26
entero. Y a mí se me va 00:10:27
la mano cualquier cosa y pongo 00:10:29
7 y algo que no es 00:10:31
un número entero. Cualquier cosa que no es 00:10:33
un número entero. Por ejemplo, he puesto 7 00:10:35
y griega. ¿Vale? 00:10:37
Algo que no es un número entero. 00:10:39
Y le doy yo aquí a Enter. 00:10:42
¡Pum! Esto sí es 00:10:44
un error de ejecución. 00:10:45
Aquí el programa ha petado y se ha parado. 00:10:47
¿Vale? Entonces este, 00:10:50
errores de ejecución nos van a salir muchos. 00:10:51
Según vayamos haciendo cosas, un montón. 00:10:53
entonces tenemos que arreglar el código 00:10:55
claro, para que este error 00:10:58
entonces 00:11:00
tú esto lo has vivido antes, ¿a que sí? 00:11:00
claro, y lo vamos a vivir muchísimo 00:11:04
lo vamos a vivir mucho 00:11:06
errores de ejecución hay un montón 00:11:08
depende de lo que hayamos hecho mal 00:11:10
claro, y cuando nos pase 00:11:12
nos va a salir este rollo rojo 00:11:14
y la aplicación se habrá 00:11:16
parado, se acabó, como veis no me pide 00:11:18
el siguiente, ya no me lo pide 00:11:20
la aplicación se detuvo, no hay programa 00:11:22
ya, termínate 00:11:24
¿vale? entonces ahora nos toca 00:11:26
a nosotros la siguiente parte, importante 00:11:28
en la que tenemos que ir cogiendo soltura poco a poco 00:11:31
que es, uy 00:11:32
¿cómo interpreto yo de esas líneas rojas 00:11:33
qué es lo que ha pasado 00:11:37
y cómo lo arreglo? 00:11:38
pues estas líneas rojas, aunque parezcan 00:11:40
una cosa rara 00:11:42
estas líneas rojas nos dan mucha información 00:11:44
primero 00:11:46
en la primera línea 00:11:48
nos dicen 00:11:51
algo relacionado 00:11:53
con lo que ha pasado 00:11:54
un término relacionado con lo que ha pasado 00:11:57
entonces normalmente 00:11:59
de ahí ya, de lo que nos dice ahí en inglés 00:12:01
algo ya 00:12:03
entendemos 00:12:05
entonces input mismatch 00:12:06
input entrada 00:12:08
mismatch es que no encaja, que no casa 00:12:10
pues la entrada no casa 00:12:12
entonces ya con eso 00:12:15
alguna información nos da de que 00:12:17
el problema es la entrada del dato 00:12:19
la entrada no casa 00:12:21
ya casi con eso 00:12:22
podríamos deducirlo y decir 00:12:24
y tanto que no casa, esto no es un número entero 00:12:26
¿vale? entonces cada vez que veáis 00:12:28
un input mismatch 00:12:30
exception, es porque 00:12:33
estáis leyendo del teclado 00:12:34
y el dato que en la ejecución habéis metido 00:12:36
no es el tipo 00:12:39
de dato que espera el objeto 00:12:41
lector que lee, si yo 00:12:42
aquí pongo un next in 00:12:44
¿vale? si yo 00:12:46
aquí pongo next in 00:12:48
es que no hay tutía, tengo que poner 00:12:50
un entero, menos 12, 13 00:12:52
14, un entero 00:12:55
y si yo no pongo un entero, pongo 00:12:56
7,8 o pongo hola que tal 00:12:58
pongo algo que no sea un entero, va a salir 00:13:00
el input mismatch y se va a parar la aplicación 00:13:02
y se acabó, vale 00:13:05
entonces las sentencias de lectura 00:13:06
del teclado pueden 00:13:08
generar errores de ejecución 00:13:10
que paran la aplicación si yo no meto 00:13:12
bien el dato, vale 00:13:14
bueno, pues esos errores de ejecución 00:13:16
son 00:13:19
se llaman así 00:13:20
input mismatch 00:13:23
entonces ya que nos vaya sonando 00:13:24
que nos vaya sonando cuando veamos esto 00:13:26
cuando veamos esto es 00:13:28
el que ejecutó el código 00:13:30
metió algo escrito 00:13:32
que no correspondía con lo que 00:13:33
el lector esperaba 00:13:36
si aún así 00:13:37
tenemos dudas 00:13:40
no somos capaces de encontrar 00:13:42
por donde van los tiros 00:13:44
pues esta línea roja nos siguen ayudando 00:13:45
entonces uno va bajando, va bajando, va bajando 00:13:47
va bajando hasta que llega 00:13:49
a la primera referencia 00:13:52
al código que ha hecho él 00:13:54
porque esto es escáner, escáner, escáner 00:13:55
veis, estos son programas Java 00:13:57
que ya están hechos, la clase escáner es una clase 00:13:59
que ya está hecha, la hemos hecho nosotros 00:14:01
entonces aquí no tiene sentido que nos metamos 00:14:03
porque no vamos a entender nada 00:14:05
y llegamos hasta, uy 00:14:06
ejercicio 1.java, esta sí la he hecho yo 00:14:09
aquí está mi error 00:14:12
entonces vamos bajando, a veces será bajar hasta 5 00:14:13
a veces será bajar hasta 127 00:14:16
porque si una clase se va llevando a otra, a otra, a otra 00:14:18
vale, pues entonces, en cuanto uno pinche aquí 00:14:21
pinche aquí, paz, el entorno de desarrollo 00:14:23
el entorno de desarrollo, que es el que deja de la tarea, el entorno 00:14:26
te lleva a la línea que provocó ese error de ejecución 00:14:29
y entonces ya, entre el mismatch 00:14:33
la entrada no casaba y que me dice, fue cuando hice eso 00:14:35
y decimos, seguro que hemos ejecutado 00:14:39
esto metiendo algo que no era un número entero, por ejemplo 00:14:42
entonces, no hay nada que arreglar en el código 00:14:45
Lo que hay que decirle al usuario es 00:14:47
No introduzcas 00:14:49
A Pepito Pérez 00:14:51
Es lo único que hay que hacer 00:14:53
No hay alguna forma, seguro que sí 00:14:54
De hecho iba a decir 00:14:56
Esto que estoy diciendo es con matices y con pinzas 00:14:59
Porque tenemos una manera 00:15:02
Que veremos en el tema de excepciones 00:15:03
De que la aplicación 00:15:05
No se pare, aunque esto se lo metas mal 00:15:07
Y se vaya por otro camino 00:15:09
¿Vale? 00:15:11
Si tenemos esa opción 00:15:13
De algún lector, 00:15:14
colocar el lector de tal manera 00:15:15
de que elimine lo que viene al rato. 00:15:17
A ver, lo que podemos hacer es, 00:15:21
en lugar de next int, 00:15:22
usar otro método 00:15:24
que te lea la cadena entera. 00:15:25
Sea lo que sea. 00:15:27
Y luego tú ya por código 00:15:28
de esa cadena extraes 00:15:29
la parte que te interese. 00:15:30
Pero tenemos que meternos 00:15:31
por código en la cadena 00:15:33
y ya operar, hacer lo que sea. 00:15:34
¿Vale? 00:15:35
Pero con next int 00:15:37
te va a saltar 00:15:38
si no metes un número entero. 00:15:39
Positivo o negativo, da igual. 00:15:41
Pero te va a saltar. 00:15:42
Siempre. 00:15:43
Eso no hay alternativa. 00:15:44
Bueno, se llama 00:15:45
Nextline, pero sí es eso 00:15:48
Con Nextline tú lees la cadena entera y no te salta nunca 00:15:49
Porque cualquier cadena que metas se la traga 00:15:52
Pero luego esa cadena ya tú 00:15:54
Tienes que operar con ella, ¿vale? 00:15:56
Bueno, esos son los errores que 00:15:59
Y de este programa es que no tiene más 00:16:01
Vuelta de hoja que darle 00:16:04
¿Alguna duda con esto? 00:16:05
No, vale, pues entonces 00:16:12
Este otro es igual 00:16:14
lo que pasa es que 00:16:16
en lugar de dos datos de entrada 00:16:18
son tres, luego tres variables 00:16:20
en lugar de int 00:16:22
son decimales 00:16:25
luego double 00:16:27
y en lugar 00:16:29
de hacer la operación suma 00:16:31
hay que hacer la operación promedio 00:16:32
pero la operación promedio 00:16:34
pues ya sabemos como es 00:16:35
la suma dividida entre el total 00:16:38
este hecho así 00:16:39
en plan rápido 00:16:42
pues habréis hecho algo así 00:16:43
Ahora ya no se me olvida marcar esto 00:16:47
Vale, como son tres números 00:16:57
Tres variables 00:17:02
¿De qué tipo? Para guardar números decimales 00:17:04
Pues tres variables de Abel 00:17:06
Num1 00:17:07
Num2 00:17:10
Num3 00:17:12
¿Cómo voy a leer del teclado? 00:17:14
Pues un escáner 00:17:17
¿Vale? 00:17:18
Ya el 00:17:26
Ahora pido del teclado 00:17:27
Voy a copiar y pegar para ahorrarme 00:17:30
Vale, habréis hecho aquí num1, num2, num3 00:17:32
Y en lugar de next in, como aquí lo que queremos es un next double 00:17:55
Ahora, la variable resultado 00:18:00
Pues la variable resultado también en un double, claro 00:18:12
La variable de resultado que va a tener 00:18:15
Justo la suma de las tres 00:18:18
Efectivamente, num1 00:18:21
Claro, fuera del paréntesis 00:18:25
Más num2, más num3 00:18:27
Y todo esto entre 3 00:18:29
Este es el promedio, ¿verdad? 00:18:32
Obviamente, si no ponemos el paréntesis 00:18:35
Todos sabemos por matemáticas 00:18:37
Claro, que como la división es prioritaria 00:18:39
Respecto a la suma y resta 00:18:44
Haría primero esta división 00:18:46
Y luego esto ya lo sumaría con esto y con esto 00:18:47
Eso no es la media 00:18:50
Entonces tenemos que arreglarlo poniendo paréntesis 00:18:52
Vale 00:18:54
Y ya está 00:18:57
Ahora mostramos el resultado y se acabó 00:19:01
La media, perdón 00:19:08
Para abrir el visor del explorador 00:19:17
Que él lo tiene cerrado 00:19:18
El visor del explorador 00:19:19
¿A qué te refieres? 00:19:22
La estructura de las carpetas 00:19:24
Ah, bueno 00:19:25
A ver, siempre podéis, si se os han cambiado las ventanas 00:19:28
En window perspective le das a reset 00:19:31
Y te pone la inicial 00:19:33
Ya con la estructura inicial 00:19:36
Luego tú ya si la quieres volver a retocar 00:19:37
Vale, media 00:19:39
Más result 00:19:41
Bueno, pues en este caso 00:19:43
Este programa es así tal cual 00:19:48
Y habiendo hecho el primero 00:19:51
Este nos habrá dado problemas 00:19:52
Porque es lo mismo pero con números dabel 00:19:55
Entonces uno lo prueba 00:19:57
y hace algunas pruebas 00:19:59
para ver si funciona 00:20:04
aquí, siguiente cosa 00:20:05
que uno se tiene que acordar 00:20:08
para que no le den errores de ejecución 00:20:10
por ejemplo, vamos a hacer la prueba 00:20:11
introduzca número entero 00:20:14
8.9 00:20:16
¡pum! 00:20:18
vale, claro 00:20:20
¿por qué uno no se tiene que quedar parado aquí? 00:20:22
porque se acuerda, porque lo ha memorizado y lo ha estudiado en casa 00:20:24
que 00:20:26
para meter el método next double 00:20:27
el dabble que tú le metes lo espera con una coma 00:20:30
¿vale? 00:20:33
porque aquí no se escribe, esto no es código Java 00:20:35
esto es lo que tú metes desde el teclado 00:20:37
y luego ya aquí 00:20:39
cuando llegamos al código Java, aquí 00:20:41
este next dabble ya coge eso 00:20:43
lo convierte en un dabble 00:20:45
patatín, si lo metiéramos directamente 00:20:47
desde aquí, que es código Java 00:20:49
aquí sí que tiene que ser el punto, porque para Java 00:20:50
la coma no significa nada 00:20:53
aquí sí sería el punto 00:20:55
pero cuando metemos por teclado es otra cosa 00:20:56
Pero cuando vamos por teclado se lo estamos dando a este 00:20:58
Y este lo espera con coma 00:21:00
¿Vale? 00:21:02
Bueno, pues es el primer error que os puede haber salido a lo mejor 00:21:04
Al hacer esta prueba, que cuando habéis hecho la prueba de ejecución 00:21:06
Os haya salido 00:21:09
Esto que me han metido no es un double 00:21:10
Porque no lo es, para él 00:21:12
No lo es para él 00:21:13
Vale, entonces si se lo ponemos bien 00:21:15
7 con 9 00:21:17
5 con 9 00:21:20
Y 5 con 4 00:21:22
Ahora ya sí, media 00:21:24
¿Vale? 00:21:26
vale, lo que pasa, a ver, es una media muy fea 00:21:27
porque me da con todas las cifras decimales 00:21:30
de precisión que admite 00:21:32
el dabble, que son un montón 00:21:34
uno lo puede redondear, vale 00:21:35
que es lo que te he encargado a ti, que lo investigaras 00:21:37
porque yo no me acuerdo del parámetro 00:21:40
para darle el formato, ¿lo has encontrado ya? 00:21:42
pues, ¿lo has hecho con 00:21:44
el printf o lo has hecho con format o cómo lo has hecho? 00:21:46
con 00:21:49
decimal format 00:21:49
vale, pues, o sea, aquí 00:21:53
de la clase decimal 00:21:56
punto format 00:21:58
decimal en mayúscula 00:21:59
ah decimal format la clase enterita 00:22:01
vale y un método de esa clase 00:22:05
decimal format punto 00:22:08
bueno espérate que te lo miro 00:22:10
es que 00:22:11
vale 00:22:13
instancias aquí 00:22:20
vale 00:22:21
bueno no lo voy a poner 00:22:21
porque complica 00:22:27
demasiado pero tú úsalo si quieres 00:22:29
para tus propios programas vale 00:22:31
pero no lo voy a poner porque no quiero 00:22:33
liar, vale 00:22:35
lo único que digo hasta ahora es que 00:22:37
si esto no le gusta a uno 00:22:39
pues puede buscar una manera 00:22:41
de que solo a efectos 00:22:44
de mostrarse en pantalla, solo a efectos 00:22:45
de mostrarse, te muestre 00:22:48
solo dos truncado, pero solo a efectos 00:22:49
de mostrarse, la variable 00:22:52
la variable result 00:22:54
seguirá siendo dable con todos 00:22:56
sus decimales, por supuesto, es solo a efectos de mostrarse 00:22:58
y para eso hay clases que lo 00:23:00
hacen como esa que ha encontrado ella 00:23:02
hay un método de java 00:23:03
printf que tú le puedes 00:23:05
dar unos parámetros y te lo muestra 00:23:08
redondeado, eso ahora mismo 00:23:10
no nos metemos en ello para no 00:23:12
liar, pero bueno, si a uno lo quiere 00:23:13
investigar como ella, pues que lo investigue 00:23:15
pero no 00:23:17
no lo metemos, ¿vale? 00:23:18
vale, bueno 00:23:27
¿estamos todos sincronizados 00:23:29
en este punto? 00:23:32
nadie está perdido, ¿no? 00:23:35
vale, entonces ahora mismo todos tendríais 00:23:37
que poder hacer programas de este tipo 00:23:39
sencillos, pues que reciben 00:23:41
datos de entrada, operan con ellos y muestran 00:23:43
el resultado, vale 00:23:45
en ese punto estamos, recibimos datos, operamos y muestramos 00:23:46
el resultado, muy bien 00:23:49
vale, vámonos 00:23:50
esto de aquí 00:23:55
es una tontería 00:24:00
es solo ya que estamos haciendo next in, next double 00:24:01
pues para ilustrar que también 00:24:04
puedo leer boolean con next boolean 00:24:06
vale 00:24:08
Entonces, esto lo voy a escribir 00:24:09
Yo ahora rápidamente, pero no tienes 00:24:11
Solamente para mostrar que el next boolean 00:24:13
También se puede usar 00:24:15
Y luego ya os ponéis a hacer el 4 00:24:16
Que ya 00:24:19
Incorpora lo que vimos ayer al final de la clase 00:24:19
A ver si os sale 00:24:23
Venga, vámonos al 3 00:24:25
Vamos a, rápidamente 00:24:27
El ejercicio 3 00:24:30
Ejercicio 3, venga 00:24:31
Vale, a ver 00:24:40
este ejercicio dice solamente 00:24:44
leer por teclado 00:24:46
una variable boolean, esto está solo 00:24:48
para que no estemos, para que 00:24:50
veamos que el objeto scanner 00:24:52
este, pues puede leer muchos tipos de datos 00:24:54
solo para eso, pero es una tontería 00:24:56
que lea una variable boolean 00:24:58
que se supone que 00:25:00
representa eso 00:25:02
y luego mostrar 00:25:03
el contenido de esa variable boolean 00:25:05
a continuación de ese texto, entonces 00:25:08
vamos a una variable booleana 00:25:10
y ahora 00:25:12
vale, pues una variable 00:25:13
boolean, ya sabemos que es ese tipo de dato 00:25:20
y ahora 00:25:21
esto tiene que ver, elección de los 00:25:23
nombres, por enésima vez 00:25:26
siempre bien elegidos 00:25:27
entonces este enunciado ya nos dice 00:25:29
esta variable es para decir 00:25:32
si un estudiante ha aprobado o no 00:25:34
bueno, pues acostumbrémonos 00:25:35
a usar nombres de variables 00:25:38
explicativas asociadas 00:25:40
a lo que significan, entonces una variable boolean 00:25:42
es en casi la que más 00:25:44
importa que el nombre 00:25:46
esté bien explicado. Porque una variable 00:25:48
boolean expresa una condición, expresa si algo 00:25:50
se cumple o no. Entonces, es casi más 00:25:52
importante una variable boolean que su 00:25:54
nombre esté bien elegido. Venga, pues 00:25:56
en este caso, boolean, aprobado. Es el nombre 00:25:58
que le vamos a dar a la variable. 00:26:00
Aprobado, que puede ser 00:26:03
true o false. 00:26:04
¿Vale? 00:26:06
Vale. Bueno, pues entonces, 00:26:07
ahora esta variable no está 00:26:10
por definir. 00:26:12
Está para guardar o 00:26:14
true o false, pero también no tiene 00:26:16
valor, hay que dárselo, bueno pues la aplicación 00:26:18
dice que se lo des por teclado 00:26:20
pues otra vez 00:26:22
del escáner, porque desde el momento que metemos 00:26:24
algo por teclado, ahora mismo nosotros 00:26:26
usamos el escáner, pues usemos el escáner 00:26:28
pues venga, creo que ya había 00:26:30
hecho un copia y pega antes, pues no era 00:26:32
de esto, vale 00:26:34
copiamos y pegamos el escáner 00:26:35
porque vamos a leer por teclado 00:26:42
yo el escáner 00:26:44
lo suelo crear fuera con 00:26:48
con un private static 00:26:50
escáner, lo creo, fuera del main 00:26:52
vale, pero yo todavía no lo menciono así 00:26:53
porque claro, eso tiene que ver con 00:26:56
bueno, hay muchas cosas que 00:26:57
¿por qué pones private? ¿por qué pones static? 00:26:59
para entenderlo habría que explicar un montón de cosas 00:27:01
entonces, lo ponemos dentro todo ahora mismo 00:27:04
todo dentro del main 00:27:06
y ya está, ¿vale? 00:27:06
venga, pues entonces dice 00:27:10
la información de esta variable la lees por 00:27:11
¿qué? 00:27:14
el escáner va arriba 00:27:17
¿cómo que el escáner va arriba? 00:27:18
Pero no entiendo, ¿qué me querías decir? 00:27:24
Lo mismo que te dije yo, que lo hacen en la vista 00:27:25
y que lo pongan fuera. 00:27:27
Yo ahora mismo prefiero que lo pongan... 00:27:29
A ver, hacedlo como queráis, pero yo prefiero que lo pongáis 00:27:31
dentro, porque de ponerlo fuera 00:27:33
adentro hay implicaciones que no 00:27:35
podemos entender cuáles serían. 00:27:37
Ahora mismo no afecta para lo que estamos haciendo. 00:27:39
Pero yo ahora mismo, 00:27:42
de cara a ir 00:27:43
incorporando los conocimientos por fases, 00:27:44
lo pongo dentro y no hago ninguna 00:27:47
referencia a la diferencia que hay de ponerlo dentro y fuera. 00:27:49
Si lo ponéis fuera vosotros, vale, 00:27:52
pero no penséis en nada relacionado 00:27:53
a por qué lo pongo fuera 00:27:56
eso ya cuando ya lleguemos 00:27:57
vale 00:27:58
pero eso sí, como os pase algo por ponerlo fuera 00:27:58
me diréis 00:28:03
vale 00:28:04
entonces 00:28:06
el programa me dice, oye tienes que leerlo por teclado 00:28:09
vale, pues venga 00:28:12
vamos a leer por teclado aprobado 00:28:13
es decir, la asignación va a ser leída 00:28:15
por teclado 00:28:17
el objeto lector es capaz de leer 00:28:18
un boolean por teclado 00:28:21
Igual que está capaz de leer un int y un double 00:28:23
Pues sí, porque si yo cotilleo 00:28:25
Los métodos, veo que tiene un next boolean 00:28:27
Veo que tiene un next boolean 00:28:29
Lo tiene 00:28:31
Entonces es capaz 00:28:32
Claro, aquí la pregunta es 00:28:34
¿Y qué tengo que poner yo? 00:28:36
Aquí 00:28:38
Pues vamos ahora cuando hagamos las pruebas 00:28:38
Bueno, una TED 00:28:43
Lo has deducido tú 00:28:46
O sea, lo has 00:28:48
Vale 00:28:49
Vamos a poner un mensajito 00:28:51
Para que al menos no se quede ahí tonto 00:28:55
Introduzca 00:28:56
Voy a poner Boolean 00:29:00
Para que se quede ahí abierto 00:29:00
Introduzca Boolean 00:29:02
Y ahora 00:29:04
El programa dice que 00:29:06
Mostremos 00:29:08
El estudiante ha aprobado una interrogación 00:29:09
Y luego ya el resultado del Boolean 00:29:12
Pues venga, entonces este programa termina así 00:29:14
¿Dónde estoy? 00:29:20
el estudiante 00:29:22
alumno, lo que sea 00:29:28
ha aprobado 00:29:30
y luego dice que 00:29:32
concatene directamente 00:29:33
con true o false 00:29:36
lo que es lo mismo, con el resultado de la variable 00:29:37
¿no? 00:29:40
¿está claro? 00:29:43
esta sentencia de aquí 00:29:44
esta sentencia es concatenación 00:29:45
de toda esta cadena 00:29:48
de texto con lo que contenga aprobado 00:29:50
aprobado que va a contener, true o false 00:29:52
con lo cual o me va a mostrar 00:29:55
al estudiante aprobado 00:29:56
true o el estudiante 00:29:59
aprobado false, eso es lo que sé que me va a mostrar 00:30:00
porque aprobado solo tiene o true o false 00:30:03
luego este código 00:30:05
no tiene nada 00:30:08
raro, la única 00:30:10
gran duda que nos surge es 00:30:12
como le meto yo el boolean 00:30:14
vale, vamos a hacer pruebas 00:30:16
el código compila y tiene sentido 00:30:18
introduzco un boolean, lo meto 00:30:20
con next boolean, lo guardo aquí 00:30:22
y luego el estudiante ha aprobado, lo concateno con lo que 00:30:24
tenga aprobado que será o true o false 00:30:26
no puede tener otras cosas que eso 00:30:28
vale, vamos a 00:30:29
hacer la primera 00:30:32
prueba de este código 00:30:34
introduzca boolean 00:30:36
si le metemos 00:30:42
true directamente, lo entenderá 00:30:44
como el boolean true 00:30:46
pues sí, tiene la pinta de que sí 00:30:47
vamos a volver a ejecutar 00:30:50
introduzca boolean, si le pongo 00:30:51
falso, ¿él lo va a interpretar como el boolean 00:30:54
falso y asignarlo a aprobado? 00:30:56
Pues sí. 00:30:59
Luego, para meter directamente a un 00:31:00
boolean el valor true, tecleo true. 00:31:02
Ya está. Para meter directamente 00:31:04
a un boolean el valor falso, tecleo falso. 00:31:06
Y si le meto 00:31:09
una T, que es algo que tú te has 00:31:10
sacado de la manga así por las buenas. 00:31:12
No, 00:31:15
la T no le sirve para nada. Dice que es 00:31:16
T. El T 00:31:18
no tiene nada que ver con un valor boolean. 00:31:20
¿Vale? 00:31:22
Vamos a probar otra cosa. Y si yo le pongo esto, tampoco. Porque uno podría haber pensado, oye, pero 6 mayor que 4 es una expresión que yo puedo evaluar como un Boolean. Ya, pero eso Java. Eso Java. Esto no es código Java. Esto es lo que yo meto por consola. ¿Vale? ¿Veis? 00:31:23
es decir 00:31:54
yo aquí a esta expresión 00:31:55
le podría poner 00:31:58
le podría poner esto 00:32:00
y esto es válido porque esto es una expresión 00:32:07
java que se evalúa como 00:32:10
true y aprobado 00:32:12
sería true, le puedo poner 00:32:14
esto, pero eso no significa 00:32:16
que cuando yo 00:32:18
meta el valor del boolean a través del 00:32:20
next boolean, aquí puedo poner una expresión java 00:32:22
porque esto no es java, esto es lo que 00:32:24
yo meto a través de la consola 00:32:26
y para que 00:32:28
yo he hecho de otra forma 00:32:30
si, si, si, dime 00:32:31
he puesto primero un double 00:32:35
y luego lo he asignado al Boolean 00:32:36
si es mayor que 5 00:32:39
y luego ya he mostrado el Boolean 00:32:41
y he puesto en la condición del free 00:32:45
que si es true 00:32:47
o si ha probado 00:32:49
si es false, es true 00:32:50
si, eso está bien hecho 00:32:51
pero lo que pasa es que has hecho otro programa 00:32:54
el que 00:32:56
O sea, como te decía, leer por teclado una variable Boolean. 00:32:58
Tú has leído por teclado la nota, 00:33:01
que es otra forma de hacerlo más intuitiva. 00:33:03
Lo que pasa es que este enunciado estaba así para 00:33:06
ejemplificar el Next Boolean, para que no nos asuste que el 00:33:09
Next Boolean existe. 00:33:12
Entonces, leer el teclado la variable Boolean, ¿vale? 00:33:13
Vale, entonces, ¿qué quiero decir con esto? 00:33:21
Que no confundáis lo que uno mete por la consola con código 00:33:23
Java. 00:33:29
lo que uno mete por la consola 00:33:29
se lo traga este de aquí 00:33:31
y eso no es código Java, es una cadena 00:33:33
de texto y luego ya hará con él lo que tenga que hacer 00:33:35
es como cuando liamos con NextDouble 00:33:37
cuando liamos con NextDouble tenemos que 00:33:39
poner 3,9 00:33:41
3,9 no es Java, pero es lo que 00:33:43
NextDouble necesita para luego convertirlo 00:33:45
a 3.97, ¿vale? 00:33:47
bueno 00:33:51
entonces en este caso 00:33:51
pues este código ya tendría un poco más sentido 00:33:54
si le decimos 00:33:56
así al tío, introduzca si ha aprobado 00:33:59
true 00:34:01
o no 00:34:02
y así le damos al tío 00:34:04
un poquito más de indicaciones 00:34:07
y ahora ya este programa, pues bueno, ya tiene más sentido 00:34:08
lo ejecutamos 00:34:12
introduzca si ha aprobado 00:34:16
o no, venga, ha aprobado 00:34:19
true, el estudiante 00:34:21
ha aprobado, vale, pues bueno, es para 00:34:23
trabajar con Boolean en la consola, que no nos 00:34:25
suenen 00:34:27
raros, vale 00:34:29
Pues ahora sí 00:34:32
Ahora, saltamos al 4 00:34:33
Ahora ya 00:34:36
Leemos una variable entera 00:34:38
Que representa una edad 00:34:40
Y ahora 00:34:42
Ahora el resultado es 00:34:44
Eres mayor de edad 00:34:46
Y luego tiene que aparecer 00:34:50
True o false 00:34:51
¿Qué tendrá que aparecer? 00:34:53
Depende del dato de entrada 00:34:55
True, si el dato de entrada era mayor de 18 00:34:56
Mayor o igual 00:35:00
O false si no 00:35:01
Entonces esto ya involucra 00:35:01
Lo que vimos ayer 00:35:04
Descanso por favor 00:35:07
Pero tú no estás hablando 00:35:14
Tú estás ahí sentado 00:35:16
¿Quién es el que está tan cansado? 00:35:18
Tú has sido 00:35:21
El de descanso por favor, ¿quién ha sido? 00:35:22
No, no, yo, yo 00:35:24
Pues no tienes motivos para estar cansado 00:35:25
Todavía yo que estoy hablando 00:35:27
Sí, vamos a parar ahora 00:35:29
De verdad 00:35:32
no me seáis niñas de un añito 00:35:33
vale 00:35:35
pues 00:35:37
este cuarto ejercicio 00:35:38
ya tiene que ver 00:35:41
con esto último 00:35:42
que dijimos ayer 00:35:45
con esto último 00:35:48
y ahora aquí ya sí que paramos 00:35:49
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
9
Fecha:
24 de septiembre de 2024 - 18:30
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
35′ 53″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
150.86 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid