Saltar navegación

Activa JavaScript para disfrutar de los vídeos de la Mediateca.

Clase 26-09-23 - 2 - Contenido educativo

Ajuste de pantalla

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

Subido el 26 de septiembre de 2023 por Raquel G.

10 visualizaciones

Más información Transcripción

Descargar la transcripción

Vale, vamos a seguir. Bueno, pues entonces, estábamos diciendo que hay que hacer aparecer una variable que sea capaz de leer del teclado y se le hace aparecer igual que se hace aparecer una variable como las que hemos visto, declarándole y poniendo su tipo. 00:00:01
y el tipo de dato hemos dicho que es este 00:00:17
con el matiz de que como es muy largo 00:00:19
me hago un truco 00:00:21
bueno, pues he mentido un poco, como siempre 00:00:22
no se le hace aparecer 00:00:26
solamente poniendo el nombre 00:00:29
las variables primitivas sí 00:00:31
las variables primitivas 00:00:33
que son las que hemos visto 00:00:35
funcionan así, yo pongo esto 00:00:36
y ¡pam! apareció un espacio 00:00:39
en memoria RAM para guardar 00:00:41
un número entero, ya está 00:00:43
Las variables objeto, como ya veremos en detalle 00:00:44
Cuando ya hagamos pronunciación de entrada de objetos 00:00:48
Para aparecer PAF en memoria 00:00:53
No basta solamente con declararlas y ya 00:00:55
Como las variables primitivas, no basta 00:00:59
Hay que hacer además una cosita 00:01:00
Que es el cuarto o quinto acto de fe que tenéis que hacer 00:01:03
Que es escribir esto 00:01:06
¿Vale? Esto hay que escribirlo sí o sí 00:01:08
Porque las variables objeto 00:01:19
para hacerlas aparecer 00:01:21
además de declararlas 00:01:23
hay que hacer una cosa 00:01:25
se llama construirlas y eso se hace con new 00:01:27
ya esto ya lo trabajaremos 00:01:29
bastante, entonces ahora mismo 00:01:32
con que sepamos como 00:01:33
crear 00:01:35
y declarar una variable scanner es suficiente 00:01:36
porque estamos usando solo esta, variable objeto 00:01:39
solo esta estamos usando, aler del teclado 00:01:41
ya está 00:01:43
vale, pues entonces 00:01:44
esta variable 00:01:50
ya está correctamente declarada 00:01:53
Y además, dando inicializada de una manera que todavía no entendemos 00:01:55
Pero bueno, nos da igual, inicializada como para a partir de ahora 00:02:01
Poder hacer las cosas que ella es capaz de hacer 00:02:03
Que es leer del teclado 00:02:07
Las variables enteras, long, char, no pueden hacer nada 00:02:08
Salvo recibir valor 00:02:13
Las variables objeto como esta, aparte de recibir valor, pueden hacer cosas 00:02:14
En este caso, ¿qué puede hacer? 00:02:19
Leer un número entero del teclado, leer un número double 00:02:22
leer un char 00:02:24
que es lo que nosotros queremos 00:02:26
bueno, pues vamos a hacerlo 00:02:28
¿cómo la ordenamos? 00:02:31
oye tú, lee el número entero del teclado 00:02:33
vale, pues a ver 00:02:35
para darle órdenes 00:02:43
a esta variable objeto y que lea 00:02:45
la llamo por su nombre 00:02:47
por supuesto, para eso le he dado un nombre 00:02:49
la llamo por su nombre 00:02:51
y lo de darle la orden para que haga algo 00:02:52
se hace poniendo un puntito 00:02:55
que también entenderemos por qué 00:02:56
poniendo un puntito se le da la orden 00:02:58
Y ahora, ¿qué orden le quieres tú dar? ¿Qué le queremos ordenar? Queremos ordenarle que lea un número entero. Pues, ala, con esto le ordenamos que lea un número entero. Esa es la orden y es esa. Y es esa y hay que saberla. 00:03:00
Y ahora la gran pregunta es 00:03:16
Vale, muy bien 00:03:20
Con esta orden que yo le he dado 00:03:21
Se irá al teclado 00:03:23
Cogerá el numerito que alguien haya tecleado 00:03:27
Y que esté en el buffer 00:03:29
Pero ese número tiene que ir a algún lado 00:03:30
Claro, es que la idea es que ese número 00:03:31
Se guarde, ¿dónde? 00:03:35
En una variable para guardar números 00:03:36
Porque para eso creamos las variables 00:03:39
Nosotros, para guardar cosas 00:03:40
Bueno, pues vamos a 00:03:42
Por ejemplo 00:03:44
Aquí vamos a declararnos 00:03:45
Una variable para poder guardar el valor 00:03:48
Porque es que si no, no hacemos nada con ese valor 00:03:50
¿Vale? 00:03:52
¿Y cómo le asignamos valor a una variable? 00:03:54
Ya sabemos cómo 00:03:56
Haciendo esto, ¿verdad? 00:03:57
Esta es la asignación 00:04:00
n igual 00:04:01
En este caso a n, ¿qué le asignamos? 00:04:03
No le asignamos 5, 7 00:04:06
n1 por 12 00:04:08
No, lo que le asignamos 00:04:10
Es el resultado de esta orden 00:04:12
le asignamos el resultado de ordenar 00:04:14
a la variable lector del teclado 00:04:17
que lea un número entero del teclado 00:04:20
y el resultado de esa orden 00:04:22
que será el número entero leído 00:04:25
ese resultado se va a n 00:04:26
luego esto es una asignación 00:04:29
no es una asignación más 00:04:32
es una asignación normal y corriente 00:04:34
a n le asigno esto 00:04:35
lo que pasa es que lo que le asigno 00:04:37
es el resultado de la orden 00:04:39
coger del teclado 00:04:42
¿vale? entonces 00:04:43
revisando 00:04:47
la declaración y construcción del objeto este 00:04:48
es así por narices 00:04:51
le puedo cambiar el nombre, por supuesto 00:04:53
los nombres de las variables, yo pongo el que me dé la gana 00:04:55
se lo puedo cambiar 00:04:57
pero es esta, y luego 00:04:58
las órdenes que le tengo que dar 00:05:01
las órdenes tienen 00:05:03
un nombre, una llamada, y las tengo que saber 00:05:05
las tengo que saber 00:05:07
pues para leer un entero esta 00:05:08
vamos de hecho a 00:05:11
comprobarlo aquí 00:05:14
a ver si ha leído correctamente 00:05:16
bueno, no voy a poner las tildes 00:05:17
porque 00:05:19
el número leído es 00:05:20
¿vale? 00:05:26
recordad ya un uso 00:05:31
del system.out.println 00:05:33
que ya lo hemos hecho al principio de todo 00:05:34
el primer programa que hicimos era 00:05:36
yo le paso algo entrecomillado y me lo muestra tal cual 00:05:37
vale, pues el número leído es 00:05:40
y vamos a poner aquí abajo 00:05:42
el numerito 00:05:44
vale 00:05:46
entonces va a ir incorporando 00:05:51
pequeñas cosas, chorradas 00:05:54
el system.out.println 00:05:56
sabemos que muestra 00:05:58
por consola 00:06:00
lo que le pasemos aquí 00:06:01
bien sea un texto entrecomillado 00:06:03
o bien sea el contenido de una variable 00:06:06
lo muestra por consola 00:06:08
y además añade un salto de línea 00:06:09
de ahí viene la ln 00:06:11
pero hay otra versión del system.out 00:06:13
que es sin el ln, también existe, sin el ln 00:06:16
entonces sin el ln, muestra lo que yo le dé ahí 00:06:19
pero luego no mete un salto de línea, depende del efecto que yo quiera 00:06:23
pongo ln, no lo pongo, en este caso, sin ln 00:06:28
me mostrará en la misma línea el número leído es, y me mostrará el número después 00:06:32
porque no hay un salto de línea aquí, no lo hay 00:06:36
si pongo un ln, me mostraría el número leído es 00:06:38
Salta y abajo ya el número 00:06:43
Depende del efecto que yo quiera lograr 00:06:45
En la vista que me sale 00:06:47
Aquí me es más cómodo 00:06:48
Como lo he puesto en la misma línea 00:06:50
Uso la versión de print 00:06:51
Vale, pues entonces vamos a ver 00:06:53
Si este programa funciona 00:06:59
Vamos a ejecutarlo 00:07:01
Lo ejecutamos 00:07:03
Y ahí se ha quedado parado 00:07:06
No ha terminado 00:07:10
Para saber si un programa ha terminado 00:07:11
Lo sabemos porque 00:07:15
aquí viene, verdad 00:07:17
aquí viene 00:07:18
el término, aquí aparecería 00:07:21
el término terminate 00:07:23
este no ha terminado, de hecho 00:07:24
me aparece este nombre porque 00:07:27
dice, este está aquí parado en ejecución 00:07:29
y tanto que está parado 00:07:31
es que está ahí esperando 00:07:32
ahí muerto de risa 00:07:34
claro, porque esta orden 00:07:36
la orden next in 00:07:38
lo que hace es 00:07:40
poner al programa cruzado de brazos 00:07:42
A la espera de que alguien 00:07:45
Se le ocurra meter un numerito y llenar el buffer 00:07:47
Mientras en el buffer no haya nada 00:07:50
Ese se va a quedar clavado hasta el infinito 00:07:51
¿Vale? 00:07:54
La orden next in 00:07:56
Se va al buffer del teclado 00:07:57
Que está vacío, ahí parado para siempre 00:07:59
No hay forma de abortar eso 00:08:01
Ahí parado para siempre 00:08:03
Que alguien ya ha tecleado algo y ha llenado el buffer 00:08:04
Lo coge del buffer 00:08:08
Entonces ahí ya la orden sale 00:08:09
Coge eso y va a la variable 00:08:11
Pero mientras el buffer esté vacío 00:08:14
Porque yo no he tecleado nada 00:08:15
Ahí el programa se está parado 00:08:16
Hasta el fin de los tiempos 00:08:18
Bueno, pues para que no se esté parado 00:08:21
Hasta el fin de los tiempos 00:08:24
Vamos a meterle un numerito 00:08:24
Y ya está, vale, el número he leído es 76 00:08:26
Vale, estupendo 00:08:29
Cuando yo le he metido 76 00:08:30
Ha cogido del buffer el 76 00:08:33
Perdón, ha llevado al buffer el 76 00:08:35
Lo ha... 00:08:37
Vale, cuidado 00:08:48
Con lo que metéis 00:08:49
Que nunca sabéis 00:08:51
Lo que puede salir de ahí 00:08:52
El next in 00:08:53
Espera un número 00:08:57
Como no metáis un número 00:08:58
¿Vale? Vamos a ver a ejecutar el programa 00:09:00
El next in 00:09:03
Se queda esperando 00:09:08
Y a mí se me va la mano 00:09:09
76 y una i que se me ha ido la mano 00:09:10
Ya la hemos roto 00:09:13
Ya la hemos roto 00:09:16
Porque next in dice 76 00:09:17
Sí, pero ¿qué número es ese? 00:09:19
Como no sea un número 00:09:21
con parte imaginaria pura 00:09:22
¿no? recordáis números complejos, ¿verdad? 00:09:25
68 hoy es un número 00:09:27
pero es un número complejo, no es real 00:09:28
los números complejos para Java 00:09:30
no ha llevado hasta ahí, no existen 00:09:32
conclusión 00:09:34
si metéis algo 00:09:37
que no es un número entero 00:09:39
next in 00:09:40
va a parar el programa automáticamente 00:09:42
fuera, parado, ya no pasa nada más 00:09:45
el programa se paró 00:09:47
y de hecho aparece el terminator 00:09:48
es el terminator 00:09:50
aparece ahí, ¿verdad? porque el programa ha terminado 00:09:51
o sea, el programa termina 00:09:54
y no pasa 00:09:57
del resto, lo que hay después pasa 00:10:00
fuera, pasa 00:10:02
esto es lo que se llama, se ha generado una excepción 00:10:03
¿vale? para que vayamos incorporando 00:10:06
conceptos 00:10:10
una excepción es 00:10:12
algo que a la máquina virtual no le cuadro 00:10:14
No le cuadro, ya veremos cómo se genera en su momento 00:10:18
Por qué, cómo evitarlas 00:10:21
Cómo capturarlas nuestras 00:10:23
Eso ya es el tema de excepciones 00:10:25
Que está más adelante 00:10:28
Una excepción basta con que ahora sepamos qué es 00:10:29
La máquina virtual 00:10:32
Ha intentado hacer una sentencia 00:10:34
Esa sentencia 00:10:36
Por lo que sea le ha salido rana 00:10:38
Pues entonces 00:10:39
Te avisa con unas letras rojas muy feas 00:10:41
Y para automáticamente el programa 00:10:44
Ya no sigue 00:10:46
bueno, pues nos van a pasar tropecientas mil excepciones 00:10:47
porque habrá mil veces que a la máquina virtual le pase eso 00:10:51
que intente ejecutar una sentencia y diga 00:10:53
uuuh, esto es imposible 00:10:56
me pare el programa y me saque unas letras rojas feas 00:10:58
bueno, habrá muchas veces que nos pase 00:11:00
pues este es el primero que nos va a pasar 00:11:02
como demos una orden de next in 00:11:04
y le metamos algo que no sea un entero 00:11:06
pues lo hemos liado 00:11:07
que yo le meto un menos esto 00:11:09
aquí el encanta de la vida 00:11:12
porque menos 98 es un número entero 00:11:14
A NextIn le gusta el menos 98 00:11:16
Aquí en la consola 00:11:19
¿No tienes consola abierta? 00:11:24
Si hay un NextIn lanzado 00:11:28
Y un programa lanzado esperando, sí 00:11:30
Tienes que tener el programa lanzado 00:11:31
Y un NextIn que está ahí esperando 00:11:34
¿Vale? 00:11:35
Bueno, pues en cuanto a enteros 00:11:42
Esto 00:11:44
Que yo quiero, claro, que yo quiero meter un número muy grandote 00:11:44
Pues 00:11:48
Y no me cabe en un int 00:11:50
No lo leería con NextIn 00:11:52
pero puedo leerlo con NextLong 00:11:53
¿verdad? 00:11:55
a ver, ¿cómo? 00:12:03
vale 00:12:05
vale, a ver, lo de que se puede 00:12:06
aquí en la consola o no se pueda, no es que se pueda o no se pueda 00:12:14
o sea, la consola 00:12:17
es esto de aquí abajo, esto blanco 00:12:18
esto blanco está ahí 00:12:20
para lo que el programa mande 00:12:22
¿vale? silencio 00:12:24
escuchadme 00:12:27
la consola, que es eso bajito 00:12:27
que está ahí abajo, está ahí 00:12:30
para lo que el programa decida 00:12:32
Entonces el programa, ¿para qué puede decidir usar la consola? 00:12:33
Puede decidir usarlo para mostrar datos o para recogerlos 00:12:37
Y en cada momento, o me sirve para mostrar o me sirve para recoger según lo que el programa diga 00:12:43
El programa es el que tiene las órdenes, el que va ordenando sentencia por sentencia 00:12:50
Y en función de las órdenes, la consola me sirve como mostradora de datos o me sirve como receptora 00:12:54
Por ejemplo, la máquina virtual arranca, el programa arranca, lo primero que hemos hecho, o sea, lo primero no, si se encuentra esto, en este momento la consola solo me vale para mostrar, está claro, porque System.out.print es una orden que es para que la consola muestre, entonces en ese caso la consola me vale para mostrar. 00:13:01
pero si yo hago una sentencia 00:13:21
como esta 00:13:23
como esa, entonces ahí 00:13:24
la consola se convierte automáticamente 00:13:27
en esperadora 00:13:29
receptora de datos 00:13:31
entonces la consola o puede recibir datos 00:13:32
o no, en función de si el programa 00:13:35
se lo ordena o no se lo ordena 00:13:37
la consola no es que sea un ente aparte 00:13:39
que haga cosas o no las haga 00:13:41
la consola está al servicio 00:13:43
de lo que las instrucciones le manden 00:13:45
bueno, pues hasta ahora 00:13:48
solamente ha estado al servicio 00:13:49
de instrucciones de mostrar 00:13:51
porque solo lo hemos usado para eso 00:13:53
con system out para mostrar una variable 00:13:55
mostrar una cadena, solo hemos usado para eso 00:13:57
entonces hasta ahora la consola solamente ha estado 00:13:58
al servicio de mostrar 00:14:01
pero ahora hemos incorporado ya una sentencia 00:14:02
solo una hasta ahora, que es esta 00:14:04
que pone la consola 00:14:06
en modo escucha 00:14:09
entonces la consola 00:14:11
solo puede recibir datos 00:14:13
cuando se ejecute 00:14:15
esta sentencia 00:14:17
entonces cuando esta sentencia se ejecuta 00:14:18
solo en ese momento 00:14:20
que es en el que estoy ahora mismo yo en mi programa 00:14:22
eso está en modo recibir datos 00:14:24
y ahí está parado 00:14:27
y el programa está aquí parado 00:14:28
y de aquí no va a salir nunca jamás 00:14:29
ahí está paradísimo, nunca jamás 00:14:31
porque está atascado en esta sentencia 00:14:33
y la consola está ahí esperando 00:14:35
y ahí atascado en mesin 00:14:37
atascado 00:14:40
y no se va a desatascar jamás 00:14:41
cuando se va a desatascar 00:14:43
cuando yo le meta un número 00:14:45
Cuando yo le meta un número, ya 00:14:47
Coge el valor, esta sentencia ha terminado 00:14:49
Con lo cual la consola 00:14:52
Deja de ser ya automáticamente receptora de datos 00:14:53
Porque ya la sentencia terminó 00:14:55
No volverá a ser receptora de datos 00:14:57
Hasta que nos llegue un next in más adelante 00:14:59
¿Vale? 00:15:01
Cuando yo le meta un numerito 00:15:03
Y de al enter, porque el enter significa 00:15:04
Ya he acabado de meter 00:15:07
Cuando yo le de al enter 00:15:08
Ahora ya esta sentencia acabó 00:15:10
La consola dejó de ser receptora de datos 00:15:12
Pero la sentencia acabó 00:15:15
Y ahora ya se ha convertido en mostradora 00:15:16
Porque se le ordena esta sentencia 00:15:19
¿Vale? Se le ordena 00:15:20
Y se ha convertido en mostradora 00:15:22
El número leído es 00:15:24
Y otra vez vuelve a mostrar 00:15:25
¿Vale? Así funciona 00:15:27
La consola y estas sentencias 00:15:30
Bueno, pues estábamos 00:15:33
Para leer un número entero 00:15:35
Que es una tarea habitual en nuestros códigos 00:15:37
Ya sabemos perfectamente cómo hacerlo 00:15:38
Y sin ningún problema 00:15:40
Lo podemos leer así 00:15:41
Que yo quiero leer un número 00:15:42
Que es muy grandote 00:15:44
y que va una variable log muy grandote 00:15:45
pues tengo otra orden 00:15:47
que es next long, esto es fácil de memorizar 00:15:49
pues next in, next long, es fácil de memorizar 00:15:51
esta orden 00:15:54
la usaré cuando 00:15:55
yo prevea que el usuario 00:15:57
me puede meter una cosa muy grandota 00:15:59
¿vale? entonces sí 00:16:01
el número por ejemplo 00:16:03
¿vale? y ambas me funcionan, por ejemplo 00:16:15
aquí voy a leer dos números 00:16:18
este y este 00:16:19
vamos a leerlos, entonces 00:16:21
Ejecutamos el programa 00:16:24
¡Hala! Primero 00:16:25
Ahí se ha quedado, esperando el primero 00:16:27
Venga, esperando el primero 00:16:29
Ahora, ya ha hecho 00:16:32
Esto System.out y otra vez 00:16:34
Se vuelve a quedar esperando el segundo 00:16:36
Otra vez se ha parado, otra vez está aquí parada 00:16:38
Otra vez parada 00:16:40
Atascada ahí en este Next.log, otra vez parada 00:16:41
¿Vale? Pues le doy un numeraco 00:16:44
No sé si... 00:16:46
Yo creo que así ya me he salido del entero 00:16:47
¿Vale? Este... 00:16:52
Porque el entero creo que tenía menos cifras decimales que esto. 00:16:54
Vale, pues ya está. 00:17:00
He leído este numerito y aquí se ha quedado. 00:17:02
Bueno, pues aquí dos veces la consola se ha parado. 00:17:09
Se ha parado aquí. 00:17:12
Cuando le dio el número ha hecho esto. 00:17:13
Se ha vuelto a quedar parada aquí. 00:17:15
Cuando le he leído el número ha hecho esto. 00:17:17
Y ya está. 00:17:19
Bueno, pues leer números. 00:17:20
Indabel, que son los que manejamos. 00:17:22
Claro, porque no has cambiado este n por n2. 00:17:27
¿Has hecho el copia y pega como yo? 00:17:29
Y has dejado aquí n, ¿verdad? 00:17:30
Claro, con los copias y pegas hay que tener cuidado 00:17:33
porque luego hay que revisar a ver si tengo que tocar algo 00:17:35
en el pega que he hecho. 00:17:38
Vale. 00:17:40
Para leer números en todo esto es lo que haremos. 00:17:44
Leer boolean no tiene sentido. 00:17:47
Uno no lee los boolean. 00:17:48
Los boolean son para almacenar condiciones, 00:17:50
pero se podría. 00:17:52
Hay un boolean, pero no nos... 00:17:53
¿Vale? 00:17:55
Y leer char. 00:17:56
leer char, uno no lee un char en realidad 00:17:57
uno cuando lee de la consola 00:18:00
lo que quiere leer es un texto 00:18:02
y ya veremos como 00:18:03
lo almacenamos, porque un texto no vale 00:18:05
en una cadena 00:18:07
no vale en una variable char 00:18:09
vale, pero es que no quiero 00:18:11
incorporar más cosas ahora 00:18:14
quiero que hagáis una 00:18:18
primera chorradilla 00:18:19
ya, por fin 00:18:22
para que yo me calle 00:18:23
vale, pues entonces 00:18:24
venga, pues 00:18:27
antes de poner ya ejercicios 00:18:32
un poco más 00:18:36
que tenemos que ver más cosas 00:18:37
pues venga, haced simplemente esto 00:18:40
simplemente esto para aseguraros de que todo 00:18:47
está claro, vale 00:18:49
sí, pero una clase nueva en la que voy a poner solo 00:18:50
en modo de comentario lo que tenéis que hacer, luego ya lo hacéis vosotros 00:18:55
he abierto una clase nueva para 00:18:57
poner en modo comentario 00:19:00
lo que os mando a hacer, luego ya lo hacéis vosotros 00:19:03
¿vale? bueno, pero antes de nada 00:19:06
para que el programa quede 00:19:07
usable, amable 00:19:09
que no sea un programa que no se entiende nada 00:19:11
porque con este, ¿qué ha pasado? 00:19:13
que cuando lo hemos ejecutado este programa 00:19:15
es que, porque lo hemos hecho nosotros 00:19:16
y como lo hemos hecho nosotros, sabemos que eso 00:19:19
se ha quedado aquí esperando un número 00:19:21
pero que lo hemos hecho nosotros, si este programa lo ejecuta el otro tío 00:19:22
ve eso en blanco 00:19:25
con el cursor esperando y dice, ¿y tú qué estás esperando? 00:19:27
entonces, hombre 00:19:31
eso es un poco feo, hay que hacer programas 00:19:31
con interfaces lo más 00:19:33
usables y amables posibles 00:19:34
entonces, aquí en este 00:19:37
programa, por ejemplo, que lo que queremos es leer 00:19:39
un numerito, pues tendría sentido 00:19:41
poner un mensaje antes 00:19:43
ponerle un mensajito antes y decir 00:19:45
introduzca número 00:19:47
entero 00:19:49
entonces ahora el programa 00:19:50
es un poquito más majo 00:19:53
porque primero 00:19:55
mostrará el mensaje, y ahora ya si se quedará 00:19:57
esperando, pero al menos tú ya sabrás que tienes que 00:19:59
meter 00:20:01
y con el otro long 00:20:01
igual 00:20:04
podríamos ponerle aquí 00:20:05
introduzca número entero 00:20:07
y ponerle entre paréntesis para que se aclare 00:20:10
puede ser long 00:20:12
para que sepa que puede ser muy largote 00:20:14
entonces ahora ya el programa 00:20:16
queda un poquito más majo 00:20:18
si lo ejecutamos 00:20:19
ahora ya, introduzca número entero 00:20:21
y se queda esperando efectivamente 00:20:25
con el next in se queda esperando 00:20:27
pero al menos ya el usuario 00:20:29
Que no es el que ha hecho el programa 00:20:31
Normalmente el usuario sabe lo que tiene que hacer 00:20:33
Ah, vale, un número entero 00:20:34
Pues venga, ya está 00:20:36
Ahora me lo vuelve a decir 00:20:37
Introduzca número entero 00:20:39
Este puede ser largo 00:20:40
¡Paaaaa! 00:20:41
¡Hala! 00:20:44
Vale, entonces, bueno 00:20:45
Incorporad siempre 00:20:46
Toda la ayuda 00:20:48
Para el usuario que va a ejecutar el programa 00:20:50
Como 00:20:52
En nuestro caso somos nosotros 00:20:54
No nos es imprescindible esa ayuda 00:20:56
Pero hay que acostumbrarse 00:20:58
¿Vale? 00:20:59
claro, es añadir mensaje 00:21:00
no comentario, esto no es un comentario 00:21:06
es añadir una sentencia que muestra por pantalla 00:21:07
solamente con la idea 00:21:10
de facilitar el trabajo al que lo va a usar 00:21:12
de facilitar, o sea, de darle información 00:21:14
este es todo el código 00:21:16
este es todo el código que hay 00:21:44
leemos número entero, dejamos aquí el programa 00:21:51
esperando, lo mostramos 00:21:54
ponemos el mensaje 00:21:56
de aviso 00:21:58
Nos quedamos esperando al siguiente 00:21:59
Y lo mostramos 00:22:01
Venga, pues os voy a complicar la vida un pelín 00:22:02
Pero un pelín solo de cara a pensar 00:22:30
No de cara a hacer nada 00:22:32
Diciendo lo que hemos hecho 00:22:33
Vale 00:22:34
Se lo tenéis que hacer solo con lo que hemos visto 00:22:35
No con nada que sepáis del pasado 00:22:40
Ni del futuro 00:22:42
Vale, programa que 00:22:43
Solicite 00:22:48
Y lea dos números enteros 00:22:49
Uno detrás de otro, claro 00:22:53
Los programas siempre actúan en secuencia 00:22:54
Dos números enteros 00:22:56
Int log, elegís el que sea 00:22:59
Por defecto, siempre se suele usar el tipo int 00:23:01
A menos que sean aplicaciones que no sepa que va a usar esos pedazos de números 00:23:04
Números enteros 00:23:07
Y a continuación 00:23:09
Muestre el mayor de los dos 00:23:14
A ver si se os ocurre como hacerlo 00:23:18
Quizá lo he puesto un poco retorcido, de buenas a primeras 00:23:21
Pero como soy muy listos 00:23:25
a ver si os ocurre como hacerlo 00:23:27
recurriendo 00:23:30
solo a lo que hemos visto aquí 00:23:32
no a cosas que 00:23:34
busquéis, ni a sentencias 00:23:36
y ni a nada, solo lo que hemos visto 00:23:38
aquí 00:23:40
venga, pues paro la grabación 00:23:41
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
10
Fecha:
26 de septiembre de 2023 - 13:21
Visibilidad:
Público
Centro:
IES ROSA CHACEL
Duración:
23′ 50″
Relación de aspecto:
1.78:1
Resolución:
1280x720 píxeles
Tamaño:
454.90 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid