Saltar navegación

20250923-ProgEstr-Variables_8 - Contenido educativo

Ajuste de pantalla

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

Subido el 24 de septiembre de 2025 por Raquel G.

4 visualizaciones

Más información Transcripción

Descargar la transcripción

Vale, vamos a nuestro ejemplito, pues por ejemplo, lo que hemos hecho antes, vale, tengo mi variable n1, vale, entonces ahora ya que estamos aquí, que se ve más claro, igual que hemos dicho que se puede dar valor a una variable a la vez que la declaras, asignar un primer valor o inicializar, 00:00:00
también hay una cosa que podemos hacer 00:00:39
por comodidad, que es 00:00:41
cuando estamos declarando varias 00:00:43
variables del mismo tipo 00:00:45
no hace falta que hagamos una línea por cada una 00:00:47
porque sería un rollo, si yo estoy 00:00:50
declarando n1 y n2 00:00:51
las dos enteras 00:00:53
pues no hace falta 00:00:55
que haga esto, una por 00:00:57
línea, se haría muy pesado 00:01:00
podemos declararlas todas en la misma 00:01:01
línea, separadas 00:01:04
por comas, ¿vale? 00:01:05
entonces 00:01:10
En esta línea separadas por coma 00:01:11
Puedo poner las variables que me dé la gana 00:01:14
Y estoy declarando todas esas variables de tipo entero 00:01:16
Que además quiero inicializar alguna de ellas 00:01:20
Claro que puedo 00:01:24
Si quiero además a n1 darle 9 00:01:24
Estaría haciendo la inicialización de n1 00:01:28
Que quiero a n2 además darle otro valor 00:01:31
Se lo doy 00:01:34
Luego en la misma línea puedo declarar variables del mismo tipo 00:01:36
Del mismo tipo 00:01:40
¿Vale? 00:01:42
Y además inicializarla si quiero 00:01:44
Tantas variables como quiera 00:01:47
Aquí podría seguir poniendo variables todas las que quiera 00:01:50
Y así ahorro líneas de código 00:01:52
Simplemente, solo para ahorrar líneas de código 00:01:55
Vale, pues entonces 00:01:56
En nuestro caso, que teníamos este ejemplito de aquí 00:01:58
Ahora 00:02:01
Podemos 00:02:03
Poner una expresión 00:02:04
Que sea, pues venga 00:02:07
Menos 4 00:02:10
Multiplicado por 00:02:12
No, N1 no, N2, perdón 00:02:17
¿Eh? 00:02:22
No, a N1 no le he dado valor, le he dado N2 solo 00:02:25
Entre N3 00:02:28
Vale, entonces 00:02:31
Esto 00:02:33
En cuanto a expresión 00:02:34
Es válida 00:02:36
Esta operación es correcta 00:02:38
Esto es correcto, esto es correcto 00:02:41
N2 y N3 tienen valores asignados, N2 tiene 12 y N3 tiene 15, que son las únicas dos variables que están aquí, pero me sigue saliendo error de compilación, ¿cuál? Pues el que os he dicho, si ponéis ahí la manita, nos dice, oye, perdona, pero de long hind no puedo, claro, ¿por qué? 00:02:43
por la promoción automática que ya hemos visto 00:03:06
n2 menos 4 es un entero 00:03:09
porque n2 es entero 00:03:11
vale, vamos a quitar esto ya para que no moleste 00:03:13
n2 es entero 00:03:15
luego n2 menos 4 es entero 00:03:17
lo multiplico por n2 otra vez 00:03:19
otra vez por 12, sigue siendo entero 00:03:21
y ahora ya me queda 00:03:23
un entero que divide a un long 00:03:25
una operación 00:03:28
de estas aritméticas que involucra 00:03:31
long e int 00:03:33
el int se promociona long añadiendo ceros 00:03:35
vale, se queda en long 00:03:38
va a n1 00:03:40
n1 es int 00:03:42
pues me dice el compilador 00:03:43
no, no puedo 00:03:45
tendríamos que arreglarlo 00:03:46
declarando n1 como long 00:03:49
si no este error de compilación no se quita 00:03:52
entonces en ese caso 00:03:54
ya no podría en la misma línea 00:03:56
hacer n1 y n2 00:03:58
ya no podría 00:04:00
dejaría n2 aquí y me declaro 00:04:01
n1 aquí por ejemplo 00:04:04
entonces ahora ya se me ha quitado 00:04:05
el error de compilación porque tengo 00:04:09
n1 como long 00:04:10
n3 como long como estaba 00:04:11
¿vale? y ahora ya 00:04:14
si mostramos lo que tiene 00:04:19
será el último numerito que muestre 00:04:21
porque aquí arriba habrá cosas 00:04:25
pues este es 00:04:27
el resto de 00:04:33
el resultado de esta división 00:04:34
que es el cociente 00:04:37
el cociente 00:04:39
porque está involucrando 00:04:41
números enteros a los dos lados 00:04:43
números enteros, luego es operador 00:04:45
es cociente 00:04:48
¿vale? 6 00:04:48
para 00:04:50
poder hacer algunas cosas 00:04:54
cuando pongamos ejemplos 00:04:58
y que no sea tan pesado al principio 00:05:00
vamos a meter 00:05:02
desde ya como le puedo dar yo 00:05:04
valores por teclado, porque con lo que 00:05:06
sabemos ahora, todos nuestros 00:05:08
programas 00:05:10
necesita que yo desde el propio código 00:05:11
le ponga el valor a la variable 00:05:14
esa no es la forma habitual de trabajar 00:05:16
por ejemplo 00:05:18
vamos a 00:05:20
hacer un programa 00:05:22
me voy a hacer aquí otra clase 00:05:25
vamos a hacer un programa 00:05:28
para que 00:05:31
haga el doble de un número 00:05:34
vale 00:05:38
la llamo doble a la clase, 00:05:41
vale, pues venga, un programita, 00:05:51
¿qué quiero yo que haga este programita? 00:05:54
Programa que calcule el doble de un número. 00:06:04
Vale, que calcule y muestre. 00:06:11
Bueno, pues entonces, 00:06:19
este programa va a operar 00:06:23
con un dato 00:06:26
entonces aunque es un programa muy sencillo 00:06:27
nos permite usarlo como base 00:06:29
para secuenciar un poquito 00:06:31
las 00:06:34
las siguientes etapas 00:06:35
las diferentes etapas que seguimos nosotros 00:06:37
cuando hacemos un ejercicio 00:06:39
o un programa o una aplicación 00:06:41
entonces primero 00:06:43
veo el enunciado y entiendo 00:06:45
exactamente lo que hay que hacer 00:06:48
si hay alguna duda 00:06:49
lo pregunto 00:06:50
Por ejemplo, lo que yo había escrito antes 00:06:52
Estaba muy mal escrito 00:06:55
Muy ambiguo 00:06:58
Entonces un programador 00:06:59
Se entrevista con un cliente 00:07:00
El cliente le dice 00:07:03
Oye, quiero un programa que calcula el doble de un número 00:07:04
Pues si es un buen analista 00:07:06
Porque el que se entrevista con el cliente 00:07:09
Es el analista 00:07:11
Pues si es un buen analista 00:07:12
El analista dirá 00:07:14
A ver, espérate, vamos por partes 00:07:15
Porque esto que tú me has dicho es absolutamente ambiguo 00:07:17
Primero 00:07:20
ese número 00:07:21
¿qué tipo quieres que sea? 00:07:23
entero, decimal 00:07:26
para empezar especificame 00:07:27
con qué números quieres trabajar 00:07:30
entonces diría, ah no, lo quiero solo para enteros 00:07:31
vale, pues tú ya vas arreglando 00:07:34
el planteamiento de tu 00:07:36
programa para que luego ya 00:07:37
los programadores lo puedan hacer 00:07:39
pero tú estás haciendo la parte más difícil 00:07:42
como analista, que es espérate 00:07:44
espérate, vamos a dejarlo claro 00:07:46
entero, vale, siguiente 00:07:47
¿qué es esto de que calcule? 00:07:49
Los programas devuelven datos, eso de calcular es una operación, una sentencia, pero un programa coge datos y devuelve datos, entonces, ¿qué significa calcular? Con el doble de ese número, ¿qué quieres hacer? Llevarlo a un fichero, mostrármelo a mí por consola, no hacer nada, tirar la basura, o sea, los programas devuelven datos. 00:07:51
entonces, lo primero que tiene que preguntar 00:08:15
el que está tratando de entender el enunciado 00:08:18
con ese dato 00:08:21
que devuelve el programa, ¿qué quieres hacer? 00:08:23
porque aquí lo han especificado 00:08:26
ah, no, lo que quiero es que lo calcules 00:08:27
y ese dato resultante 00:08:30
lo muestres 00:08:32
por la consola para que yo lo vea 00:08:33
porque yo voy a estar ahí sentado todo el rato 00:08:35
cada vez que ejecute el programa voy a estar sentado 00:08:37
todo el rato viendo el resultado 00:08:40
ah, vale 00:08:41
pues entonces 00:08:42
calcule y 00:08:44
muestre 00:08:47
por consola 00:08:50
vale, esto ya parece, es un anunciado 00:08:52
un poquito menos ambiguo 00:08:57
y ahora ya 00:08:59
el analista se tiene que 00:09:01
pensar si ya tiene toda la información 00:09:02
que necesita o todavía tiene que 00:09:05
preguntarle más cosas al cliente 00:09:07
bueno, yo creo que con esto más o menos está claro 00:09:09
que tiene que hacer el programa 00:09:11
vale 00:09:11
a ver, no está claro 00:09:14
porque precisamente lo voy a usar para meterlo 00:09:16
en los datos de entrada 00:09:18
no estaría claro porque 00:09:20
la siguiente pregunta que tendría 00:09:22
que hacer es 00:09:24
¿este número entero con el que va a trabajar 00:09:25
¿de dónde lo sacas? 00:09:28
¿el doble o un número entero? 00:09:31
¿de qué número entero? 00:09:33
¿del que a mí me dé la gana? 00:09:34
¿de uno que tú me des? 00:09:37
¿vamos a hacer la versión? 00:09:40
no, no, del que a ti te dé la gana 00:09:41
vale 00:09:42
pues vamos a añadir eso 00:09:44
el que al programador le dé la gana 00:09:46
bueno, puede no tener sentido 00:09:49
pero al menos se ha anunciado, ya no es ambiguo 00:09:55
el número que al programador 00:09:58
le dé la gana 00:10:00
calculará el doble 00:10:01
y lo mostrará por consola 00:10:03
ahora ya sí que está claro lo que hay que hacer 00:10:05
necesitamos más datos 00:10:07
pues ahora ya 00:10:08
resulta esto 00:10:09
pues al equipo, a los diseñadores 00:10:13
a HGPT, a quien te dé la gana 00:10:15
y ya lo puedes hacer 00:10:16
porque tienes toda la información previa. 00:10:19
Pero la parte de análisis es la complicada, ¿vale? 00:10:21
Es la que no te va a hacer echar GPT 00:10:24
en condiciones normales. 00:10:26
Cuando ya esté toda la parte de robótica 00:10:29
para que te puedas entrevistar con el cliente, sí. 00:10:32
Pero antes, pues no. 00:10:34
Bueno, pues vamos a hacer este programa. 00:10:36
Vale, ya tenemos esa parte, el análisis. 00:10:38
Ahora, ya vamos a programar. 00:10:43
Y lo primero que tenemos que pensar es, ¿con qué datos va a trabajar mi aplicación? 00:10:46
Vuelvo a el enunciado, que ya no estará ambiguo, porque para eso lo hemos pensado bien, que ya no estará ambiguo. 00:10:52
Y digo, ¿va a trabajar con un número entero? 00:10:59
Pues automáticamente, en cuanto pienso en datos, tengo que pensar en las variables donde van a caer esos datos. 00:11:08
pensar en datos es pensar en las variables 00:11:14
que voy a necesitar para esos datos 00:11:18
¿vale? pues mi dato va a ser un número entero 00:11:20
pues automáticamente pienso en una variable entera 00:11:23
que tengo que poner en mi programa para que caiga ese dato 00:11:26
venga, pues ya está una variable entera 00:11:29
aquí va a ir mi dato, mi número 00:11:32
¿vale? 00:11:35
y ahora, ¿qué tiene que hacer el programa con ese número? 00:11:38
calcular el doble 00:11:42
vale, pues entonces vamos a hacerlo 00:11:45
aunque sea una tontería 00:11:47
vamos a hacerlo paso por paso 00:11:49
para calcular el doble 00:11:50
yo tendré que hacer una expresión 00:11:53
espera, espera, espérame 00:11:54
el que, el que por favor le dé la gana 00:12:00
entonces vamos a seguir, ahora volvemos ahí 00:12:02
de donde sale este número, vale 00:12:04
vamos por partes, un segundo 00:12:05
vale, entonces, el dato va a estar ahí 00:12:07
ahora veremos 00:12:10
cómo recibe el valor 00:12:12
como recibe, pero el dato va a estar ahí, el que sea 00:12:13
vale, sea cual sea lo que tenga esa variable 00:12:16
sea lo que sea, para calcular el doble 00:12:21
necesito una expresión, mi expresión cuál va a ser 00:12:25
pues esta, dato por 2, esa es mi expresión 00:12:29
este va a ser el resultado, entonces claro 00:12:33
el resultado en condiciones normales tendría que guardarlo en algún sitio, los resultados 00:12:37
se guarda en algún lado 00:12:41
pues venga, me voy a declarar una variable entera 00:12:42
para el resultado 00:12:46
para que se vea 00:12:47
lo voy a poner en líneas separadas, aunque sea 00:12:49
vale, pues venga 00:12:51
el resultado 00:12:54
luego 00:12:56
ahora continuamos con ese rojo 00:12:58
entonces 00:13:02
aunque sea con este ejemplo sencillo 00:13:03
los pasos mentales 00:13:06
siempre son los mismos 00:13:08
una vez que tengo claro lo que hay que hacer 00:13:08
mis datos de entrada, ¿cuáles son? 00:13:11
Estos, variables para esos datos. 00:13:13
¿Mi resultado cuál va a ser? 00:13:17
En este caso va a ser un número entero, 00:13:19
pues una variable para ese resultado. 00:13:21
Podrían ser muchos los resultados, 00:13:25
pues muchas variables. 00:13:27
Entonces, tanto los datos de entrada 00:13:28
como los resultados del programa 00:13:30
eran variables para estar guardados. 00:13:32
Pues en este caso, 00:13:35
aquí va a ir mi dato de entrada. 00:13:36
Aquí voy a guardar el resultado 00:13:39
del programa 00:13:41
¿el resultado del programa cuál es? 00:13:42
en este caso hacer una operación 00:13:44
el número que haya aquí por 2 00:13:46
esto va a mi resultado 00:13:49
¿y qué tiene que hacer? 00:13:51
oye, mostrarlo, hemos dicho que mostrarlo 00:13:52
mostrar por consola sea hacerlo 00:13:55
entonces 00:13:57
pues ya está, venga 00:13:59
resultado 00:14:01
vale, ahora 00:14:02
vamos a esto al que el programador le dé la gana 00:14:04
ahora claro, este programa 00:14:08
queda por refinar 00:14:10
no perdáis nunca de vista 00:14:12
que no se programa así 00:14:14
tirando una línea de código tras otra 00:14:16
jamás 00:14:18
se va programando 00:14:20
que lo iremos viendo 00:14:22
o sea, se irá poniendo más en 00:14:25
se irá poniendo 00:14:27
se irá haciendo más visible según vayamos programando 00:14:28
uno programa siempre 00:14:31
por lo que podríamos llamar 00:14:33
iteraciones sucesivas 00:14:34
o sea, va haciendo un esqueleto con cajitas negras 00:14:36
y va a editar esto y esto y esto 00:14:39
Ahora relleno mi cajita negra 00:14:41
Ah, esta parte ya sé hacerla, vale 00:14:43
Luego tendré que hacer esto que todavía no sé 00:14:45
Pero aquí debajo irá esto 00:14:47
Voy rellenando mis cajas negras 00:14:48
Un programador jamás programa tirando dinero una tras otra 00:14:50
Porque no se piensa así 00:14:53
No pensamos secuencialmente 00:14:55
En realidad 00:14:57
Vemos las cosas en su conjunto 00:14:59
Vamos resolviendo problemas 00:15:01
Y luego vamos componiendo 00:15:03
Las diferentes soluciones parciales 00:15:04
¿Vale? Y para componer un problema 00:15:07
tenemos a que a veces haber resuelto otro 00:15:09
que se va a presentar después, etc. 00:15:12
Bueno, pues entonces, 00:15:15
yo he hecho mi primer esqueleto del programa. 00:15:17
Ahora voy a lo siguiente, 00:15:20
que es, vamos a ver, 00:15:22
lógicamente, como era de prever, 00:15:23
aquí me sale el error de compilación, 00:15:25
que es, uy, estás usando una variable, 00:15:27
una expresión que no tiene nada. 00:15:30
Eso ya hemos dicho, que es un error 00:15:32
que lógicamente va a salir 00:15:33
si en una expresión uso una variable 00:15:35
que no tiene nada, que es lo que me dice aquí. 00:15:37
la variable dato no está inicializada 00:15:39
es lo que me está diciendo 00:15:42
vale 00:15:45
claro, es que esto liga con 00:15:45
es que este es mi dato de entrada 00:15:48
y yo te he preguntado a ti, cliente 00:15:50
¿cuál quieres que sea el dato de entrada 00:15:52
para hacer el doble? 00:15:54
tú me has dicho el que me dé la gana 00:15:55
pues como tú me has dicho el que me dé la gana 00:15:56
me da la gana el 9 00:15:59
y lo planto ahí 00:16:03
y sí, este código tan estúpido 00:16:04
resuelve el problema que me han planteado 00:16:07
el número que a mí me dé la gana 00:16:09
calcula el doble 00:16:11
y muéstralo por consola 00:16:13
y si ejecutamos este código 00:16:15
pues me va a mostrar 00:16:17
18, lógicamente 00:16:19
vale 00:16:21
pero claro, este programa 00:16:22
yo lo puedo ejecutar 00:16:26
27.000 veces y las 27.000 00:16:27
me va a dar 18 00:16:30
porque solo trabaja para el 9 00:16:31
porque es el que he puesto aquí 00:16:34
eso no tiene ningún sentido 00:16:35
y si yo quiero que este programa 00:16:37
me calcule el doble de cualquier número 00:16:39
pues el proceso es muy complicado 00:16:41
porque tiene que coger el programador 00:16:42
o sea, yo como cliente 00:16:45
que me han dado este programa 00:16:47
digo, perdona, es que ahora quiero el doble de 15 00:16:48
pues 00:16:51
tengo que ir al programador y decirle 00:16:52
oye, cambia el programa y pon 15 00:16:55
porfa, venga 00:16:56
pon 15, que ahora quiero el doble de 15 00:16:58
venga, vale 00:17:00
30, entonces cada vez que 00:17:02
yo como cliente que he recibido 00:17:08
esta aplicación quiera calcular el doble 00:17:10
de otro número, tengo que ir a la 00:17:12
empresa de software y decirle 00:17:14
oye, hacedme otra versión que ahora 00:17:16
lo calcule de 90, hacedme otra versión 00:17:18
que lo calcule de 30. Es estúpido 00:17:20
lógicamente. Entonces 00:17:22
lo habitual 00:17:24
es que los 00:17:25
datos de entrada de una aplicación 00:17:28
los podamos recoger 00:17:30
en tiempo de ejecución 00:17:32
desde la consola, desde 00:17:34
del teclado, entonces 00:17:36
nuestro programa es siempre el mismo 00:17:38
pero cuando se ejecuta 00:17:39
te pide el 00:17:42
dato y te dice, ¿qué dato quieres este? 00:17:44
tú se lo metes y ya está 00:17:45
y la aplicación trabaja con esto 00:17:47
entonces, aquí 00:17:49
lo que nos gustaría es 00:17:52
en lugar de poner un valor 00:17:54
tal cual, poner 00:17:56
un valor que hayamos leído del teclado 00:17:58
de lo que llamamos la consola 00:18:00
¿vale? es lo que querríamos 00:18:06
¿vale? pues entonces, para 00:18:07
poder empezar a hacer 00:18:14
programas que tengan sentido y no tengamos que 00:18:16
estar cambiando el dato de entrada todo el rato 00:18:18
ahí dentro 00:18:20
vamos a incorporar como era un valor del teclado 00:18:20
y ya está 00:18:24
es una línea 00:18:24
que es una línea que no vamos 00:18:28
a entender, bueno son dos, pero 00:18:30
tenemos que incorporarla desde ya para poder hacer programas operativos 00:18:32
pues venga 00:18:34
entonces eso implicaría 00:18:36
el doble de un número entero, ahora no 00:18:37
ya el que al programador le dé la gana 00:18:40
sino un número 00:18:42
Introducido por teclado 00:18:43
Por el usuario 00:18:47
Ahora este programa ya tiene sentido 00:18:51
Un número introducido por el usuario 00:18:54
Te calcula el doble y te lo muestra 00:18:57
Vale 00:18:59
Pues entonces 00:19:01
Para leer por teclado 00:19:03
Introducido por el usuario del programa 00:19:09
Vale, pues para leer por teclado 00:19:11
Necesitamos 00:19:17
Algo que sea capaz 00:19:19
De engancharse al teclado y leer 00:19:25
Que es lo que llamamos 00:19:26
Un objeto lector 00:19:28
Yo ahora lo explico 00:19:29
Así para que no suene a que pongo 00:19:35
La línea y punto pelota 00:19:37
Pero eso no significa que podamos entender 00:19:38
Que es un objeto y nada de eso 00:19:41
Aunque bueno, desde ya 00:19:42
Podemos decir 00:19:45
que en Java 00:19:45
hay variables, está claro 00:19:48
y luego sentencias que operan con las variables 00:19:50
esas variables son 00:19:53
de los tipos que hemos dicho, aunque nos falta 00:19:54
por ver cómo funcionan algunos 00:19:56
esas variables son de los tipos 00:19:58
que hemos dicho, o también 00:20:00
pueden ser objetos, que serían variables 00:20:02
un poco más complejas 00:20:04
¿vale? que ya las veremos 00:20:05
con relación a todos los objetos, pues esas variables 00:20:08
que pueden ser objetos, además 00:20:10
de tener datos dentro, como el int, el double 00:20:12
que tiene su dato dentro, además de eso 00:20:14
resulta que puede hacer cosas 00:20:16
las variables 00:20:18
como indabel, estas que hemos visto 00:20:21
que son las que se llaman primitivas 00:20:23
estos ocho tipos son los que se llaman 00:20:25
primitivos 00:20:27
pues las variables de esos ocho tipos 00:20:28
sirven para guardar un dato 00:20:31
y para nada más 00:20:33
y para luego entregarlo en una expresión 00:20:34
si le pones una expresión, lo entrega, claro 00:20:36
pero no vale para nada más 00:20:38
las variables que son objeto 00:20:40
que son raras y distintas 00:20:42
a estas, además de 00:20:44
para tener un dato dentro guardado 00:20:46
además de para eso, que también valen 00:20:48
valen para hacer cosas muy chulas 00:20:50
bueno, pues 00:20:52
yo si consigo hacer aparecer 00:20:54
aquí un objeto 00:20:56
lector, una variable objeto lector 00:20:58
que sepa leer del teclado 00:21:00
pues ya está, le mando que lea 00:21:02
y se acabó, lo tengo todo hecho 00:21:04
vale, pues 00:21:05
¿cómo creamos ese objeto lector? 00:21:08
lo creamos así 00:21:11
Y esto sí que ahora mismo nos lo vamos a tener que creer, ¿vale? 00:21:12
Ahora mismo vamos a tener que creer que este es un objeto lector que se llama scan, 00:21:25
que lo he creado, un objeto lector, y ahora está creado ya ese objeto. 00:21:31
Ahora lo único que tengo que hacer es darle órdenes para que lea cuando a mí me interese. 00:21:37
Lo que pasa es que para que Java me reconozca, para que el compilador me reconozca este término de aquí, para que me lo reconozca, tengo que escribir una línea aquí arriba, pero que la escribe automáticamente el compilador. 00:21:41
Si le dais aquí en la cosita esta roja, si pulsáis con el izquierdo, os ofrece arriba Import Scanner. 00:21:59
Pues le dais doble clic y os hace aparecer esta línea. 00:22:10
La podéis escribir a mano, no pasa nada. 00:22:15
¿Vale? 00:22:18
La podéis escribir a mano. 00:22:19
Y si no, cuando escribáis Scanner, os pondré en rojo, le introducís y ya está. 00:22:20
Entonces, esta línea tiene que estar en el código para poder crear el objeto lector que es este, ¿vale? 00:22:24
Vale, ya tenemos creado el objeto lector. 00:22:38
Ahora este objeto lector me vale para hacer una lectura 2, 20, 30 y 7, las que yo quiera. 00:22:41
Bueno, vale, ya lo tengo creado. 00:22:48
¿Cómo lo uso ahora para leer del teclado? 00:22:50
¿en qué momento queríamos leer 00:22:52
del teclado nosotros? aquí 00:22:55
aquí no quiero darle yo 00:22:57
15, 30, 20, no 00:22:59
aquí quiero dar la orden 00:23:01
al lector para que lea 00:23:03
y el valor que ha leído 00:23:05
que vaya a dar 00:23:07
ahí en ese punto es en el que yo quiero 00:23:08
engancharme al teclado 00:23:11
leer y guardarlo en dato 00:23:13
¿cómo fuerzo 00:23:15
esa lectura? 00:23:17
pues esto es simplemente 00:23:19
Llama al objeto scan, punto y ya está. 00:23:21
Es decir, esto significa, tú scan, que eres el objeto de este lector, 00:23:34
engánchate al teclado, quédate ahí esperando 00:23:42
y cuando alguien meta un entero, cógelo y ese entero que vaya a dato. 00:23:46
Todo eso significa 00:23:52
Ahora mismo lo único que tenemos que hacer es 00:23:55
Aprendernos de memoria entre comillas 00:24:03
Que para leer un entero del teclado 00:24:06
Esta es la sentencia 00:24:08
Y luego lo más importante 00:24:08
Entender lo que está pasando cuando se ejecuta 00:24:10
Eso sí que es importante 00:24:13
Vale, pues nuestro programa es este 00:24:15
¿Qué va a pasar cuando esto se ejecute? 00:24:18
Vale, pues cuando esto se ejecute 00:24:24
No pasa nada 00:24:26
Es un aviso, es un guarde 00:24:32
No pasa nada porque no lo cierres, da igual 00:24:35
Porque habrás importado otra cosa 00:24:37
¿Dónde está el circulito? 00:24:46
¿He perdido el circulito? 00:24:53
no sé 00:24:59
porque esto no escribe 00:25:01
bueno, da igual 00:25:03
vale, pues entonces, ahora lo importante es entender 00:25:05
qué va a pasar 00:25:08
cuando este programa se ejecute 00:25:10
eso sí que es lo importante, ¿vale? 00:25:11
vale, pues a ver 00:25:16
ahora ya este programa 00:25:16
como no tiene ningún error de compilación 00:25:18
que no tiene ninguno 00:25:20
se puede ejecutar, ¿vale? 00:25:20
como no tiene ningún error se puede ejecutar 00:25:23
vale, ¿alguien ve el circulito ese 00:25:25
que hay que dar para que se congele 00:25:28
para que se convierta en pantalla 00:25:30
¿le ha desaparecido o qué ha pasado? 00:25:32
¿pero qué es? 00:25:37
no, pero yo quiero ese circulito 00:25:39
que yo le doy 00:25:40
creo que 00:25:42
vale, pero 00:25:44
es más rápido desde ahí, bueno, no sé, da igual 00:25:46
vale, bueno, pues entonces 00:25:48
ahora esto se va a ejecutar 00:25:50
vale 00:25:52
la máquina virtual va paso por paso 00:25:53
primero 00:25:57
crea ese objeto 00:25:58
lo crea, nosotros ahí no vemos nada 00:26:02
lo crea, aparece 00:26:04
aparece ese objeto, vale 00:26:05
ahora 00:26:08
declara esa variable 00:26:09
muy bien, en memoria RAM 00:26:11
aparecerá 00:26:14
un espacio 00:26:16
en memoria, dato 00:26:18
para 32 bits 00:26:20
y ahora 00:26:22
a la vez que lo declara 00:26:26
a la vez que lo declara 00:26:28
le va a hacer una asignación. 00:26:30
Eso es algo que siempre podemos hacer, ya sabemos. 00:26:35
A la vez que declaro una variable, 00:26:37
le puedo asignar un valor. 00:26:40
Pero en este caso, el valor que yo le asigno 00:26:42
no va a ser un numerito que yo le dé o una expresión, no. 00:26:44
En este caso, el valor que yo le asigno 00:26:48
va a ser el resultado de esta sentencia. 00:26:52
¿vale? pues ¿cómo funciona esta sentencia? 00:26:58
¿cómo funciona? 00:27:01
la máquina virtual 00:27:02
ve que hay un next int y ¿qué hace? 00:27:04
detiene automáticamente 00:27:07
el programa, el programa se 00:27:08
queda aquí parado 00:27:10
ahí parado esperando 00:27:11
¿esperando a qué? 00:27:13
justo a que alguien por el teclado 00:27:16
meta un numerito 00:27:18
y mientras nadie meta nada 00:27:19
por el teclado 00:27:22
el programa está ahí esperando hasta el infinito 00:27:23
Nunca jamás va a avanzar a la siguiente sentencia. Jamás. Ahí se va a quedar. Cuando alguien ya escriba algo en el teclado, recogerá ese algo y ya lo guardará en esta variable de datos. Será una asignación. 00:27:26
lo que pasa es que esa asignación 00:27:44
no viene de un numerito 00:27:46
directamente o de una expresión 00:27:49
sino viene de lo que 00:27:51
alguien ha metido en el teclado 00:27:53
¿vale? entonces es importante entender 00:27:54
que mientras 00:27:56
no haya alguien ahí metiendo algo 00:27:58
esto va a estar aquí parado 00:28:00
en el next in hasta el infinito 00:28:03
ahí va a estar parado, de ahí no va a salir 00:28:05
hasta que alguien no escriba algo 00:28:07
vale, alguien 00:28:09
escribe algo, pues ya está, la asignación está hecha 00:28:11
A ver, se supone que van a escribir un entero, 37. Si alguien escribiera una cosa que no es un número, como hola, cuando la máquina virtual tratara de asignar un hola, ahí daría un error de ejecución y el programa pararía. 00:28:13
pero bueno, vamos a usarlo así, vamos a usarlo 00:28:31
introduciendo, lo que supone que tiene que introducir 00:28:33
pues ya está, ahora ya 00:28:35
sí que 00:28:37
este programa 00:28:38
nuestro, ya sí que 00:28:43
es más general, entonces 00:28:45
para que sea más amigable 00:28:47
vamos a poner un mensajito delante 00:28:49
porque si no el tío no sabe que 00:28:51
vale, porque si yo no pongo este System.out.println 00:28:52
voy a 00:28:55
ejecutar mi programa así tal cual 00:28:57
lo ejecuto, aquí 00:28:59
está la consola como tonta 00:29:03
esperando hasta el infinito 00:29:05
y yo estoy sentada adelante diciendo 00:29:07
¿y tú qué esperas? 00:29:09
¿qué hago? no sé, ¿qué tengo que hacer? 00:29:11
y ahí está parada hasta el infinito 00:29:14
entonces, como yo no sé qué tengo que hacer 00:29:15
pues yo qué sé, puedo escribir cualquier cosa 00:29:17
aquí el programa 00:29:20
me fallaría, porque 00:29:23
está esperando un entero 00:29:24
este es el cubito que quería yo 00:29:27
está esperando un entero 00:29:28
entonces, si yo como le he puesto 00:29:30
esto, que no es ni un entero ni nada 00:29:33
el programa se rompe, pero bueno 00:29:35
ahora mismo esto no nos importa, vamos a hacer el uso 00:29:37
correcto, pero también entendemos muy bien que es esto 00:29:39
de exception, etcétera 00:29:41
¿vale? 00:29:43
entonces, para que el programa 00:29:45
sea intuitivo 00:29:47
vamos a poner un mensajito 00:29:48
siso 00:29:52
control espacio 00:30:01
vale, el programa ahora es un pelín más amigable 00:30:02
Ahora ya ejecutamos esto 00:30:18
Me muestra el mensaje 00:30:21
Y ahí está esperando 00:30:24
Ahí está esperando 00:30:27
Pero yo ya sé que tengo que meter un entero 00:30:29
Meto un entero 00:30:31
Y me calcula el doble 00:30:33
Entonces ahora ya 00:30:35
Puedo calcular el doble de cualquier 00:30:37
Número con este mismo programa 00:30:39
No tengo que ir al 00:30:41
Programador a oye cámbiame el número 00:30:43
Cámbiame el número, no porque se lo estoy dando yo 00:30:45
En tiempo de ejecución 00:30:47
¿Vale? Como se lo estoy dando yo en tiempo de ejecución 00:30:48
Ya la empresa de software 00:30:51
Ya no la necesito para nada 00:30:53
Tengo yo a mi programa, el que me ha vendido 00:30:55
Y lo ejecuto siempre que me dé la gana 00:30:57
Para hacer lo que yo quiera 00:31:00
¿Qué ahora quiero el doble de este? Pues este 00:31:01
¿Qué ahora quiero el doble de este otro? Pues este otro 00:31:02
¿Vale? 00:31:06
Entonces los programas, lógicamente 00:31:09
Trabajan con datos 00:31:11
Y la idea es que esos datos se entreguen 00:31:12
En tiempo de ejecución 00:31:15
No los pongamos por código 00:31:16
porque entonces tendríamos que ir a la empresa 00:31:19
de software, cámbiame a la variable 00:31:21
y vale 7, cámbiame, es absurdo 00:31:23
¿vale? bueno pues 00:31:25
en los ejemplos que veamos 00:31:28
desde ya y eso 00:31:31
daremos los datos por teclado 00:31:32
para que el programa 00:31:35
tenga un poco más de sentido 00:31:37
con lo cual ya podemos 00:31:38
usemos esto ya siempre 00:31:40
sin tener que pararnos 00:31:43
esa línea para crear el objeto 00:31:45
lo cual implicará 00:31:47
que haya que poner 00:31:49
el import 00:31:51
arriba 00:31:53
¿vale? el import ese que está arriba 00:31:54
y luego cuando 00:31:57
yo quiero leer, en el caso de que sea un número 00:31:59
entero, cuando sea otra cosa ya lo incorporaremos 00:32:01
esto 00:32:04
y con esto lo entero 00:32:05
ahora mismo asegurémonos 00:32:06
cuando lo ejecutemos de meter realmente 00:32:09
un entero, pues el programa se va a parar 00:32:11
y no sabemos todavía cómo capturar eso 00:32:13
cómo manejarlo, etcétera, entonces 00:32:15
usemos el programa metiendo lo que me está 00:32:17
pidiendo, si me pide un entero, pues un entero 00:32:19
yo tengo una pregunta 00:32:21
el system out después del 00:32:23
escáner, o sea, automáticamente como se 00:32:25
como después del escáner, ah, este 00:32:29
simplemente es para que me 00:32:31
ya, pero tú no has puesto ni escáner ni nada 00:32:34
como que no he puesto ni escáner ni nada 00:32:37
o sea, después del escáner has puesto 00:32:39
system, claro, esto es 00:32:41
para que me muestre un 00:32:43
mensaje, sin más 00:32:45
o sea, entonces al mostrarme 00:32:47
Me muestra el mensaje 00:32:49
Me muestra la información 00:32:51
Que es, voy a esperar que metas 00:32:52
Y luego ya sí que sí 00:32:55
Se queda aquí esperando 00:32:57
Esto es solamente para mostrar un mensajito 00:32:58
Para que la interfase sea más amigable 00:33:00
Claro, porque si no 00:33:02
¿Vale? 00:33:03
Bueno, pues todo esto en cuanto a 00:33:10
Venía en cuanto al rollo de expresiones 00:33:13
¿Vale? 00:33:18
Que a una variable 00:33:20
Le podemos asignar una expresión correctamente escrita, etc. 00:33:20
Bueno, ¿alguna pregunta? 00:33:38
Ninguna, ¿no? 00:33:41
Es que todavía, con lo que sabemos, podemos hacer nada, nada más que cosas como esta. 00:33:42
Así que tenemos que incorporar alguna cosita más para poder hacer programas un poquito más así. 00:33:46
Vale, en lugar de parar ahora que toca, vamos a parar ahora porque quiero descansar un rato. 00:33:54
La voz, ¿vale? 00:33:59
Materias:
Programación
Niveles educativos:
▼ Mostrar / ocultar niveles
  • Formación Profesional
    • Ciclo formativo de grado superior
      • Primer Curso
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
4
Fecha:
24 de septiembre de 2025 - 18:06
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
34′ 08″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
124.69 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid