Saltar navegación

Scanner - 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 29 de septiembre de 2023 por Stefano C.

7 visualizaciones

Más información Transcripción

Descargar la transcripción

Estoy grabando, si vosotros habláis, me dais la autorización a que se pueda grabar, ¿vale? 00:00:00
Entonces, nosotros hemos hablado de varias cosas, hemos hablado de hacer pequeños programitas, ¿vale? 00:00:07
Creamos variables, luego procesamos estas variables, etcétera, etcétera, etcétera. 00:00:18
Para que nuestro objetivo es que paso a paso estos ejercicios vayan siendo más complejos y a la vez más útiles. 00:00:22
Los ejercicios que estamos haciendo ahora son muy básicos y tienen poco sentido, no sirven de nada en la práctica, en la vida real. 00:00:35
Lo que iremos haciendo es añadir cosillas para que empiecen a tener un poquito más de sentido 00:00:43
Dentro de este contexto, hoy vamos a ver dos cosas 00:00:52
La salida básica y la entrada básica 00:00:56
La salida básica en realidad ya la hemos visto, es el system.auto.println 00:00:58
Como salida básica, es decir, cuando yo he recibido los datos, los he trabajado, he procesado todos los datos 00:01:03
si ahora mismo tengo un resultado 00:01:11
¿cómo escribo este 00:01:13
resultado? ¿vale? y hay muchas 00:01:15
formas de hacerlo, lo puedo escribir en un fichero 00:01:17
lo puedo mandar por 00:01:19
por red, lo puedo 00:01:20
compartir en una zona de memoria 00:01:23
que se yo 00:01:25
nosotros lo que hacemos es imprimirlo en pantalla 00:01:26
¿vale? con system.auto.println 00:01:29
tened en cuenta que el system.auto.println 00:01:31
lo que obtiene 00:01:34
entre paréntesis es un string 00:01:35
siempre es un string 00:01:37
hasta cuando escribo un int 00:01:39
en realidad lo que me hace 00:01:41
él es hacer un casting 00:01:43
hacer una transformación de este int 00:01:45
como si le pegara delante 00:01:47
abierta comillas, cerrada comillas, más 00:01:49
y ese es int 00:01:51
entonces el println 00:01:52
imprime una cadena 00:01:55
un string, una cadena de carácter 00:01:57
entonces aquí son ejemplos 00:01:59
de lo que puedes poner aquí 00:02:01
puedes concatenar aquí, estos ya lo hemos 00:02:03
hecho, vale, lo que no 00:02:05
hemos hecho es la entrada básica. Es decir, hasta ahora yo creo una variable dentro del 00:02:07
programa mismo. Creo int edad 23 y ahora mi alumno, mi lo que sea, tiene 23 años. Si 00:02:17
yo quiero cambiar este 23, lo que tengo que hacer es cambiar el código fuente. Tengo 00:02:26
que ir a Eclipse, entrar en esta variable, ponerle 24, ¿vale? Y recompilar todo. ¿Os 00:02:33
imagináis vosotros que cualquier programa que estáis utilizando, normalmente por ejemplo 00:02:41
Google, cuando vais a hacer una búsqueda en Google, en vez de escribir que haga la 00:02:46
búsqueda, deberíais recompilar Google entero para hacer vuestra búsqueda? Eso no tiene 00:02:51
mucho sentido. Las variables que nosotros utilizamos, como lo sabemos utilizar de otra 00:02:59
forma, la escribimos directamente su valor en el código fuente, pero la cosa interesante 00:03:04
sería que tú tengas una variable edad, pero que el valor de esta edad no venga desde el 00:03:09
código fuente, sino que a tiempo de ejecución, cuando yo lanzo el programa, haya un cierto 00:03:16
momento alguien que me pregunta, oye mira, ¿cuántos años tienes? Y que sea el usuario 00:03:22
De ese programa que pone su edad 00:03:28
Y en base a lo que ha puesto 00:03:30
En su edad, el programa haga una cosa o otra 00:03:32
O calcule lo que tiene que calcular 00:03:35
El ejemplo pequeño que hemos 00:03:36
Hecho antes de decir cuantos días 00:03:38
Has vivido 00:03:40
Si te doy mi edad 00:03:42
Nosotros lo podemos hacer solo con 00:03:43
El valor que hemos puesto 00:03:46
Dentro de la variable, en el código 00:03:48
Sería más interesante 00:03:50
Ese programa, si yo pudiera preguntar 00:03:53
Lanzo el programa, el programa ya ha sido 00:03:54
Compilado y lanzado 00:03:56
Y el programa me pregunta 00:03:57
¿Cuántos años tienes? 00:03:59
Y tú pones 30 años 00:04:01
Y él hace la multiplicación 00:04:03
30 por 365 00:04:06
Y me da el resultado 00:04:07
Entonces has vivido no sé si no sé cuánto 00:04:08
Es que si yo lo lanzo otra vez 00:04:10
Sin haberlo recompilado 00:04:12
Lo lanzo otra vez 00:04:14
El usuario puede poner esta vez en vez de 30 00:04:15
¿Sí? 00:04:18
Eso es una cosa importante 00:04:22
Porque 00:04:23
Escala el nivel de abstracción 00:04:24
A mi programa 00:04:28
Ahora yo no estoy pensando 00:04:30
A la edad 24 00:04:32
Y entonces todo mi programa 00:04:35
Está basado sobre el número 24 00:04:37
Yo estoy pensando ahora 00:04:39
Sobre la representación de ese dato 00:04:41
Que es la variable edad 00:04:44
Y todo lo que hago dentro del programa 00:04:46
Será basado sobre esta edad 00:04:49
Que no sé cuánto vale 00:04:50
Lo sabré en tiempo de ejecución 00:04:52
¿Cuánto vale? 00:04:56
Cuando yo lanzo el programa 00:04:58
Alguien me dirá que para esta vuelta del programa 00:04:59
Vale 37 00:05:02
Vale, entonces usaré 37 00:05:03
Pero a tiempo de programación 00:05:05
Cuando yo estoy desarrollando 00:05:07
No voy a saber cuánto vale 00:05:09
Esta variable 00:05:12
¿Entendéis lo que quiero decir? 00:05:15
Para hacer esto 00:05:19
Lo que vamos a hacer 00:05:20
es ver cómo se hace la entrada básica 00:05:22
es decir, cómo puedo leer 00:05:24
unos datos a tiempo 00:05:26
de ejecución 00:05:28
es decir, cómo puedo leer algo 00:05:30
desde el teclado 00:05:32
nuestra entrada básica 00:05:33
será el teclado 00:05:36
nuestro programa, al menos en el primer trimestre 00:05:37
se basará en 00:05:41
arranco el programa 00:05:42
el programa mismo 00:05:44
me pide algunos datos por teclado 00:05:46
dame tu nombre, dame tu edad 00:05:49
dame donde sea 00:05:51
Y luego después yo proceso estos datos 00:05:52
Y te doy una salida en base a lo que tú has puesto 00:05:55
¿Sí? 00:05:57
Voy a hacer un programa solo 00:05:59
Que luego podrá funcionar por un mogollón de datos distintos 00:06:01
¿Sí? 00:06:06
Vale, entonces 00:06:11
Nosotros, para simplificarnos la vida 00:06:12
Vamos a usar una clase que ya existe 00:06:15
Porque programar nosotros un programa 00:06:17
que va a leer las teclas 00:06:20
del teclado, es posible 00:06:22
pero es complejo, vale 00:06:24
y nosotros vamos a usar la clase 00:06:26
Scanner 00:06:28
Scanner es como 00:06:28
los métodos Println, vale 00:06:31
¿de dónde vienen los métodos Println? 00:06:33
pues existe una clase que se llama la 00:06:36
Printstream, una cosa de ese estilo 00:06:37
y nosotros de esa clase 00:06:40
estamos utilizando el método 00:06:42
Printline, vale 00:06:43
¿sabemos nosotros cómo está hecho? 00:06:46
¿cómo está escrita? ¿quién la ha escrito? No 00:06:48
Viene en la librería de Java 00:06:49
Y nosotros estamos felices de utilizarla 00:06:51
Sin preguntarnos por qué funciona 00:06:54
Lo mismo hacemos aquí 00:06:55
Usamos esta clase scanner 00:06:57
Que nos permite de escanear el teclado 00:06:59
De leer cosas desde el teclado 00:07:02
¿Vale? 00:07:05
Para poder utilizarla 00:07:06
Tengo que hacer dos cosas 00:07:08
Tengo que poner esta línea de aquí 00:07:09
Que pone import 00:07:12
Espacio java.util.asterisco.com 00:07:14
Justo antes de public 00:07:17
Clase, el nombre de mi clase 00:07:21
Ahora lo veremos, ¿vale? ¿Dónde va? Hacemos un ejemplo 00:07:22
Esto es 00:07:25
Importa esta clase 00:07:27
Importa scanner 00:07:29
Si yo no importo scanner 00:07:31
Scanner me da un problema, me dice 00:07:33
No existe este scanner, ¿qué es scanner? 00:07:34
¿Vale? Si yo en vez lo importo 00:07:37
Entonces me dice 00:07:39
Ah, quieres utilizar el scanner 00:07:40
Que está indefinido en la librería 00:07:43
Java.util 00:07:45
Ok, perfecto, vamos a utilizar eso 00:07:46
¿Sí? 00:07:48
Y luego, tengo que crear 00:07:50
Una variable 00:07:53
Que se llama la scan 00:07:55
¿Vale? 00:07:56
Que es de tipo 00:07:58
Scanner, ¿vale? 00:08:01
Y esto 00:08:03
Nos complica un poco la cosa, no la entendemos 00:08:03
Esto sería un objeto 00:08:07
¿Vale? Y por ahora 00:08:08
No queremos entenderlo 00:08:10
Nosotros utilizaremos esta letra 00:08:12
Aquí, esta cosa aquí 00:08:14
Esta frase de aquí, justo para decir, oye, yo creo una cosa, una referencia, este scan, que me permitirá, utilizándola de la forma oportuna, vemos ahora, de leer cosas desde el teclado. 00:08:16
Es decir, que cuando yo ahora haré una determinada acción, ahora vamos a ver qué acciones son, mi programa se parará y estará a la espera de que mi usuario escriba algo en teclado y dé al Enter. 00:08:30
Mientras que el usuario no ha escrito y no ha dado Enter, yo me quedo allí parado tranquilo. 00:08:47
Entonces, esto de aquí va arriba del todo. 00:08:55
Este de aquí va ya dentro del main, ¿vale? 00:09:00
Y hay que escribirlo así. 00:09:05
Una cosa que nos puede interesar es que nosotros hemos usado System.out, ¿vale? 00:09:06
System.out.println. 00:09:12
Está este System.out porque es la salida del sistema. 00:09:14
Y aquí estamos utilizando System.in, la entrada del sistema. 00:09:18
Porque quiero pasar datos desde fuera del ordenador hacia el ordenador. 00:09:24
Entonces los datos entran 00:09:28
Ahí 00:09:31
Es un parámetro 00:09:31
Del objeto escándalo 00:09:36
Pero no sabemos que es 00:09:38
Pues nosotros escribimos esto tal y cual 00:09:40
Y funciona 00:09:42
Dentro de un rato cuando veremos que son los objetos 00:09:43
Entenderemos que es esto 00:09:47
Y entenderemos que es hacer esta frase 00:09:48
¿Sí? 00:09:50
Ok, una vez que yo he hecho estas dos líneas 00:09:52
Entonces he creado este 00:09:55
Objeto mágico que se llama scan 00:09:57
Dentro de mi 00:10:00
Dentro de mi programa 00:10:01
Yo puedo crear 00:10:03
Una variable por ejemplo cadena 00:10:05
Y decir que cadena 00:10:08
Es igual a scan.next 00:10:09
Vale 00:10:12
Scan.next 00:10:13
Lo que hace es 00:10:15
Parar el programa 00:10:17
El programa se para en esta línea 00:10:18
Y espera hasta que 00:10:21
El usuario haya escrito 00:10:24
una palabra y haya dado 00:10:26
intro 00:10:28
cuando este, el usuario ha escrito 00:10:28
una palabra y ha dado intro 00:10:32
esta palabra se guardará 00:10:33
dentro de la variable cadena 00:10:36
y a partir de ahora tengo 00:10:38
esa palabra, tú podrías poner aquí 00:10:39
dame tu nombre 00:10:52
string nombre, nombre 00:10:53
es igual a scan.nest 00:10:56
entonces el programa 00:10:58
escribe dame tu nombre, separa 00:10:59
espera que tú hayas 00:11:02
Escrito tu nombre, le he dado 00:11:04
Intro, y a ese punto 00:11:05
El nombre que he leído desde el teclado, lo meto 00:11:07
Dentro nombre y sigue adelante 00:11:09
¿Vale? 00:11:11
No lo sabemos, ¿vale? 00:11:17
Nosotros, por ejemplo, con un nombre 00:11:20
Con una string es fácil, porque string 00:11:21
Te pilla todo, ¿vale? 00:11:23
Con un int es más complejo, porque si yo te pido 00:11:25
Un número y tú me escribes gato 00:11:27
Pues él explotará, pobrecito, ¿vale? 00:11:28
¿Y qué sabemos hacer nosotros? 00:11:31
¿Sabemos hacer algo con esta explosión? No 00:11:33
¿Vale? Hasta que no veremos que son 00:11:35
las excepciones, pues no haremos nada 00:11:37
por ahora nosotros 00:11:39
asumimos, grosso 00:11:41
modo, que el usuario 00:11:43
es una persona capaz 00:11:46
y sabe, si le digo, dame tu nombre 00:11:47
me escribe su nombre, en vez de darme su DNI 00:11:49
¿vale? 00:11:51
luego, en un futuro, no 00:11:53
en un futuro, seremos nosotros 00:11:55
programadores, que cuando leo un número 00:11:57
tendré que antes de 00:11:59
utilizarlo, cerciorarme 00:12:01
que efectivamente me ha dado un número 00:12:04
y no me ha escrito su nombre 00:12:05
¿Sí? Pero por ahora no 00:12:06
Por ahora somos buenos 00:12:08
Y asumimos que los usuarios son capaces 00:12:10
¿Vale? Entonces 00:12:13
Quiero leer una palabra 00:12:14
Scan.nest 00:12:16
¿Y qué es esto? 00:12:18
La función, un método 00:12:27
¿Vale? Es un método 00:12:28
Definido en la clase Scanner 00:12:30
Se llama Scan porque tú has querido 00:12:32
Sí, lo podías llamar 00:12:37
Cocodrilo, gato, hay una variable 00:12:38
Es esto 00:12:40
Se llama Scan porque yo aquí he definido 00:12:42
scan, tipo 00:12:45
nombre variable, valor de la 00:12:47
variable, siempre igual 00:12:49
si aquí hago scanner 00:12:51
leer de teclado, todo junto 00:12:53
es igual a new scanner 00:12:55
entonces en vez de hacer scan.next 00:12:56
haré leer de teclado.next 00:12:59
ahora lo probamos esta cosa 00:13:03
leo una palabra 00:13:06
punto next 00:13:09
leo un entero 00:13:10
O sea, quiero tener un número 00:13:13
Entonces lo que sale de aquí es un int 00:13:15
Y lo puedo guardar en un int 00:13:18
Pues uso scan.nextInt 00:13:19
Fijaos 00:13:22
Que esta Y mayúscula 00:13:23
¿Sí? 00:13:26
Es como se usan los nombres 00:13:27
Estándar en Java 00:13:30
¿Vale? 00:13:32
Next es una palabra, empieza int que es otra palabra 00:13:33
Pues pongo la I mayúscula 00:13:36
¿Sí? No es nextLNT 00:13:37
Es una I mayúscula 00:13:40
que quiero leer 00:13:42
un double 00:13:45
pues hago 00:13:46
scan.nextdouble 00:13:48
y con esto suficiente para nosotros 00:13:51
podemos leer palabras 00:13:55
podemos leer enteros y podemos leer 00:13:56
números decimales 00:13:59
suficiente 00:14:00
se puede hacer cosas más complejas 00:14:01
si, existe un nextline 00:14:05
si no me equivoco, que lee una línea entera 00:14:06
y cosas así, pero como todavía 00:14:08
nosotros somos a un nivel 00:14:10
muy muy sencillo, pues no nos 00:14:13
complicamos la vida, ¿sí? 00:14:15
¡Cuidado! 00:14:17
Si me pide mi nombre 00:14:19
tengo que dar una palabra 00:14:21
no puedo poner 00:14:23
Estefano Espacio Chiesa 00:14:24
¿vale? Si pongo espacios 00:14:26
esto ya 00:14:29
funciona, ¿eh? Pero funciona de una forma 00:14:30
distinta, por lo tanto no lo hagáis 00:14:32
podéis pedir una palabra 00:14:34
un entero 00:14:37
o un double, si tengo que pedir 00:14:38
cinco palabras, las pido 00:14:41
de una en una, dame tu nombre 00:14:43
dame tu apellido, dame tu segundo 00:14:45
apellido, y por cada una de esas 00:14:47
haré una next 00:14:49
¿entiendes? 00:14:50
vale, vamos a probarlo, ¿no? 00:14:55
entonces, para probarlo 00:14:59
me hago otro ejercicio 00:15:01
que llamaré 00:15:02
prueba 00:15:08
entrada 00:15:09
y aquí tengo 00:15:11
Mi main, hemos dicho que 00:15:17
Lo que necesito 00:15:19
Es este 00:15:21
Scanner 00:15:23
Nombre de la variable 00:15:25
Normalmente usaréis scan 00:15:27
Es igual a 00:15:29
New scanner 00:15:31
De system 00:15:32
Punto i 00:15:34
Fijaos 00:15:37
Que se enfada 00:15:39
¿Vale? Porque me dice 00:15:40
Oye, esta cosa scanner de aquí 00:15:43
No la puedo resolver 00:15:45
Tú me la estás usando como tipo 00:15:49
Pero yo no soy capaz 00:15:51
De entender que es este tipo 00:15:54
¿Vale? 00:15:56
¿Por qué sabe que la está usando como tipo? 00:15:57
Porque aquí es la declaración de una variable 00:15:59
Y es tipo, nombre, valor 00:16:02
¿Sí? 00:16:04
Pues entonces, ¿qué es este escándalo? 00:16:06
No lo sé 00:16:08
Fijaos que entre las varias opciones 00:16:08
Que os da para solucionar esto 00:16:12
Esta crea una clase 00:16:14
Scanner 00:16:17
Crea un enumscanner 00:16:18
Crea cosas raras escanner 00:16:20
O importa 00:16:23
El escanner 00:16:25
Que está definido 00:16:27
En java.util 00:16:29
¿Qué es lo que quiero hacer yo? 00:16:30
Entonces 00:16:35
O lo escribo a mano 00:16:36
O pincho aquí 00:16:38
¿Vale? 00:16:40
Vamos a escribirlo a mano 00:16:42
Antes de public class 00:16:44
Aquí arriba del todo 00:16:48
Voy a poner 00:16:49
Import 00:16:51
Java.util 00:16:52
Punto 00:16:56
Y si os fijáis 00:16:57
Aquí me viene una lista de mogollón 00:16:59
De cosas 00:17:01
Y paquetes y cosas por el estilo 00:17:02
¿Vale? 00:17:06
Si yo pongo asterisco 00:17:06
Importo 00:17:08
Todo lo que está 00:17:11
Dentro de java.util 00:17:13
Java.util es un paquete 00:17:15
Una librería externa 00:17:19
Con clases 00:17:21
Y cosas por el estilo 00:17:23
Y yo todo lo que hay allí dentro 00:17:24
Lo importo en mi programa 00:17:26
¿Esto es eficiente? 00:17:27
No, porque yo voy a usar solo scanner 00:17:33
Y estoy importando un mogollón de cosas 00:17:35
¿Si? 00:17:37
Pero si no me acuerdo 00:17:39
Como ahora estamos aprendiendo 00:17:41
Puede hacerlo así 00:17:42
Para hacerlo bien, como voy a necesitar 00:17:43
Scanner, aquí podría poner 00:17:46
Scanner 00:17:48
Impórtame solo 00:17:48
La que voy a utilizar 00:17:51
Entonces no me está importando 00:17:53
Todo lo que está en el paquete 00:17:55
Java.util, me está importando solo 00:17:57
La clase que voy a utilizar 00:17:59
Pero que no me acuerdo o que no lo entiendo 00:18:01
Porque todavía es pronto, pues pongo asterisco 00:18:04
Y ya está, fijaos que 00:18:06
En un caso o en el otro 00:18:07
Ya no me da error aquí 00:18:09
Ahora dice 00:18:11
Tú quieres usar 00:18:12
Scanner aquí, vale 00:18:15
Y has importado este 00:18:17
Scanner, entonces ese es el que quieres 00:18:19
Usar, vale, fenomenal 00:18:21
¿Sí? Entonces 00:18:22
Hasta si no los entiendo 00:18:25
Porque hasta que no llego a los 00:18:26
Objetos, estas cosas son 00:18:29
Un poco 00:18:31
Complejas de entender, pues 00:18:31
Estas dos líneas 00:18:34
Son la base para poder 00:18:36
Empezar a 00:18:38
Para configurar la posibilidad de leer de teclado 00:18:40
Si no tengo estas dos cosas 00:18:44
No puedo leer de teclado 00:18:46
Pero todavía no lo he leído 00:18:48
¿Dudas? 00:18:49
Vale 00:18:57
Entonces, con esto he activado la posibilidad de leer 00:18:57
¿Cómo leo? 00:19:00
Pues vamos a leer 00:19:02
Y digo 00:19:03
Leemos una palabra 00:19:06
String 00:19:09
Nombre 00:19:10
Es igual a 00:19:12
scan.next 00:19:14
y luego me escribo 00:19:17
system.out.println 00:19:22
y me saludo 00:19:30
hola 00:19:33
más nombre 00:19:35
¿os acordáis? antes que hacía yo 00:19:38
yo aquí me creaba string nombre 00:19:42
y decía Estefano 00:19:45
entonces ahora me decía hola Estefano 00:19:46
Vale, hola Stefano 00:19:48
Pero si quería cambiar el nombre 00:19:53
A otro nombre 00:19:56
Pues tenía que entrar dentro del código 00:19:57
Tenía que ser un programador 00:20:00
Tener el eclipse, entrar dentro 00:20:01
Cambiar el nombre 00:20:03
Y volver a recompilar todo 00:20:04
Guardar, recompilar 00:20:07
Pues no, yo eso no lo quiero hacer 00:20:09
Entonces, aquí tengo mi programa 00:20:10
Lo lanzo 00:20:13
Y mi programa lo que hace es 00:20:14
Nada 00:20:16
Pero 00:20:18
Mirad esto 00:20:22
Chan chan 00:20:25
Chan chan 00:20:28
¿Sabéis que es esto? 00:20:30
Quiere decir que mi programa 00:20:35
No ha acabado 00:20:37
Sigue allí funcionando 00:20:39
Mi programa ha arrancado 00:20:41
Y está allí a la espera 00:20:44
Es bloqueado 00:20:46
Esperando a que funcione 00:20:47
Cualquier otro programa 00:20:49
Que vosotros habéis lanzado 00:20:51
Este de aquí se vuelve rojo un átimo 00:20:52
Y luego se vuelve gris 00:20:55
Porque cuando acaba, esto se acaba 00:20:56
Y de hecho, si yo tengo problemas 00:20:59
Y quiero terminar un programa 00:21:01
Que se está ejecutando 00:21:03
Pinchando aquí 00:21:04
Lo mato, lo termino 00:21:06
¿Vale? 00:21:08
Pero el hecho que esto esté rojo 00:21:10
Quiere decir que este programa no ha acabado 00:21:11
¿Dónde está este programa? 00:21:14
Está aquí 00:21:16
Está a la espera 00:21:16
De que yo le escriba algo 00:21:20
Entonces le escribo algo 00:21:23
Estefano 00:21:25
Intro 00:21:26
Y él me dice, hola Estefano 00:21:30
Y ahora sí que ha terminado 00:21:32
¿Y por qué esto? 00:21:34
Porque yo no le he dicho en ningún momento 00:21:38
Oye, dirá al usuario 00:21:41
Que tiene que hacer 00:21:43
Entonces, acordaos que 00:21:44
Antes de hacer un scan.next algo 00:21:46
Siempre hay que decir al usuario 00:21:50
Que te esperes que haga el usuario 00:21:53
Porque si vosotros arrancáis un programa 00:21:55
Y veis una pantalla en blanco 00:21:57
Estáis allí y miráis y no os dice nada 00:21:59
Pues no sabéis que tenéis que hacer 00:22:00
Entonces vamos a ponerle antes 00:22:02
Hola 00:22:05
Usuario 00:22:09
Dime tu nombre 00:22:11
Escribe 00:22:15
Escribe tu nombre 00:22:17
Entonces ahora lo ejecuto 00:22:20
Y ahora me dice 00:22:27
Hola usuario, escribe tu nombre 00:22:28
Y ahora ya sé que tengo que hacer 00:22:30
Este está parado 00:22:32
Y estará a la espera que yo escriba mi nombre 00:22:33
Y pongo ahora 00:22:36
Sara 00:22:38
Y me dice, hola Sara 00:22:38
Fijaos, vuelvo a ejecutarlo 00:22:41
Sin tocar el código 00:22:46
Y sin compilarlo 00:22:48
Lo re ejecuto 00:22:49
Y ahora le digo que me llamo Antonio 00:22:50
y me dice, hola Antonio 00:22:53
¿entendéis la diferencia 00:22:56
entre lo que había 00:23:01
antes y lo que 00:23:04
está pasando ahora? 00:23:06
que antes mi programa valía 00:23:07
solo para un nombre 00:23:09
y ahora he hecho un programa 00:23:10
abstracto que vale para 00:23:13
cualquier nombre del multiverso 00:23:15
y eso no es poco 00:23:17
diga 00:23:20
este último proceso cual lo escrito aquí esto y ha escrito escribe o los 00:23:23
aires entonces él me escribirá esto y donde se bloquea donde es que el 00:23:39
programa se bloquea la espera de un input del usuario en esta línea de aquí 00:23:43
entonces todo lo que viene antes de esta línea es lo ejecutará ello le echó 00:23:48
escribe oye mira hola dame tu nombre que así el usuario cuando se bloquea el 00:23:53
programa sabe que tiene que hacer si al usuario no le he dicho escribe tu nombre 00:23:58
que sabe él si tiene que poner una password tiene que poner su nombre su 00:24:02
edad o lo que sea 00:24:06
entonces sigamos con nuestro programa he leído un nombre lo he saludado que ahora 00:24:12
le puedo decir oye dime dame tu edad y te digo cuántos años ha vivido no por 00:24:20
ejemplo entonces le digo si escribe tu edad y te diré cuántos días has vivido y que ahora 00:24:25
Si pongo string edad 00:24:57
¿De qué problema tengo? 00:25:15
Que luego tengo que hacer edad por 365 00:25:17
¿Cómo lo hago? 00:25:19
Un nombre, una palabra por 365 00:25:20
Int 00:25:23
Edad 00:25:28
Es igual a qué? 00:25:29
Scan 00:25:32
Punto 00:25:33
Fijaos que aquí me vienen las opciones 00:25:35
Que tengo con scan 00:25:38
Cuando pongo scan punto 00:25:39
Me dice que quieres 00:25:43
Next int, next byte, next short 00:25:44
Find all, find in line 00:25:47
As next, as long 00:25:49
Todos los métodos que puedo utilizar 00:25:51
Con esta cosa 00:25:54
Pero bueno, a mi me interesa 00:25:55
Next int 00:25:57
Y ahora que hago 00:25:58
Como 00:26:02
De string a int 00:26:08
Más complejo de lo que parece 00:26:15
No es tan fácil 00:26:17
Porque 00:26:20
¿Qué es string? 00:26:21
String es una concatenación de char 00:26:24
Entonces lo que irá 00:26:26
Si tú le dices trártalo como int 00:26:28
Te pillará la char 00:26:31
El valor que tiene 00:26:32
Y te dice ese es su número 00:26:34
El número 1 no corresponde al valor 1 00:26:36
Como char 00:26:38
Corresponde al valor 36 00:26:39
Entonces explota 00:26:40
No, hacemos con el siguiente que es más fácil 00:26:41
Y digo 00:26:45
Has vivido 00:26:45
Más 00:26:48
¿Cómo lo he llamado? 00:26:50
Edad 00:26:55
Edad por 365 00:26:55
Más 00:26:58
Días 00:27:01
Fijaos 00:27:04
¿Sé yo la edad del usuario? 00:27:10
¿Por algún lado alguien me ha dicho cuánto vale esta edad? 00:27:14
¿Cuándo lo sabré? 00:27:19
En tiempo de ejecución 00:27:20
Es cuando ejecuto el programa 00:27:22
Que el programa se parará 00:27:28
Aquí 00:27:30
A la espera que el usuario me ponga un dato 00:27:31
Y yo usaré ese dato 00:27:34
Para hacer este cálculo 00:27:36
Vamos a ver cómo funciona 00:27:38
Luego volvemos aquí 00:27:42
Play 00:27:43
¿Cómo te llamas? 00:27:45
Estefano 00:27:48
Escribe tu edad 00:27:49
Y te diré cuántos días has vivido 00:27:54
Vale, 41 00:27:56
Has vivido 00:27:57
Y fijaos que este dato 00:28:03
Si este dato 00:28:07
Hasta que no lo ha escrito 00:28:08
El no lo sabía 00:28:11
Lo va utilizando 00:28:12
Pero el no lo ha sabido 00:28:14
Hasta que el usuario lo ha puesto 00:28:16
Es una cosa importante 00:28:18
Porque esto me permite 00:28:19
Extraer mucho 00:28:21
Aumentar muchísimo 00:28:23
El rango de problemas que puedo solucionar 00:28:25
Antes podía solucionar un problema solo 00:28:28
El señor Estefano con 41 años 00:28:30
Ahora puede solucionar cualquier problema 00:28:33
De cualquier usuario 00:28:36
Cualquier nombre de usuario 00:28:38
Cualquier edad 00:28:39
Eso es mucho 00:28:41
Un buen salto 00:28:42
¿Dudas? 00:28:45
Resource leak 00:29:16
Scan is never closed 00:29:17
Scan punto close 00:29:18
sabemos que es no fuera el campo punto cloud dudas los recursos que yo uso normalmente los 00:29:25
creo los uso y cuando ya no los uso los tengo que cerrar o destruir en java existe una cosa 00:29:50
se llama el java garbage collector por garbage collector que es sustancialmente que todas las 00:29:59
cosas que no se usan pasa el en automático en libera memoria para que no 00:30:05
se quedan allí recursos utilizados que luego no se utiliza vale es lo que me 00:30:11
está diciendo aquí me dice oye mira tú has creado este objeto si no lo cierras 00:30:16
este objeto se queda y abierto y gasta recursos y para que vale entonces 00:30:20
dice por algún lado deberías marcar que ya no lo necesito más para que el 00:30:28
garbage collector pueda pasar pero como nuestro programa luego acaba cuando 00:30:33
acaba limpia todo entonces no hay problema si esto fuera un programa que 00:30:39
después de haber hecho esto hiciera otra cosa y se queda aquí un año trabajando 00:30:42
haber dejado abierto esto sin haberlo utilizado nunca jamás me ha creado un 00:30:46
memory link un uso de memoria impropio dudas 00:30:50
vale veamos si lo puesto lo que pasa es yo le doy aquí como te llamas stefano 00:31:04
¿Cuál es tu edad? 00:31:15
Veinte cinco 00:31:17
Así, así, no sé 00:31:20
¿Mi edad? 00:31:21
¿Qué hace? 00:31:23
Explosión 00:31:28
Lo que se llama 00:31:29
Una exception 00:31:32
Input mismatch exception 00:31:33
Error, digámoslo así 00:31:36
De input no correspondiente 00:31:39
Tú has dicho un int 00:31:43
Y has puesto un string 00:31:44
Exploto 00:31:45
String 00:31:46
¿Dudas? 00:31:53
A mí no me sale eso 00:32:00
Vale, entonces, esperad un segundo 00:32:01
Hagamos una pausa 00:32:04
Autor/es:
Stefano Chiesa
Subido por:
Stefano C.
Licencia:
Reconocimiento
Visualizaciones:
7
Fecha:
29 de septiembre de 2023 - 13:15
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
32′ 07″
Relación de aspecto:
4:3 Hasta 2009 fue el estándar utilizado en la televisión PAL; muchas pantallas de ordenador y televisores usan este estándar, erróneamente llamado cuadrado, cuando en la realidad es rectangular o wide.
Resolución:
960x720 píxeles
Tamaño:
148.64 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid