2024-11-25-Programacion | Mediateca de EducaMadrid

Y para empezar, como habitualmente, pues preguntaros si tenéis alguna duda por ahí que queráis que comentemos antes de nada. 00:00:01

Relación al módulo. 00:00:10

Si no tenéis nada así en particular, bueno, pues había pensado, lo que vengo haciendo estos años anteriores es el primer día después de cerrar un tema, 00:00:16

pues repasar un poco para cerrar el tema, la tarea, hacerla aquí en conjunto. 00:00:26

de forma, bueno, pues en la tarea 00:00:31

para compartirla con vosotros y que os quede grabada 00:00:34

como lo vamos haciendo poco a poco 00:00:36

y luego pues empezamos 00:00:37

a comentar algunas cosas por ahí del tema 4 00:00:40

¿Os parece? ¿Tenéis alguna cosita 00:00:42

por ahí 00:00:46

que queréis que veamos? 00:00:46

Bueno, pues hacemos este plan 00:00:49

entonces. Bueno, mirad por aquí 00:00:52

vamos a ver 00:00:57

el enunciado de la tarea 00:00:59

por aquí lo tenemos, independientemente de que 00:01:01

la resolvamos ahora, sabéis que la tenemos, he abierto 00:01:11

una solución ahí en el aula virtual y bueno, ya corregida con 00:01:15

comentario la tenéis todos los que me habéis entregado. Me ha llamado la atención 00:01:18

una cosa que os he puesto de comentario a algunos, que no es que esté mal 00:01:25

ni mucho menos, pero habéis utilizado bastante los 00:01:29

bucles con el while true y luego utilizando una instrucción 00:01:33

que hace un break, o sea una rotura del bucle 00:01:38

dentro de 00:01:41

dentro del código 00:01:43

del propio bucle 00:01:46

lo pongo por aquí 00:01:47

en el código 00:01:48

vamos a crear el proyecto 00:01:50

vamos a crear el método public 00:01:55

el método main 00:02:10

mirad en la tarea esta 00:02:11

ahora lo hemos anunciado 00:02:23

tiene que se esté realizando una 00:02:24

acción, ir cogiendo información 00:02:26

las opciones de menú 00:02:28

por teclado hasta que introduzcamos 00:02:30

lo que es salir o fin, entonces hacemos 00:02:32

un bucle hasta que lo introducido sea salir o fin 00:02:36

parece que la lógica a la que nos empuja un poco 00:02:39

el enunciado es a pensar en que en el while 00:02:44

en el do while aquí, que al final es donde metemos la condición 00:02:47

de finalización del bucle, pues ponemos realmente 00:02:52

la que nos dice el enunciado, hasta que lo leído sea fin o 00:02:56

o salir. Imaginaos que tenemos un código 00:03:00

muy grande, que no está todo a la vista, como 00:03:04

este que es así muy sencillo. También es cierto que se sugiere 00:03:08

cuando los códigos son muy grandes se partan en funciones o métodos 00:03:12

que hablaremos de ellos en esta tutoría o en las siguientes. 00:03:16

Pero bueno, imaginaos que por lo que sea nos ha quedado un código aquí muy grande. 00:03:21

Entonces, si tú ves aquí un while, esperas que 00:03:24

es lo que pasa dentro de este wild se ejecute mientras suceda esto no con un wild true que 00:03:28

se ejecute siempre y luego en alguna zona de código por ahí con una instrucción break rompo 00:03:34

la ejecución del bucle está esta o sea java funciona así si dentro de un vuelto encuentras 00:03:41

un dentro una instrucción de control de repetición tú encuentras una instrucción break te va a sacar 00:03:47

del bucle, es cierto, y funciona 00:03:53

y los que lo tenéis así 00:03:55

el programa da los resultados 00:03:56

esperados 00:03:59

pero simplemente por, bueno, pues un poco 00:04:00

por lógica, por facilidad, luego de mantenimiento 00:04:03

por todo un poco 00:04:05

yo creo que cuando está bien definida 00:04:07

la condición que nos saca del bucle 00:04:09

es mejor ponerla aquí, más que poner 00:04:10

un while true y luego una instrucción 00:04:13

break 00:04:15

además, bueno, pues 00:04:15

la tendencia de siempre, aunque 00:04:20

hoy en día, por ejemplo, la inteligencia 00:04:22

artificial da mucho este tipo de soluciones 00:04:24

también 00:04:26

lo que siempre 00:04:27

se ha venido a decir de las instrucciones break 00:04:30

es que se intenten evitar 00:04:32

siempre que sea posible, por ejemplo 00:04:34

en el switch, la instrucción 00:04:36

switch de selección que 00:04:38

estuvimos viendo la semana pasada 00:04:40

en la clásica, donde 00:04:41

se ponen 00:04:44

las condiciones con dos puntos 00:04:46

a partir de cierta 00:04:48

versión del 00:04:50

jdk que ya permite hacerlo con con el símbolo este verdad de flecha excepto en este caso que 00:04:52

no son auto excluyente las opciones sí que se recomienda poner un break porque si es que 00:05:02

quieres que convertir cada una de las de las opciones del switch cada uno de los keys en auto 00:05:07

excluyente pues tienes que meter un break pero luego en líneas generales siempre se ha recomendado 00:05:13

e intentar evitar los break y por qué se intentan evitar evitar los break pues fijaros aquí en una 00:05:18

instrucción while si es muy fácil hacer un mantenimiento y entender bien el código si la 00:05:25

condición por la que nos salimos del whale está aquí definida nos salimos cuando esto luego ya 00:05:31

miraremos a ver qué pasa por aquí en el código que tenemos que hacer que algoritmo implementa 00:05:36

pero este bucle se sale aquí si te pones aquí un while true resulta que aquí puedes empezar a 00:05:40

tener códigos con if, con switch, mucho código diferente 00:05:46

y puedes meter 10 breaks. Y en cada 00:05:50

break puede tener una condición por ahí diferente, no ser exactamente 00:05:54

la misma. Entonces, en una ejecución de programa se saldrá de aquí 00:05:58

porque ha encontrado un break, pero ¿qué break será el que ha encontrado y el que provoca que 00:06:02

se esté marchando? Entonces, este tipo de instrucciones siempre 00:06:06

las desaconsejan dentro de lo posible y bueno, pues yo 00:06:10

un poco en esa línea pues intento evitar hacer 00:06:14

wild true. Igual en algún momento hago alguno 00:06:16

y en la asignatura de programación de servicios 00:06:19

y procesos que hay en segundo 00:06:22

hay ciertos momentos en los que viene muy bien utilizar 00:06:24

el wild true y sí que se utiliza porque 00:06:28

la condición de salirse es un poco ajena 00:06:31

al código que pongamos de aquí sino que realmente 00:06:35

la salida de este bucle en ese contexto 00:06:37

que os comento viene por cosas que pasan en otras 00:06:40

aplicaciones entonces como pasa en otras aplicaciones es bueno pues como no lo 00:06:43

puedo tener tan controlado aquí a lo mejor sí que una vez que sea una 00:06:48

condición de esas en otra aplicación sí que meto aquí un break pero siempre y 00:06:51

cuando sea posible bueno pues mejor evitarlo 00:06:56

y luego otra cosa así en grandes rasgos que os ha pasado a algunos es algo que 00:06:59

hemos comentado ya en otras prácticas que tiene que ver con la lectura con 00:07:05

Scanner. Bueno, recordad aquí la clase Scanner está, como no está en Java Lange, hay que importarla 00:07:10

al estar en Java útil, ya queda integrada en mi proyecto a través de meter la instrucción 00:07:25

importa aquí de esa clase y ya podemos instanciar objetos de esa clase. Entonces, esto lo que nos 00:07:31

permite es, bueno, trabajar de una forma razonablemente cómoda con flujos de datos, entendiendo 00:07:37

flujos de datos, como hemos dicho otras veces, mecanismos con los que conectamos nuestra aplicación 00:07:43

a elementos externos, bien sea fichero, bien sea 00:07:48

un flujo de datos al teclado o si es de salida a la pantalla o sockets 00:07:52

y utilizando SystemIn, justo este flujo de datos 00:07:57

por defecto se establece en todo programa con el teclado 00:08:00

utilizando el flujo de datos SystemIn lo encasulamos para trabajar con un objeto 00:08:03

de la clase Scanner. Los flujos de datos, una cosa 00:08:08

que es aconsejable, bueno muchos lo habéis hecho, es cuando voy a dejar 00:08:13

de usarlos, cerrarlos, para que no me queden en la ejecución del programa 00:08:16

flujos de datos abiertos. Entonces, por ejemplo, a través 00:08:20

de la clase Scanner podemos utilizar el método Close, con lo cual 00:08:24

si hemos establecido aquí una conexión con el teclado 00:08:28

podemos entenderlo como una tubería que está pinchada 00:08:32

en un lado en nuestro programa y en el otro en el teclado, pues aquí ya liberamos 00:08:36

la tubería. ¿Qué pasa en nuestro programa? Pues que 00:08:40

se está ejecutando un main, necesitamos esa conexión al teclado 00:08:44

todo el rato, con lo cual hasta el final no lo podemos cerrar y realmente el único sitio 00:08:48

donde podemos terminar cerrando este flujo de datos es cuando acaba el main 00:08:52

cuando acaba el main acaba el programa en verdad, con lo cual si no 00:08:56

lo cerramos, si no ponemos esta instrucción, el hecho de acabar el programa lo va a cerrar 00:09:00

él, con lo cual no tiene grandes consecuencias ponerlo o no ponerlo 00:09:04

no me va a dejar el ordenador en sí con recursos 00:09:09

hay enganchados por no cerrarlo. 00:09:13

Pero 00:09:16

este programa es así, pero otro programa 00:09:16

podría ser que después de esto, aquí 00:09:19

siguiera haciendo un montón de cosas. 00:09:20

Incluso ser un programa de 00:09:23

trabajar 24-7, que estuviera 00:09:24

siempre arrancado. Entonces, si aquí 00:09:26

he dejado enganchado un 00:09:29

recurso, pues igual no 00:09:31

es interesante, pues ya está. 00:09:32

Cogemos la costumbre de cerrarlo 00:09:34

y listo. ¿El programa no se va a funcionar 00:09:36

aunque no cerremos la tarea que hemos 00:09:38

hecho? Sí. En este caso se va 00:09:40

a liberar, sí, porque termina el programa, pero como 00:09:42

cosa habitual, pues mucho mejor que cuando abramos un flujo 00:09:45

de datos, sea a System.in o a quien sea, terminamos 00:09:50

cerrándolo. Y además de eso, bueno, pues 00:09:54

si nosotros, acordaros que a través de mi scan, pues nos ofrece 00:09:59

un montón de métodos por aquí. Están los 00:10:04

métodos hash, hashness line, hashness by, hashness 00:10:08

lo que sea, que nos indica, devuelve un boolean y nos indica 00:10:12

si hay algo que leer, bueno, tiene más métodos por ahí, pero bueno, están los 00:10:17

has, algo, y luego están los nest, que son los que 00:10:21

hacen la lectura en sí. Entonces, este ejercicio, 00:10:24

como era una calculadora, había momentos en los que nos pedía 00:10:29

cargar valores numéricos o float, entonces tenemos 00:10:32

el nest int o el nest float, bueno, pues 00:10:37

para leer valores que tengan 00:10:40

o nest double para valores que tengan comas 00:10:43

o los que no los tengan. 00:10:46

Estos valores son perfectos para leer esta información. 00:10:49

De hecho, vamos a poner aquí un system.out.println 00:10:54

mete un entero 00:11:03

y valor. 00:11:07

Entonces, bueno, pues imaginaos que tenemos esto 00:11:22

y luego mete un entero 00:11:24

y a continuación tu nombre. Vamos a poner 00:11:27

este supuesto ejercicio. Queremos meter un entero y luego una cadena de caracteres 00:11:32

que sea el nombre. Entonces si nosotros cogemos y hacemos esto, string 00:11:36

ese valor igual a mi scan. 00:11:40

nestLine y la cojo y pongo aquí 00:11:48

system.out.println 00:11:52

el entero ha sido, meto el valor del entero y valor 00:11:55

y luego pongo el nombre 00:12:06

ha sido ese valor 00:12:12

y luego pongo aquí por ejemplo un system.out.println 00:12:19

saliendo del programa 00:12:25

vale, pues aquí estamos esperando 00:12:31

yo creo que si lo pongo aquí 00:12:34

me va a valer igualmente 00:12:39

no, bueno, a ver, aquí lo dejo 00:12:43

Vale, pues aquí se supone que vamos a meter un entero, un 20 y luego después vamos a meter el nombre. 00:12:46

Entonces si ejecutamos esto y ponemos, bueno mete un entero y el nombre, meto el 5, le doy enter, pues fijaros como el programa termina. 00:12:54

¿Qué es lo que ha sucedido? Que NSYNC coge un entero, pero no coge el enter que he utilizado yo cuando he puesto el 5 y el enter. 00:13:05

Entonces, el siguiente Enter lo está cogiendo con el Slime, es decir, aquí en esta instrucción ha cogido 5 y en esta otra instrucción ha cogido el Enter que he pulsado yo para confirmar este 5 por teclado. 00:13:13

Con lo cual, en el S-Valor se ha cargado el Enter, es decir, el Enter nada, o sea, hace como si no escribiera nada un Enter y en I-Valor se ha cargado el 5, que son los datos que efectivamente estos dos System of Println me están mostrando aquí. 00:13:29

leer de esta forma nos puede provocar estos errores. Entonces, ¿cómo es 00:13:42

cómo lo podemos manejar? Pues, sabiendo que la lectura 00:13:48

de valores numéricos nos pueden provocar esta situación, 00:13:52

pues, lo que habéis hecho algunos, que es correcto, es limpiar el buffer. 00:13:56

Limpiar del buffer 00:14:02

de lectura el Enter 00:14:04

a sabiendas de que esta lectura 00:14:08

no me va a leer no va a cargar el ente de mi valor porque solamente va a cargar el valor numérico y 00:14:12

luego pues bueno pues habéis hecho otro next line para lo que es la lectura del del valor del nombre 00:14:17

fijarse después de esta lectura que está limpiando ese ente del entero cogemos y hacemos así 5 enter 00:14:31

fijaros como todavía sigue pidiendo datos porque el 5 se ha cargado aquí este ente del 5 se ha 00:14:38

cargado aquí y ahora se me ha quedado aquí y ahora pongo aquí jose y ya veis ahora ya funcionaría 00:14:44

bien el programa después de esta lectura es decir hacemos una lectura de un slime para quitar de 00:14:50

en medio el enter y en realidad no lo utilizamos para nada lo podríamos hacer sin cargarlo en 00:14:54

ningún sitio quitando así es decir lo leo pero no lo cargo hacia la izquierda en ningún sitio 00:14:59

simplemente limpio el buffer o aquí el 4 si lo tenéis y otra alternativa es hacer la lectura 00:15:05

siempre con slime y haciendo la conversión entonces si yo cogí defino aquí un string ese 00:15:17

info que es la que yo os he comentado que yo hago habitualmente escojo y la información por mucho 00:15:23

que vaya a ser un número la cojo con un slide con lo cual esta información va a el 5 y como 00:15:38

lea hasta que encuentra un nuevo inter también limpia del buffer en el ente entonces lo que se 00:15:48

me carga aquí es el 5 pero está este método next line ya os digo limpia el buffer también ahora 00:15:54

qué pasa que tengo con esta técnica tengo la información en una variable de tipo string y 00:16:08

lo que quiero tenerla es una variable de tipo y valor que podemos hacer pues vamos a buscar 00:16:14

algún método que en este caso los tenemos disponibles en las librerías de java para 00:16:20

convertir un string que tenga en realidad como literal un número a un valor que sea en realidad 00:16:24

numérico para guardar una variable de este tipo lo primero que nos pediría el cuerpo sería poner 00:16:31

un valor aquí punto para decir a ver si me ofrece un método como hacemos siempre con los objetos 00:16:36

pero ya hemos comentado en varias ocasiones que los tipos de datos primitivos no tienen métodos 00:16:41

disponibles tiene la ventaja de no tener que hacer el niño pero no tienen esa estructura de clase que 00:16:47

sí que tienen los tipos referenciados pero como sí que es algo que vamos a necesitar en ocasiones de 00:16:53

hecho ahora mismo no lo está demandando el programa pasar un string a un valor numérico pues lo que 00:17:00

podemos hacer es utilizar las clases Wrapper esta que van de la manita de los tipos de datos 00:17:05

primitivos y lo que hacen es implementar funciones de este tipo. Pues como estamos trabajando con un 00:17:11

valor de tipo entero aquí, pues la clase Wrapper es la integer. Integer punto y al pulsar aquí ya 00:17:17

tenemos el parse int, que lo que recibe es, como fijáis por aquí, nos ofrece la información Eclipse, 00:17:27

recibe como parámetro de entrada un string 00:17:34

que será el número y devuelve un entero 00:17:37

que será el valor numérico del 00:17:40

número en modo literal que tiene el string 00:17:43

que le estamos pasando como parámetro. Efectivamente 00:17:46

Eclipse nos intenta echar una mano y ya dice que 00:17:51

aquí coge el valor de ese valor. Bueno, 00:17:54

en realidad queremos coger el de ese info. 00:17:58

Con lo cual, haciéndolo de esta forma 00:18:01

no tenemos necesidad de hacer 00:18:03

un slide aquí para cargar el para limpiar el buffer porque porque efectivamente ya lo tenemos 00:18:07

limpio y bueno pues nada luego si acaso ya cogeríamos el nombre vamos a poner aquí un 00:18:13

mensajito para que nos resulte más cómodo ahora el nombre y este el nombre pues sí que lo vamos 00:18:21

a cargar utiliza la variable ese valor ese valor por aquí sí que lo utilizamos con un slide que 00:18:37

en este caso no hay que convertir nada porque un nombre como es un literal de carácter es alfa 00:18:46

numérico es por directamente lo cargamos con es line que es lo que nos devuelven es line la 00:18:51

información como literal pues ya damos aquí ejecutar me ponemos el 5 se me ha quedado un 00:18:56

es line por ahí que no sé cuál es ahora mismo bueno se me ha quedado en este mes 00:19:06

vale que no lo había quitado lo quito de aquí hacemos el line para el número y lo pasamos 00:19:16

ahí valor lo medirá esto y ya me llegará el line este entonces estamos aquí ponemos 6 ahora el 00:19:29

nombre jose y también nos funciona ya una precaución hay que tener precaución de no 00:19:37

poner un mes sin un es double uno de estos que cogen números sin limpiar el buffer después con 00:19:43

un slide muchos lo habéis hecho en la tarea algunos no se os ha pasado y os acaba por 00:19:50

ejemplo dos veces la información del menú o bien cogerlo con es line siempre y hacer la 00:19:55

conversión otra otra cosa así que comentaros así en líneas generales y ahora nos ponemos a 00:20:01

resolver la tarea es que si tenemos por aquí un while es que tenemos aquí un while aquí la 00:20:10

condición que sea. Voy a poner true aunque os estoy diciendo que mejor no lo utilicemos pero para que 00:20:21

compile de momento. Luego en el ejercicio no pondremos un while true. Aquí en el ejercicio tenemos una 00:20:28

serie de opciones y en las opciones a lo mejor hay falta definir dos enteros y es la opción de 00:20:36

menú que suma dos enteros entonces tenemos definimos el entero y val 1 y el entero y val 2 00:20:43

imaginaos que este bucle aquí no voy a poner las opciones luego ya en el ejercicio así que las 00:20:54

ponemos imaginaos que lo ejecutamos 100 veces vale pues ya la vez número 100 pondremos la 00:21:03

condición de ruptura del bucle que habremos programado aquí que será diferente del while 00:21:09

true, pues eso habremos pulsado salir para irnos. Pero antes 00:21:13

hemos hecho 100 veces la operación. Entonces, 00:21:17

hablando un poquito de las variables que comentábamos durante este tema, 00:21:22

las variables se definían en un determinado ámbito. Y el ámbito que 00:21:26

tenemos aquí, para estar dos variables, ¿cuál es? Pues en el que 00:21:29

están definidos. Es el ámbito del while. Esta otra variable, 00:21:33

la scanner, está definido en el ámbito, en este caso, 00:21:38

un poquito a nivel superior de donde está definida, pues sería el main. 00:21:41

Esta variable existe en todo momento, mi scan, mientras 00:21:46

estemos ejecutando el método main. Y si tuviésemos aquí una variable 00:21:50

de clase, en este caso de la clase tarea 3, 00:21:54

que fuese int y var, una variable 00:21:58

miembro de la clase var clase, vamos a poner 00:22:03

aquí, es un nombre muy significativo, pero como tampoco 00:22:06

la vamos a utilizar, pues esta estaría definida 00:22:10

al nivel de la clase. Entonces si aparte de tener 00:22:13

un método main aquí, tuviéramos otro, un segundo método 00:22:16

yo que sé, pues si vamos aquí, public 00:22:19

void, el método que llamemos hola por poner 00:22:28

algo. Entonces la variable 00:22:31

y var clase está definido en el ámbito 00:22:39

de la clase, con lo cual podríamos utilizarla tanto dentro del 00:22:42

método main como dentro del método hola. 00:22:45

La variable miScan, como está definida 00:22:48

en el ámbito de la clase main, podemos utilizarla dentro del main, pero no podríamos utilizarla 00:22:51

dentro de la clase hola. Y 00:22:55

estas dos variables están definidas en el ámbito de las llaves que las cierran 00:22:57

de las llaves más cercanas que las están encerrando, es decir, están definidas 00:23:02

en while, con lo cual están disponibles aquí, pero fijaros como si aquí yo 00:23:06

pongo, mirad, aquí no me está compilando ahora porque 00:23:11

con un while true sin ninguna condición break por aquí 00:23:17

este código está muerto, nunca llegaría, entonces se me queja Eclipse 00:23:21

vamos a poner una condición, inum 00:23:25

igual a 4, y vamos a poner que mientras inum 00:23:30

cualquier condición, no vamos a ejecutar el código, mientras inum 00:23:39

sea distinto de 9, por ejemplo, vale, ahora ya esto me compila, como veis 00:23:44

¿por qué? porque ya no es un bucle infinito y el programa entiende que habrá 00:23:48

un momento en el que podría llegar aquí, aunque en realidad no lo iba a hacer 00:23:52

Bueno, lo iba a hacer aquí, por ejemplo, no lo haría nunca, pero ya este nivel no lo mira el compilador. Dice, bueno, inum vale 4, no lo estás cambiando nunca, se va a quedar aquí en un bucle infinito, pero ya no es un while true, el programa quiere pensar que alguna vez terminaría y ya me compila. 00:23:55

Pues si pongo aquí, por ejemplo, ival1 igual a 5, fijaros que en este caso no me compila. ¿Por qué no me compila? Pues porque ival1 está definido en el ámbito del while. 00:24:15

Fuera del ámbito del while, esta variable no existe. Si yo ival1 la definiese aquí, ya me compila. ¿Por qué? Porque ival1 está en el ámbito del main y ya sería una variable disponible 00:24:29

en esta zona de código. Mira, si este programa que ejecutamos 00:24:40

100 veces, ¿cómo tendría su gestión de memoria haciendo 00:24:50

un análisis del programa poquito a poco? Bueno, pues vendría 00:24:54

por aquí, no nos vamos a detener, llegamos al while, entra 00:24:58

a ejecutarse y nada más entrar aquí, necesita dar de alta 00:25:02

una nueva variable. ¿Esta nueva variable qué implicaría? 00:25:06

Pues una nueva variable supone que el programa se va al sistema 00:25:10

operativo y le dice, oye, necesito recursos donde guardar una variable 00:25:13

de tipo entero. En este caso, en el código no hemos puesto el new por ser 00:25:17

un tipo de datos primitivo, pero lógicamente su información se guardará 00:25:21

en algún sitio en la memoria RAM. Y luego llegará aquí y hará lo mismo 00:25:25

para esta otra variable. Dos veces pedirá al sistema operativo 00:25:29

espacio en memoria RAM donde guardar información de un entero. 00:25:33

Llegados aquí, ¿qué es lo que sucede? Pues que estas variables 00:25:38

dejan de existir y ya no están disponibles en el programa. 00:25:41

El recolector de basura por detrás, que es un programa que va liberando 00:25:46

memoria RAM de aquellas variables y objetos que han dejado de utilizarse, 00:25:50

habrá un momento en el que liberará la memoria RAM y la pondrá a disposición 00:25:54

del sistema operativo de nuevo para que sea utilizada bien por nuestro programa 00:25:57

o por otras aplicaciones que puedan estar corriendo en el ordenador. 00:26:01

¿Pero qué pasa en la siguiente iteración de este bucle? 00:26:04

Pues que lo primero que se encuentra es una variable local a este ámbito, 00:26:07

Entonces cogerá y le pedirá al sistema operativo espacio de memoria para reservar, para poder guardar su información. Igualmente de este. Pues coge aquí, llega y de nuevo queda fuera del ámbito de estas dos variables, recolector de basura, limpieza. 00:26:10

Tercera pasada, la misma jugada, sistema operativo, sistema operativo, sistema operativo, recolector de basura, recolector de basura, recolector de basura. 00:26:26

Entonces esta definición de estas variables aquí, incluso aunque no vayamos a utilizarlas por aquí, igual nos podría llegar a interesar definirlas aquí. 00:26:36

Pues tiene su matiz. Es verdad que es un programa que no consume muchos recursos de procesamiento, pero si queremos buscar que nuestro programa sea óptimo en cuanto al tiempo de ejecución, si la definimos aquí, ya tenemos las variables y aunque des aquí 100.000 vueltas o las que sean 100.000 o 1.000.000 o 10.000.000 de vueltas, no estamos pidiendo al sistema operativo un millón de veces que nos haga la reserva de memoria y aquí que el recolector de basura lo libere. 00:26:45

¿Por qué? Porque según se lo encuentra aquí, nos cogerá ese espacio de memoria y luego por aquí cogerá y ya no volverá a utilizarlo. 00:27:13

Bueno, al final son elecciones de compromiso, porque imaginaos que este bucle se ejecuta dos veces, por lo que sea, solo dos veces. 00:27:23

Pues a lo mejor podría llegar a interesar ponerlo aquí para que después de esa segunda vez estas variables no estén ocupando nunca más memoria RAM que ponerlo aquí y si luego el programa aquí tiene mucho que hacer, dejar el espacio de estas dos variables en memoria RAM ocupadas para siempre porque aquí siguen estando disponibles al pertenecer al ámbito del main. 00:27:33

O sea, que no necesariamente siempre, siempre, siempre tiene por qué ser mejor definirlas aquí, pero bueno, pues como todo en esta vida, pues tiene sus ventajas y sus desventajas. 00:28:02

Aquí ganamos en cuanto a rendimiento porque no estamos molestando al sistema operativo continuamente en cada iteración y luego al recolector de basura a la hora de liberarlo. 00:28:13

solamente lo hacemos una vez, pero sí que es cierto 00:28:23

que si esto tiene muy pocas iteraciones o igual 00:28:26

ninguna, imaginaos que la primera vez ya no se cumple 00:28:29

este while, pues sí que hemos dejado aquí bloqueado 00:28:33

espacio de memoria RAM para estar dos variables 00:28:36

todo el tiempo que se esté ejecutando el main por aquí 00:28:39

porque su ámbito de actuación es ahora 00:28:42

estas llaves, cuando ya no 00:28:45

van a ser utilizadas y simplemente son variables 00:28:48

para trabajar dentro del while 00:28:50

bueno, pues que tengáis un poco 00:28:52

en consideración esa diferencia, ¿no? 00:28:55

que podríamos pensar en ella 00:28:58

si no se entienden cosas, me vais avisando, ¿vale? 00:29:00

entonces, mira, vamos a ver el ejercicio entonces 00:29:11

pues bueno, el ejercicio está construido aparte 00:29:13

sí, bueno, alguien me quería hacer una pregunta 00:29:16

por ahí, pues dime, no digo tu nombre para que no quede grabado 00:29:20

en la grabación 00:29:23

ah, vale, bien, nada 00:29:24

ha sido un error por nada perfecto pues ahora pues seguimos entonces bueno el programa entonces 00:29:32

que es que es lo que lo que pretende pues quiere quiere hacer un bucle en principio hasta que 00:29:40

pulsemos esto entonces tendremos una opción que elegir durante el bucle queremos cogiendo por 00:29:47

teclado el programa nos va a mostrar algo así es un menú de este tipo vamos a ir programando 00:29:52

mirad como el menú 00:30:01

la opción que tenemos, si utilizamos un bucle while 00:30:04

pues podemos sacar una primera vez el menú 00:30:09

y luego tener un while, o podríamos hacer un do while 00:30:13

y directamente ponerlo ya la primera vez 00:30:16

que sabemos que tiene una primera ejecución 00:30:19

aquí podemos coger y decir 00:30:22

vamos a escribir el menú 00:30:24

system.out.println 00:30:26

programa matemático 00:30:32

tenemos las secuencias de escape 00:30:38

con el barra T 00:30:51

nos muestra una tabulación 00:30:53

y luego dice pulsa 00:30:54

cualquier 00:30:57

combinación de 00:30:59

salir o 00:31:02

fin para terminar 00:31:04

a ver que nos va diciendo por ahí 00:31:06

lo hacemos rápido esta parte 00:31:12

S para sumar dos números reales 00:31:14

R para restar dos enteros 00:31:17

dos números enteros 00:31:18

M para ver el máximo 00:31:43

de tres números, p para si par o impar, p para indicar si es par o impar, vale, pues nada, entonces luego nos dice aquí, aquí tenemos, no sé qué he hecho aquí, que he dejado de compilarme, vale, he quitado la t, barra t por aquí, opción deseada, dos puntos y este le voy a poner un system out print para que se me quede ahí el cursor y 00:31:49

a poner un barra n aquí para que me incluya una nueva entrada vamos a darle a ver si me muestra 00:33:07

bien el menú bueno más o menos no tiene mala pinta voy a meter aquí otro barra n mirad este 00:33:13

este bloque lo voy a poner aquí una vez y luego dentro del while lo voy a poner una segunda vez 00:33:20

entonces como lo voy a poner dos veces pues vamos a podemos crear una opción aprovechando que ya 00:33:26

estamos en el tema 4 que sea una opción menú entonces para que haga esto se lo puedo poner 00:33:33

aquí y ahora para que me ejecute desde el main la opción menú se la puedo poner aquí puedo hacer 00:33:44

una llamada mirad porque no me compila ahora pues hace esto este tiempo atrás en alguna tutoría os 00:33:52

he hablado de variables y métodos de tipo static cuando algo es static resulta que se puede llamar 00:34:03

sin haber instanciado sin haber definido ningún objeto de esa clase aquí tenemos la clase tarea 00:34:11

que tiene un método por aquí entonces si yo cojo y pongo aquí intento utilizar el método un método 00:34:16

un parámetro y bar clase igual a 3 resulta que este y bar clase no me funciona a pesar de que 00:34:26

sí que es un método un parámetro definido para la clase tarea y está definido en su ámbito porque no 00:34:36

funciona porque el método main es estático y es común a todos los posibles objetos que tenga la 00:34:44

clase tarea. Si yo tuviera aquí un objeto, defino un objeto tarea 3, mi objeto 1 igual a new, tarea 3, constructor y 00:34:51

defino otro, mi objeto 2, resulta que cada uno de estos objetos tendrá una variable de este tipo. 00:35:06

Imaginaos que esto es la clase Persona y esta es la edad. 00:35:19

Pues al instanciar dos objetos estaríamos instanciando dos personas, 00:35:24

estaríamos dando de alta dos personas en nuestro programa 00:35:27

y cada uno de ellos tendría su variable de edad. 00:35:29

Entonces, ¿qué es lo que sucede aquí? 00:35:33

Que en este método que es estático, que es común a todos los objetos de la clase, 00:35:35

resulta que estoy intentando utilizar esta variable y el programa se pregunta 00:35:41

vale, si este método que se puede ejecutar para todos los objetos 00:35:45

no tiene cada objeto de la clase tarea 3 un método main 00:35:49

resulta que se está ejecutando y me dicen que ibarclase 00:35:52

vale 3, será el ibarclase de mi objeto 1, de mi objeto 2 00:35:57

de otro objeto que defina luego después, de cual de ellos 00:36:02

si yo pongo aquí que es de mi objeto 1 00:36:05

ahora ya me compila, ahora ya no hay lugar a dudas 00:36:09

Este ibarClase, que es una variable definida en la clase, queremos poner el valor 3, pero no para el objeto 2, sino para el objeto 1, para ningún otro. 00:36:13

Si no lo pongo aquí, esta variable podría ser para cualquiera de los dos objetos y como hay una ambigüedad ahí, el programa directamente no me lo permite. 00:36:24

Mirad, cuando nosotros ponemos aquí, por ejemplo, el método integer, 00:36:39

ponemos integer punto, resulta que integer es una clase definida en las librerías de Java. 00:36:43

Y lo que vamos a definir aquí, por ejemplo, antes hemos dicho el método parseInt. 00:36:50

El método parseInt lo estamos utilizando, antes lo hemos utilizado, 00:36:54

ahora lo podríamos utilizar de igual forma, lo estamos utilizando 00:37:00

sin definir ningún objeto de la clase integer. 00:37:03

¿Pero por qué me compila y me funciona parseInt? 00:37:09

Porque es un método que está definido de forma estática. 00:37:11

Es común a todos los posibles objetos que tuviéramos de la clase Integer. 00:37:14

Pues igual que pasa esto con los métodos, resulta que, 00:37:21

igual con esto que acabamos de ver, para ir a clase, 00:37:24

es lo que nos está sucediendo aquí. 00:37:27

Por eso nos compila menú ahora mismo cuando lo hemos puesto aquí. 00:37:28

El método menú está definido dentro de la clase, 00:37:32

con lo cual estaría disponible para main, 00:37:35

pero resulta que menú no es un método estático es decir cada objeto nuevo que definamos tendría 00:37:37

su propio método menú entonces si yo pongo aquí que quiero ejecutar desde algo que es estático 00:37:45

que es común a todos los objetos el método menú le vuelve a surgir la misma dura duda y cuando hemos 00:37:51

utilizado antes el para ver el atributo y bar clase me dirá si tú quieres ejecutar menú pero 00:37:57

el menú del objeto 1 o del objeto 2. 00:38:05

¿Cómo podríamos solucionar esto? 00:38:08

Pues si tenemos definido un objeto, pondríamos esto 00:38:10

y ahora ya me compila porque ya no habría lugar a dudas 00:38:12

que el menú, este método disponible dentro de la clase, 00:38:16

el menú, este método, lo queremos ejecutar para el objeto 1, 00:38:21

sería una de las posibilidades, 00:38:25

o si lo queremos mantener así, 00:38:28

tendríamos que definir el método menú también como estático. 00:38:30

static, entonces en este caso ya me compila, desde un sitio que es 00:38:33

común para todos los objetos de la clase tarea 3 00:38:39

ejecuto algo que también es común para todos los objetos de la clase 3 00:38:42

no hay lugar a dudas que el único método menú definido en la clase 00:38:47

es este y como es el método común para todos los objetos no hay ambigüedades 00:38:51

ya cojo y compilo, bueno si no se entiende muy bien esto del static 00:38:55

decirme seguramente en algún otro momento volveremos a hablar 00:39:04

de ello, en cualquier caso. No nos vale decir 00:39:08

a lo loco me pongo a definir todo estático porque parece que compila todo mejor 00:39:15

porque si esto fuese la clase persona y definimos un atributo, con los atributos 00:39:19

siempre se ve un poco más claro, y definimos un atributo y edad 00:39:23

pues la edad tiene que ser distinta para cada 00:39:27

una de las posibles personas, si esto fuese la clase persona 00:39:31

que definamos, entonces si tenemos la persona 1 tendrá una edad, si tenemos la persona 00:39:34

2 tendrá otra edad. Cada una de ellas necesitará su trocito 00:39:39

de memoria RAM donde guardar su propiedad. No nos valdría 00:39:43

un dato común como este de este tipo. Si fuese un programa 00:39:47

para, o sea, que dependiendo del uso que vaya a tener 00:39:51

el parámetro o el método, podrá ser estático o no. Dentro de 00:39:55

una posible clase persona o alumno que tuviésemos 00:39:59

para nuestra clase, pues igual sí que podríamos poner aquí 00:40:03

un parámetro que fuera string que identificase 00:40:06

el grupo o 00:40:11

el ciclo en este caso y este podríamos ponerlo quizás 00:40:14

estático. ¿Por qué? Porque aunque definiésemos 10 alumnos 00:40:20

todos vosotros tendríais 00:40:24

el mismo ciclo que sería DUM. 00:40:27

Este para un ejercicio en el que todo alumno que se diera de alta 00:40:39

fuese de nuestro grupo, podría ser estático, solo tendríamos una zona 00:40:43

común y sería común a todos los 00:40:47

alumnos. En cambio, la edad no lo sería. En un caso nos permitiría 00:40:51

que fuese estático, en otro no. Vamos a definir el menú como 00:40:55

estático y lo llamamos aquí. ¿Por qué lo he pasado 00:40:59

un menú? Porque como lo vamos a utilizar varias veces, así solamente escribo 00:41:03

su código una vez y hago la llamada varias. Imaginaos que luego el menú 00:41:06

aquí cuando he puesto impar me he equivocado y he puesto impaz 00:41:11

en lugar de impar. He hecho copy y pega esto 00:41:16

en dos sitios en este ejercicio pero podría ser en 20. De repente me di 00:41:19

cuenta y tengo que irme a tocar a 20 sitios para actualizar del impaz 00:41:24

al impar si no he utilizado un método. Si lo que hago es llamar 00:41:28

al método con ir aquí y actualizar el impaz 00:41:32

por impar ya he corregido el problema en todas partes donde estoy haciendo 00:41:36

la llamada al método menú para corregir, para 00:41:40

meter nuevas cosas, para lo que hiciera falta. 00:41:43

¿Alguien tenía por ahí alguna pregunta que hacer? ¿Alguna consultita? 00:41:47

Pues sí, por ahí. ¿Me querías comentar algo, alguien? 00:41:58

No sé si estás hablando. Estás silenciado, yo creo. Tienes que desactivar el 00:42:04

altavoz. Sí, sí. 00:42:08

¿Esto? Claro, sí, pues nada, lo cuento. 00:42:30

mira, para que quede grabado 00:42:39

para que quede en la grabación la pregunta 00:42:41

porque solo se escucha mi micrófono 00:42:43

no el vuestro 00:42:45

me preguntan que qué significa esto 00:42:46

bueno, el asterisco no significa nada 00:42:48

es un carácter más que aparece por ahí 00:42:51

pues como pulsa o como una A 00:42:53

forma parte del contenido, lo que pasa es que para 00:42:54

como aparece luego aquí 00:42:57

inmediatamente después, pues está pegado 00:42:59

y la 00:43:01

y qué significa 00:43:03

pues existen unas cuantas secuencias de escape 00:43:04

que tienen ciertos significados. Las dos más típicas 00:43:07

pues es el barra N, que lo que hace es meter una nueva línea 00:43:11

y el barra T, que lo que te hace es tabular. 00:43:13

Y luego, bueno, pues hay algunos otros por ahí que 00:43:17

se pueden utilizar, que hay una tabla por ahí que sin la intentar 00:43:19

localizar. Entonces mira, aquí por ejemplo que pone 00:43:22

pulsa cualquier combinación, fíjate 00:43:25

como antes del asterisco, que es lo primero 00:43:28

que vemos, hay una tabulación aquí. Pues esta tabulación es 00:43:31

este barra T. Si en este 00:43:34

metemos tres barras T 00:43:36

Eclipse me lo duplica 00:43:38

pero bueno, metemos ahí tres barras T 00:43:40

pues mira, coge 00:43:42

y este, el pulsa S que le hemos 00:43:44

metido tres barras C, pues tiene tres tabuladores 00:43:46

uno, dos y tres. 00:43:48

Bueno, pues sirve un poquito para dar cierto 00:43:50

formato. Y si aquí metemos 00:43:52

barra N, dos barra N 00:43:54

pues aparte de una nueva 00:44:05

línea, que es la típica que nos permite 00:44:07

que nos haga a continuación un texto de otro 00:44:09

aparte va a meter dos nuevas líneas 00:44:11

aquí, entonces si le damos aquí a enter 00:44:14

fijaros como después de este reales 00:44:16

hay dos líneas, esas dos barras 00:44:18

que hemos metido, bueno esto es 00:44:20

el uso que tiene y justo 00:44:27

en el bloque 00:44:29

del barra T no es que participe 00:44:31

del asterisco sino 00:44:33

que es el primer carácter que he puesto aquí 00:44:35

como para que nos fueran mostrando 00:44:37

la información, si quitamos este asterisco 00:44:39

pues igualmente funciona el barra T 00:44:41

en el pulsa 00:44:43

pero claro pues no aparece el asterisco 00:44:45

aparece aquí 00:44:47

pero sin el asterisco, eso sí con el tabulador 00:44:49

que implica el barra T 00:44:51

tenemos el barra T, fijaros 00:44:53

un espacio, una tabulación 00:44:55

y un espacio 00:44:58

tendríamos aquí 00:44:59

bueno pues esto sería 00:45:00

si alguien más tiene alguna pregunta por ahí 00:45:06

vale pues nada, pues esto es 00:45:11

bien pues continuamos 00:45:21

aquí nos saca el menú, lo siguiente que podemos 00:45:23

hacer es intentar coger la opción, entonces podemos poner aquí string, esa opción 00:45:27

y después del menú podemos coger la opción con 00:45:30

mi scan.nestline 00:45:44

ya os digo que yo tengo la costumbre de coger todo con nestline 00:45:49

en este caso además es un string, pues bueno, pues con más razón 00:45:52

fijaros aquí como en la opción esta he metido 00:45:55

un barra n para darle este espacio 00:46:00

he metido dos barras T en lugar de uno para que 00:46:04

queden alineadas, vamos a hacer una ejecución 00:46:08

para que queden alineadas con un barra T, a ver que todavía tengo por ahí metidas 00:46:12

cosas, aquí he metido alguno de más 00:46:21

para que queden todas alineadas y este, pues bueno, esté desplazado una tabulación 00:46:24

más, y justo este en lugar de println 00:46:34

he puesto print para que se me quede el cursor aquí a la hora de escribir 00:46:37

que me parece que, bueno, pues como voy a escribir, pues después de la opción deseada 00:46:41

me parece que queda mejor aquí que no, que se me quede el cursor para escribir 00:46:45

la nueva línea, para cargar la opción 00:46:49

pues pongo aquí esa opción, vale, aquí la cargo 00:46:53

y ahora ya entraría en el bucle hasta que 00:46:56

pulse salir, fin o lo que sea, como estábamos 00:47:00

diciendo que cualquier combinación de mayúsculas, minúsculas de salir 00:47:05

o de fin, pues bueno, tenemos 00:47:09

dos opciones. Una, convertir lo que cojamos de la opción 00:47:13

para que sea cualquiera de estas combinaciones a todo mayúsculas 00:47:19

o a todo minúsculas y luego comparar con eso. Si queremos 00:47:22

hacer esa opción, podríamos decir que esa opción, la misma variable, sea 00:47:26

igual a... vamos a ver cómo 00:47:30

podríamos hacerlo esto. Decirle, hacerle un 00:47:34

Tu uppercase, tenemos un método, esa opción, punto, tenemos tu lowercase o tu uppercase. 00:47:38

Esto lo que hace es convertir todos los caracteres que estén en minúsculas en mayúsculas, 00:47:50

con lo cual se nos queda un texto en mayúsculas por completo, con lo cual cualquier combinación, 00:47:54

por ejemplo, de salir poniendo mayúsculas o minúsculas, nos quedaría en salir todo con mayúsculas. 00:47:59

Y lo mismo sucedería si hemos metido un fin. 00:48:04

Entonces podemos poner toUpperCase, por ejemplo, o toLowerCase, vamos a hacerlo. 00:48:08

Y ahora aquí, en el while, queremos permanecer dentro del while mientras sea distinto de cualquiera de estas. 00:48:13

Para que sea, lo primero que podemos hacer aquí es, para poner la condición, fijaros que dentro del while al final nos tiene que devolver algo que sea verdadero o falso. 00:48:39

Entonces, si lo que queremos es, primero podemos decir, vamos a comprobar que salí, que la opción es, si es salir. Entonces, cogemos y decimos, ese opción, punto. 00:48:48

Podemos utilizar el método equals. Este equals lo que hace es hacer una comparación del valor que tiene con otro que reciba como parámetro. 00:49:01

y nos devolverá un boolean, verdadero si es igual y falso si es diferente. 00:49:14

Aquí podríamos utilizar el equals directamente con la información de salir o de fin en minúsculas, 00:49:22

porque aquí le hemos hecho un to lower case, o podríamos habernos ahorrado hacer aquí el to lower case 00:49:29

y haber utilizado el equals ignore case, es decir, compáramelo que también devuelve un boolean 00:49:34

con la información que te estoy pasando, pero la comparación considero que son iguales 00:49:40

aunque uno tenga caracteres en minúsculas y otro en mayúsculas. 00:49:47

Es decir, si utilizamos el Equals Ignore Case, nos podríamos ahorrar esta conversión 00:49:50

que hemos hecho al To Lower Case. O podemos utilizar el Equals y haber hecho 00:49:55

la conversión a To Lower Case aquí. Ya tenemos al To Lower Case, vamos a poner aquí el Equals 00:49:59

y lo que queremos comparar es con salir. 00:50:06

Fijaros que aquí lo pongo en minúsculas porque esa opción tendrá el valor en minúsculas 00:50:13

como consecuencia de haber utilizado aquí el método toLowerCase. 00:50:19

Esto me debería verdadero en caso de que la opción que he metido sea salir. 00:50:29

También me interesa la opción fin porque son las dos que me exige el enunciado. 00:50:36

descojo y hago aquí y pongo aquí un fin 00:50:42

ahora resulta que estoy, que me devuelve 00:50:48

este conjunto verdadero, como es un or, en el caso 00:50:52

de que sea salir o en el caso de que sea fin 00:50:57

cualquiera de las dos me vale y cualquiera de los dos obtendría en su conjunto 00:51:01

si pongo aquí unos paréntesis, un verdadero 00:51:05

y resulta que en verdad lo que pretendo es 00:51:07

no que se me quede en el while cuando sea verdadero, este me está devolviendo 00:51:12

verdadero si he pulsado salir o fin, sino que cuando pase esto 00:51:17

lo que quiero es que se salga, entonces si yo cojo y niego esto aquí 00:51:21

ya tengo la condición que necesito en el while, cuando 00:51:24

lo que tenga esa opción, mientras 00:51:29

mientras, no cuando, mientras lo que tenga esa opción 00:51:32

sea distinto, tanto de salir 00:51:36

como de fin, el geomu también es lo que hay en el while 00:51:41

y cuando sea cualquiera de los dos, este conjunto 00:51:44

me da igual que haya sido fin o salir, será verdadero 00:51:48

con lo cual este conjunto será verdadero 00:51:53

este, y ya este que sigue siendo verdadero, si lo niego 00:51:55

se convierte en falso, bueno, vamos a ir haciéndolo poco a poco y lo comprobamos 00:52:01

entonces aquí cogemos y decimos, vamos a poner un 00:52:08

system.out 00:52:13

println 00:52:15

de esa opción 00:52:17

aunque esto luego lo quitemos 00:52:20

vale, y 00:52:21

fijaros, si aquí hemos cogido 00:52:28

un valor que es diferente de 00:52:30

de salir o de fin, cualquiera 00:52:32

lo que sea 00:52:35

esto va a ser cierto 00:52:35

se me va a meter aquí 00:52:38

va a ejecutar todo lo que tenga el while 00:52:39

va a llegar aquí y se va a venir a comparar de nuevo 00:52:42

si vuelve a ser cierto, volverá a ejecutarlo 00:52:44

Dentro del while, para que no se nos convierta en un bucle infinito, 00:52:48

pero en este caso un bucle infinito indeseado, 00:52:50

tendremos que tener en algún sitio algo que nos haga cambiar esa opción. 00:52:53

Si no, si esa opción en una primera entrada hace que entre en el while, 00:52:58

pues no va a cambiar esto nunca. 00:53:04

¿Y cómo hacemos cambiar esa opción? 00:53:06

Pues la hacemos cambiar solicitándolo desde luego desde teclado. 00:53:09

Entonces es tan fácil como coger estas tres líneas de nuevo, 00:53:13

que nos vuelva a mostrar el menú, leemos del menú 00:53:15

la opción que queremos, la convertimos 00:53:20

a lowercase de nuevo y aquí terminal while vuelve 00:53:24

y vuelve a hacer la comprobación de ese opción 00:53:28

entonces si damos aquí a ejecutar, nos sale este primer menú 00:53:31

este primer menú es este y se me ha quedado 00:53:38

el menú al final, como veis, me escribe opción deseada 00:53:42

con un system of print, ha acabado el menú y se me ha quedado aquí 00:53:47

en esta instrucción parado, en el line, entonces si yo cojo y pongo 00:53:50

hola aquí, fijaros como me muestra aquí un hola, este hola 00:53:55

como no he puesto ni salir ni fin, le ha gustado, me ha mostrado 00:54:00

la opción que había escrito, me ha vuelto a mostrar el menú 00:54:04

opción deseada, del menú habrá 00:54:08

hecho un lowercase, finaliza, se ha venido 00:54:12

a ver perdón, bueno me ha mostrado esto 00:54:16

el menú y se me ha quedado aquí parado 00:54:22

en el next line, entonces si ahora pongo adiós aquí 00:54:25

pues vuelve a pasar lo mismo, me lo muestra, fijaros que después de meter el adiós 00:54:30

se ha actualizado opción, que luego me lo muestra 00:54:34

aquí, pero continúa en la entrada, y si yo en cambio aquí 00:54:39

pongo fin, cualquiera de las combinaciones se me marcha 00:54:42

Si yo pongo aquí un System.out.println después del bucle, fijaros como si yo pongo aquí, pongo la n y la f mayúscula y la i minúscula, lo doy a Enter, en cualquier caso, en esta impresión después de un bucle, fin, mostrando opción, me lo muestra en minúsculas porque he utilizado aquí el tool over case. 00:54:46

vale, pues nada, la condición para entrar y salir ya la tenemos aquí 00:55:18

y tenemos claro que después de lo que hagamos aquí 00:55:23

luego hay que mostrar el menú y volver a cargar la opción que nos interese 00:55:28

fijaros, lo primero que nos pide por aquí como opciones es 00:55:33

sumar dos números reales 00:55:37

podríamos definir aquí, por aquí en algún sitio esos dos números reales como variables 00:55:41

o lo podemos definir aquí, por lo que os decía 00:55:48

Que cada vuelta del while, o al menos cada vuelta en la que definamos sumar dos reales, no esté molestando al sistema operativo para coger espacio de memoria y liberarlo. 00:55:51

Entonces una opción que podríamos hacer aquí es definir un double de valor 1, voy a inicializar a 0 y aquí tenemos una estructura de control de repetición con el while y ahora lo que vamos a hacer aquí va a ser utilizar una estructura de control de selección. 00:56:02

Entonces, por ejemplo, podríamos poner if, sí, o podríamos hacerlo con un switch, a quien más os guste. Entonces podríamos decir que si la opción es igual, acordaros que la opción la tenemos en minúscula, si la opción es igual a S, resulta que es cuando queremos sumar. 00:56:38

Como lo he hecho un tool over case, pondré aquí una S y aquí pongo estamos sumando dos números reales. 00:57:00

System.println para ir pidiendo, vamos a pedir los dos datos, println. 00:57:18

Fijaros, podríamos poner aquí un barra n aquí. 00:57:33

Esto lo podemos tabular, si queréis, barra t. 00:57:37

En lugar de meter otro system.println, podríamos meter aquí un barra n y luego dos tabuladores, por ejemplo. 00:57:41

y decir, dime, aunque no me gusta mucho esto, ahora lo voy a cambiar, 00:57:47

pero lo voy a poner ya que lo estoy diciendo, el primer número. 00:57:55

Entonces si yo le doy aquí, digo sumar, y dice sumando dos números reales, 00:58:03

dime el primer número, fijaros como este dime el primer número está en una línea 00:58:17

diferente del sumando dos números reales, esto es consecuencia de que hemos puesto 00:58:21

aquí este barra n y está más tabulado que el sumando dos números reales 00:58:26

porque le hemos metido dos tabulaciones en lugar de una 00:58:31

que le hemos puesto al tabulando. Como hemos puesto aquí un println 00:58:35

al final de este número el cursor se me ha quedado en una nueva línea. 00:58:38

Entonces lo voy a quitar ahora, pero bueno, quería que vierais como dentro 00:58:43

de un solo system of println, bueno, podemos meter varias 00:58:46

líneas utilizando estas secuencias de escape de las que hablábamos antes. 00:58:51

Vamos a ponerlo como un system of println cada uno. 00:58:59

aquí sumando dos números reales 00:59:01

podemos hacer que aquí quede 00:59:04

un poquito más bonito haciendo así 00:59:06

después de la opción deseada 00:59:08

vamos a meter otra línea más aquí 00:59:11

para que se separe ahí un poquito 00:59:13

aquí vamos a poner 00:59:15

print 00:59:18

y vamos a meterle dos tabuladores 00:59:20

sumando dos números 00:59:23

ya no quiero sumando, aquí vamos a decir el dime 00:59:25

dime el primer número 00:59:28

y ese primer número 00:59:30

lo vamos a cargar en esta variable. ¿Cómo vamos a cargarlo? Pues lo vamos a cargar 00:59:32

con, vamos a definir aquí, podría 00:59:37

definir aquí una variable string auxiliar para hacer un S line 00:59:42

y luego hacer el parse double, pero en lugar de hacerlo aquí, que cada 00:59:46

vuelta me va a pedir al sistema operativo 00:59:50

espacio para ella, pues voy a definir aquí un S aus. 00:59:54

Una variable de tipo S aus. Bueno, en particular 00:59:59

los stream ya os contaré son un poco tramposos porque éste sí que molesta el sistema operativo 01:00:05

cada vez para pedir una reserva de memoria pero bueno los cojo y hago que me es campo 01:00:10

camp punto a un net line y ahora cojo y en esta variable de bar 1 01:00:23

hago, quiero convertir 01:00:32

un literal que tiene un número en 01:00:37

una variable numérica. Acordaros que 01:00:41

este es primitivo, con lo cual no dispone de métodos, pero 01:00:46

al ser un tipo de dato primitivo, en este caso de tipo double, pues 01:00:49

tiene una clase wrapper, que se llama como él. Entonces hacemos un parse 01:00:54

double y de esta forma hemos dejado limpio 01:00:57

el buffer de la jugada esta del enter que os comentaba antes y ahora vamos a pedir el segundo 01:01:02

número hacemos next line volvemos a utilizar la misma variable ya tenemos ahí los dos números 01:01:09

entonces aquí podemos poner un system.out.println es decir la suma de los dos números de los números 01:01:23

podríamos hacerlo así, vamos a hacerlo así para que quede un poquito más claro vamos a hacer la 01:01:34

operación numérica antes de imprimirlo hay y así no metemos tantas cosas dentro 01:02:23

del println a ver me falta por aquí es ahí está y aquí me falta un más entonces 01:02:29

si ejecutamos por aquí vamos a ver qué pinta va teniendo esto hicimos sumar 01:03:04

dime el primer número vale es con el punto nunca me acuerdo 01:03:09

para coger el real, sumar 01:03:15

5.5 y el segundo número 01:03:17

voy a poner 2.2, con lo cual me dice 01:03:21

la suma de los dos números es, bueno pues ahí me saca 01:03:24

el resultado y me vuelve a mostrar 01:03:26

una vez que he hecho esta ejecución con el if 01:03:30

me vuelve a mostrar el menú y se queda esperando 01:03:32

a que recoja la opción de menú 01:03:35

que queremos, vamos a poner salir 01:03:39

y después de bucle salir se me marcha para que nos quede más bonito vamos a tabular esto también 01:03:41

y vamos con la segunda opción si no es este ya os digo esto lo podemos hacer con un switch también 01:03:49

perfectamente la segunda de las alternativas que nos pide es la resta de dos números enteros pues 01:04:04

igual que hemos hecho esto aquí pues podríamos coger y valor 1 y vamos a utilizar este código 01:04:11

la resta y así nos ahorramos escribir 01:04:32

muchas cosas. Lo adaptamos. Decimos en el shift 01:04:36

si en lugar de sumar lo que queremos es restar dos reales 01:04:40

en la R, pues entonces la condición que hay que cumplir es R 01:04:44

estamos restando dos enteros. 01:04:48

Restando dos enteros. 01:04:58

Dime el primer número. Bueno, lo cogemos por aquí. 01:05:04

ahora el primer número lo vamos a guardar en la variable y valor 1 01:05:07

y como lo que queremos es convertir un string a un entero 01:05:12

pues ya no le gustan los tipos, dice esto no me gusta, pero 01:05:19

en lugar de utilizar el método wrapper de la clase double 01:05:22

pues utilizamos el método wrapper de la clase integer 01:05:27

y lo tenemos, y para el segundo de los valores 01:05:30

hacemos lo mismo aquí, 2 y aquí ponemos 01:05:34

y result, será igual a i valor 1, en este caso estamos restando, menos el valor 2. 01:05:42

La resta de los números i valor 1, i valor 2 es i result. 01:06:01

Si os surgen dudas me vais diciendo, pues pulso por aquí, voy a decir que ahora que restamos, 01:06:18

dime el primer número, voy a decir que quiero restar 3 menos 6 01:06:24

y nos dice que el resultado es menos 3, bueno me ha puesto 6 menos 6 01:06:28

porque he puesto y valor 2 las dos veces aquí, ahí, no 01:06:32

control c, ahí está, pues ese sería, ejecuto de nuevo 01:06:42

digo que quiero restar, digo que quiero restar 01:06:50

3 menos 8 y dice que 3 menos 8 es menor 5 01:06:54

después de la opción del else, que ha sido con la opción r 01:06:57

he puesto aquí R minúscula, si la pongo mayúscula 01:07:04

hubiera dado igual por el tool over case 01:07:06

que hubiéramos puesto por aquí 01:07:08

y aquí 01:07:09

para las siguientes opciones 01:07:14

pues ahora si le digo 01:07:16

sumar 01:07:18

sumando dos reales, dime el primer número 01:07:19

real, pues pongo 6.3 01:07:22

y 01:07:26

0.4 01:07:26

pues 6.7 01:07:28

y si damos a fin 01:07:31

pues nada, se nos va 01:07:32

el código que tenemos hasta ahora funciona razonablemente bien 01:07:34

vamos a la siguiente opción 01:07:39

voy a hacer copy y pega por aquí 01:07:41

la siguiente opción es el máximo de tres números 01:07:44

y nos pide una M 01:07:50

pues ponemos aquí máximo de tres números 01:07:53

como vamos a coger tres números vamos a definir 01:08:01

no sé si dice tres números enteros 01:08:06

es un poco igual, es solo definir un tipo de dato o otro 01:08:08

tres enteros, se ha apuntado yo aquí, vamos a definir otro 01:08:12

dato entero, máximo, vamos a poner aquí 01:08:15

tres números enteros, dime el primer número, dime el segundo, vamos a coger el tercero 01:08:31

el tercer número, la misma jugada, pero ahora 01:08:38

aquí lo guardamos en el tres, mirad, una posibilidad para 01:08:52

una posibilidad que tenemos para calcular el máximo, bueno, pues 01:08:58

hay diferentes opciones, mirad, tenemos, si no queremos 01:09:04

estar comparando con mayores y menores, por ejemplo 01:09:09

la clase, existe igual que tenemos la clase 01:09:13

double, tenemos la integer 01:09:22

que son clases que tienen métodos estáticos definidos en la librería 01:09:26

de Java, pues otra de las librerías de Java que hay disponibles es la clase mat 01:09:30

fijaros que hemos puesto aquí mat y directamente me ha funcionado sin importar nada 01:09:34

sin hacer ningún import, no importar del verbo 01:09:38

importar sino de importar sin hacer un import esto es porque más estará definido en la librería 01:09:42

java lang que se importa directamente en todos los proyectos entonces la clase está más lo que 01:09:49

tiene son pues muchas funciones matemáticas fijaros por aquí tenemos valor absoluto muy 01:09:56

útil cuando queramos hacer cosas operaciones matemáticas fijaros a ver si no el seno por 01:10:01

ejemplo es una de las opciones que tiene es más fijaros tiene la opción más para comparar dos 01:10:08

para devolver el valor máximo que hay entre dos entre dos valores que metamos por aquí para dos 01:10:15

double para dos flores parados enteros está el min bueno pues hay un montón de opciones si no 01:10:21

queremos acudir a la clase más en este caso una forma la forma que me parece más rápida y más 01:10:29

sencilla, es considerar uno de ellos el máximo de partida. 01:10:35

Es decir, mira, antes de hacer más comparaciones, digo que el valor 01:10:40

1 es el máximo de ellos, con lo cual entiendo aquí 01:10:43

en el irresult, aprovechando que tengo esta variable, voy a guardar el máximo. Entonces digo 01:10:47

que irresult es igual al primero. 01:10:51

Estoy haciendo la suposición de que este ya es el máximo. Ya digo que en irresult 01:10:55

estamos guardando el máximo. Y ahora digo, si el segundo 01:10:59

valor resulta 01:11:05

que es mayor 01:11:07

que lo que tengo ya como máximo 01:11:08

no me hace el enter 01:11:11

el teclado ahora 01:11:20

pues resulta que si el nuevo 01:11:21

valor es mayor que este 01:11:24

pues resulta que desbanca al que tengo 01:11:26

considerado como máximo hasta ahora 01:11:28

pues cogido aquí result sea igual 01:11:30

hay valor 2 01:11:32

y aquí bueno pues podría 01:11:34

hacer otra comparación así directa 01:11:38

de esto diciendo que si el valor 3 01:11:42

es mayor, pues desbanca el 3 al máximo que lleva acumulado hasta ahora 01:11:44

con lo cual el máximo pasa a ser el valor 3, con lo cual aquí en irresult 01:11:49

ya tengo el valor máximo de los 3. Si tuviéramos 01:11:53

un array de valores enteros, pues podríamos recurrer todo 01:11:58

el array y hacer en un bucle toda esta misma 01:12:03

validación que hemos hecho de los dos valores, del segundo y el tercero, para el resto 01:12:07

de valores. En este caso no tenemos un array, pues así lo podemos hacer. 01:12:11

Entonces aquí, para sacar el resultado, diríamos el máximo de los números y valor 1, ponemos aquí una coma, más y valor 3, nos dice el máximo de los números, el 1, el 2 y el 3, es el result que hemos hecho aquí, nos hemos buscado aquí las mañas para poner un algoritmo 01:12:15

que nos termine guardando ni resuelve el valor máximo de los tres. 01:13:05

Entonces damos por aquí a ejecutar, máximo, pues decimos, dime un número, 01:13:11

decimos aquí un cinco, el segundo número un ocho, 01:13:19

y el tercer número un dos, y nos dice que es el ocho. 01:13:23

Vamos a hacer otra prueba con el máximo, poniéndolo el primero, 01:13:26

para ver que nos funciona, seis, dos y tres, nos dice el seis, 01:13:28

vamos a hacer un máximo poniéndolo el tercero, el mayor de todos, 01:13:35

5, 6, 7, vale pues en los tres casos nos funciona y ponemos aquí salir y nos queda una última opción 01:13:37

que es la opción de mirar a ver si es par o impar, vamos a copiar esta de restar por ejemplo, ponemos 01:13:49

aquí una p, ponemos el indicador que ponemos para hacer este tipo de operación, indicar si es par o 01:14:06

impar, comprobar si un número es par o impar, aquí solo necesitamos un número, indica el número, decimos, lo podemos guardar en, he quitado un parse int, bueno me preguntan que si lo voy a subir este programa en algún sitio, 01:14:18

Yo creo que, no creo que sea muy diferente de la solución que os he dado en, a ver, mira aquí en el aula, esta solución a las tareas que vamos entregando, os doy una solución. 01:15:01

Entonces, mira, voy a pulsar por aquí y bueno, la clase se llama programa matemático, pero en líneas generales, fijaros, aquí está haciendo el while, aquí en lugar de tool over case habíamos trabajado con el tool per case, pero bueno, fijaros que vamos haciendo más o menos lo mismo. 01:15:17

Entonces este programa sí que lo tenéis disponible 01:15:33

Aquí está cerrando el close 01:15:36

Aquí repite esto 01:15:38

Lo único que sí que es verdad es que fijaros 01:15:39

Que aquí en lugar de un método 01:15:41

Menú al que hemos llamado aquí 01:15:42

Y al que hemos llamado aquí 01:15:45

Pues lo he escrito dos veces 01:15:46

Pero en líneas generales 01:15:47

Prácticamente el mismo programa 01:15:49

Si queréis alguna variante 01:15:51

Pues viendo el vídeo 01:15:54

Pues hacer la variante que os parezca oportuno 01:15:56

Y si queréis 01:15:59

Yo qué sé 01:16:01

Si queréis que lo suba 01:16:02

pues nada pues luego lo me lo ponéis en los foros si nos parece bien resuelto o tenéis algunas dudas 01:16:03

y lo recupero aquí de la máquina virtual y os lo subo no tengo problema pero en principio echar un 01:16:11

ojo a ver si os resulta suficiente con eso bueno pues entonces tenemos por aquí el DS el a ver si 01:16:18

es par o impar de aquí ya tenemos cogido el número hacemos el parse in con lo cual lo tenemos aquí 01:16:30

de forma numérica y en algún momento creo que hemos comentado que para ver si un número es par 01:16:36

o impar lo mejor de las maneras es utilizar el resto de la división entonces si el resto de a 01:16:43

la hora de dividir nos devuelve cero pues quiere decir que el número es par cualquier número dividido 01:16:50

entre dos su resto el cero si es par su resto el cero cualquier número dividido entre dos si su 01:16:55

resto es impar, es un 1, es un 1, es impar. Entonces podemos hacer ahí esa 01:17:01

comprobación. Entonces decimos if, si el valor, si pusiéramos esto, estaríamos 01:17:06

haciendo la división. Si tenemos un 5, nos devolvería, nos devolvería lógicamente 01:17:14

un 2, si el valor fuera un 5. Pero si utilizamos el operador tanto por ciento, 01:17:20

este lo que nos devuelve es el resto de la división ahora mismo nos compila porque esto 01:17:27

no está devolviendo un verdadero falso no está devolviendo un valor numérico 0 o 1 entonces 01:17:34

dentro de una estructura de control de selección o de condición lo que tiene que ir entre los 01:17:38

paréntesis tiene que ser resoluble se tiene que poder resolver como un verdadero falso entonces 01:17:44

para que pase lo que queremos lo que le decimos que si esto es igual a 0 si el resto de la 01:17:49

división es igual a cero. Esto no funcionaría ya, pero si ponemos 01:17:57

aquí unos paréntesis ya nos queda ya más súper claro el orden 01:18:01

de evaluar la condición. Entonces aquí estamos 01:18:04

hablando de que es el número es par. Else 01:18:09

que vendría a ser comparar, es hacer esta misma comparación, pero a uno 01:18:18

como solo tenemos dos opciones, vamos a utilizar el else directamente, pues sería 01:18:22

el caso en el que tendríamos que el número es 01:18:26

impar. System.out.println 01:18:30

y aquí podemos poner, para que nos quede tabulado así 01:18:39

un poquito más bonito, ponemos dos barrastes 01:18:43

y decimos el número, vamos a poner 01:18:46

el número con el que estamos trabajando, pongo más para seguir 01:18:59

concatenando cadenas de caracteres, aquí dejo un espacio para que me quede 01:19:05

más chulo, otro espacio, es, y si estamos aquí 01:19:09

dentro pues resulta que estamos hablando de un número par pues es par podemos decir y en este 01:19:13

caso podemos decir que es impar esto no me está cumpliendo probablemente porque falta un paréntesis 01:19:20

ahí está le doy a la ejecución vamos a ver si nos funciona con el par 01:19:28

dimos par dime un número decimos un 3 me dice que es impar ponemos la p de la opción y ponemos un 6 01:19:42

me dice que es par 01:19:53

vamos a sumar 01:19:55

vamos a hacer un ejercicio rápido 01:19:58

4.4 01:19:59

2.2 01:20:00

bueno pues me da ahí el resultado 01:20:03

6.6 01:20:05

fijaros ahí me da un número 01:20:07

larguísimo y termina aquí completándolo 01:20:09

con un 5 01:20:12

pues tiene una pequeña deriva esto ahí 01:20:12

a la hora de hacer la operación 01:20:15

si damos aquí resta 01:20:16

ponemos 7 01:20:21

menos 2 01:20:23

nos da el resultado de 5, el máximo de 3 números 01:20:24

3, 3, 3, 4, 2, me dice que es 4 01:20:30

y el par, ponemos el 88 01:20:34

y me dice que es un número par, ponemos 01:20:38

una opción no válida y no me dice nada, ahora 01:20:42

terminamos de implementar la opción no válida 01:20:46

si ponemos salir, pues nada, se marcha 01:20:50

Fijaros que aquí se me ha quedado una T, porque probablemente no he puesto la barra. 01:20:54

En la opción, pulsa P para indicar si es par. 01:20:59

Bueno, se me ha quedado esta T. 01:21:06

Pulsa T para indicar si es par. 01:21:08

Tengo una T ahí extra. 01:21:10

Y luego, bueno, pues aquí podríamos decir, para completar el ejercicio, 01:21:13

podríamos poner un else. 01:21:17

Y aquí decir, system.out.println, opción no. 01:21:23

Bueno, como lo queréis formatear. Entonces, si yo pongo aquí cualquier cosa que no sea válida, pues dice opción no válida y tras mostrar por el else la opción no válida, me vuelve a mostrar aquí el menú. 01:21:38

Y bueno, esto en líneas generales era la práctica que os proponía para practicar, para trabajar un poquillo con esto, con esto del tema 3. 01:21:58

al ejercicio le queda, bueno, pues para que sea 01:22:06

algo entregable, digamos, a un cliente todavía le quedaría recorrido 01:22:10

un ejercicio habría que validar, por ejemplo, que si yo cojo aquí 01:22:14

digo sumar, si yo dice ponme aquí el primer número 01:22:18

y pongo aquí unas teclas, pues no me pase esto, entonces esto ahí 01:22:22

tema más adelante, pues veremos como podemos hacer 01:22:26

una gestión de excepciones que se puedan producir en el programa para que 01:22:30

detecte un error, nos dé un aviso, pero el programa 01:22:34

no se termine. Imaginaros que esta 01:22:36

calculadora, no sé qué deciros, 01:22:38

fuese un programa de un cajero 01:22:40

automático que tiene que estar funcionando 01:22:43

continuamente y coge y da 01:22:44

un error de estos y de repente se apaga el cajero 01:22:46

y ya deja de funcionar. Pues no es admisible. 01:22:48

Entonces tenemos la posibilidad 01:22:51

de hacer un control de errores 01:22:52

para luego 01:22:55

con código estabilizar 01:22:57

el programa después de que se haya producido ese error 01:22:58

y que siga funcionando a pesar de haberse 01:23:01

producido ese error, igual mostrándonos un mensaje, ¿no? La opción que has puesto no es 01:23:03

válida, pero has intentado meter una cadena de caracteres 01:23:07

donde se esperaba un número, pero que no se acabe así de golpe. Eso, por ejemplo, 01:23:11

es algo que veremos en un tema que es el de controles de excepciones. 01:23:15

Y, bueno, no mucho más que contaros 01:23:19

ya de este ejercicio. No sé si os ha resultado muy complicado, 01:23:23

si tenéis algunas dudas de él, si queréis que comentemos 01:23:28

alguna cosa extra. Sí, sí. Bueno, he puesto, sí, me comenta aquí para que quede en la grabación 01:23:32

una pregunta de que utilizando el Nest, el Nest Sync, bueno, pues ha funcionado. Depende un poco 01:24:11

de la gestión que hagas luego en las siguientes lecturas. Al final, si hay sitios donde luego 01:24:18

hacer lecturas con Nest, es diferente 01:24:25

que si lo haces con NestLine 01:24:27

si en 01:24:29

algún sitio del código 01:24:31

está limpiando el buffer 01:24:33

lo que sí que 01:24:35

te digo es que si tú 01:24:37

haces una lectura con Nessint 01:24:39

y no limpias el buffer 01:24:41

o la alternativa de leerlo 01:24:42

con el NestLine 01:24:45

estás dejando ahí sembrada 01:24:46

una posibilidad de que luego te dé un problema 01:24:49

que a lo mejor no te da 01:24:51

Pues yo que sé, por la secuencia de ejecución del programa, pero dejas ahí un puntito que te lo puede dar. Y en un programa que es muy lineal, más o menos cae rápido en la cuenta. Este ejemplo que os he puesto yo, que sí que se producía el error, no sé si lo has observado, que el siguiente en S-Line. 01:24:53

Sí, pues en este programa se ve muy directo, pero cuando realmente tienes pues a lo mejor un bucle y luego se va a otra opción y pues ya como que visualmente las líneas según el siguiente Nes que puedas hacer, el siguiente Nesline igual no está próximo en el código al Nesync que acabas de hacer. 01:25:12

y entonces tú ves que no te funciona en esa zona de código 01:25:33

por ejemplo, la variable está vacía como me estaba sucediendo 01:25:37

antes cuando pedía el nombre y como no tienes el otro 01:25:41

nesting visualmente cerca en el código, cuesta a veces mucho 01:25:45

terminar deduciendo que es que en la secuencia de ejecución pasó aquello 01:25:49

y es más, si además es un programa que 01:25:52

unas veces no tienes por qué llegar a ese nestline directamente siempre después 01:25:55

de un Nessint anterior, de un Nessdouble, sino que depende 01:26:01

de opciones que vayas o ejecuciones que vayan pasando en el programa 01:26:04

unas veces van por ahí, otras no. Entonces esto te puede 01:26:07

dar situaciones a lo típico de 01:26:10

jolín, ¿por qué siempre me está funcionando el programa y ciertas 01:26:12

veces no? Me voy aquí al código, yo veo el Nessline 01:26:16

donde debería coger el nombre y no me lo coge. 01:26:19

O sea, dejas como una semillita de 01:26:22

una posibilidad de problema futuro, que la libras 01:26:24

con cualquiera de las dos alternativas 01:26:28

que hemos dicho, si quiero leer un número 01:26:30

y lo voy a leer desde el teclado 01:26:32

voy a limpiar y utilizo 01:26:34

un nest double, que no es que esté incorrecto 01:26:36

es código disponible ahí 01:26:38

en la librería de Java 01:26:40

voy a dejar limpio el buffer del enter 01:26:41

no lo voy a dejar ahí, no va a ser que 01:26:44

luego el diablo enrede por ahí, en otra zona 01:26:46

de código, o otra posibilidad 01:26:48

ya te digo que es la que yo suelo utilizar 01:26:50

es el nest line, cojo mi número 01:26:52

entero, mi número double con el line 01:26:54

lo convierto a un número 01:26:56

y mi buffer se queda totalmente limpio cuando tenga que pasar cosas con la lectura de teclado, pues ahí está. 01:26:58

No pongo en duda que te está funcionando, pero ahí dejas una posibilidad, algo sin leer, 01:27:06

que luego vete tú a saber si en algún sitio te puede dar un comportamiento que no esperas. 01:27:11

¿Alguna otra cosita por ahí? ¿Queréis comentarme alguien? 01:27:22

Sí, mira, sí, bueno, preguntaba un poco por el funcionamiento de estas líneas. 01:27:27

Entonces, en el API de Java, para la clase Scanner, si tú pones aquí mi scan, el objeto que tenemos definido y ponemos aquí netline, si leemos una línea, fíjate aquí que lo que me devuelve es un string. 01:27:53

este string será, si es un nombre 01:28:15

será Rubén, será 01:28:18

Noah y si es un número 01:28:20

será el número pero cargado en una 01:28:22

variable string, es decir 01:28:24

es una cadena de caracteres 01:28:25

entonces 01:28:28

nestline, eso es, siempre te lee 01:28:28

un string 01:28:32

sí, bien, pues entonces 01:28:32

bueno, ya completo la 01:28:36

consulta por si alguien 01:28:38

luego ve el vídeo, entonces nestline 01:28:40

siempre te cogerá un string, entonces esa variable 01:28:42

la estás cargando en un string 01:28:44

fíjate como si yo pongo aquí y valor 2 que sabemos por la definición que tenemos arriba que es un 01:28:45

entero no he puesto aquí el indicador este de la y para que me lo chive y yo digo mi scan 01:28:53

punto next line punto y coma fíjate que no me compila porque porque él como devuelve el 01:29:00

next line devuelve un string dice una variable de tipo entero no lo puedo cargar pues como lo 01:29:09

tenemos aquí cargado con independencia que si metemos el dato bien desde el 01:29:14

teclado será un literal será un string aunque realmente vemos aquí un número 01:29:18

pero será un string no será 444 pues para convertirlo a un entero por eso es 01:29:24

por lo que hacemos el parse int en este caso 01:29:30

esta era un poco la jugada de por qué lo hacemos así bueno nos hemos metido en 01:29:33

Son las 7 y 5 ya y bueno, pues no me importa en absoluto. Tengo aquí el guioncillo de cosas que os quiero contar del tema 4. Se nos ha ido la clase resolviendo la tarea 3, pero bueno, a mí me parece que ha podido ser interesante porque hemos hecho un repaso ahí de muchas cosas y haciendo un ejercicio desde cero para que veáis como más o menos se me ha ocurrido a mí ir planteándolo. 01:29:44

Lo que sí que no vamos a hacer, yo creo, ya es arrancar con el tema 4. El tema 4 lo tenemos, todavía lo tenemos abierto alguna semana más, pues hacemos repaso del tema 4 ya a partir de la semana que viene. 01:30:07

Estos minutillos, si tenéis alguna otra cosa que queráis comentar, pues adelante y si no, pues yo creo que lo vamos a ir dejando por aquí ya. 01:30:22

Uy, pues no sé decirte ningún libro así especialmente recomendado. Bueno, si has hecho alguna búsqueda por internet, que entiendo que sí, habrás visto que hay miles de colecciones de Java, es un lenguaje tan popular. 01:30:31

pero así alguno decirte, mira este sí que te lo recomiendo 01:30:56

que podría ser especialmente útil, pues no sabría decirte 01:31:00

de todas formas, como esta asignatura la damos también aquí en presencial 01:31:04

y tenemos varios ciclos, le voy a preguntar a otros compañeros que dan 01:31:08

la asignatura a ver si a ellos se les ocurre algún libro 01:31:12

en particular y os lo pongo en el foro. Bueno, pues nada 01:31:16

voy a parar la grabación y si no tenéis alguna otra cosita por ahí 01:31:28

que comentarme, aquí lo dejamos. 01:31:33