Saltar navegación

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

Clase 16-10-23 - 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 16 de octubre de 2023 por Raquel G.

7 visualizaciones

Más información Transcripción

Descargar la transcripción

Venga, vamos a seguir, ya solo para que podamos hacer algunos ejercicios para poner en práctica algunas cosas más, ya solo para eso vamos a ampliar las opciones de lectura de teclado que hasta ahora mismo hemos leído numeritos y ya está. 00:00:00
Vamos a ampliar las opciones de lectura de teclado para leer cadenas también y trabajar un poquito más con las cadenas de texto, porque eso nos abre el poder incorporar algunas cosas más en nuestros ejercicios. 00:00:16
vale, vamos simplemente a incorporar eso 00:00:28
de cara a poder abrir un poco 00:00:32
el abanico de ejercicios que podemos hacer 00:00:33
y datos de entrada que podemos utilizar 00:00:35
vale 00:00:37
vale, bueno, recordad 00:00:39
que los tipos de datos que hemos visto 00:00:42
los que llamamos primitivos 00:00:43
números 00:00:46
enteros y decimales 00:00:48
boolean y char 00:00:50
vale, ya sabemos lo que implica 00:00:52
declararlos, cuando los declaramos 00:00:54
aparecen automáticamente en memoria y ya está 00:00:55
aparte de esos tipos 00:00:57
primitivos 00:00:59
para guardar 00:01:00
cadenas enteras de caracteres 00:01:03
que se usa mucho, una cadena entera de caracteres 00:01:05
no un carácter suelto, uno por uno 00:01:08
teníamos un tipo adicional 00:01:09
que hemos mencionado 00:01:11
que es este, vale 00:01:13
entonces este tipo es un tipo 00:01:14
especial, ay perdón 00:01:17
perdón, perdón 00:01:19
vale, o sea, este tipo es un tipo especial 00:01:20
vale, entonces 00:01:25
no es un tipo primitivo 00:01:28
es un tipo objeto que todavía no sabemos 00:01:34
las implicaciones que tiene, pero bueno, lo hace un poquito 00:01:35
especial, ¿vale? 00:01:38
pero lo podemos usar hasta ahora 00:01:39
igual que usamos los primitivos 00:01:41
para guardar cadenas de caracteres 00:01:43
¿vale? por ejemplo 00:01:45
ya lo hemos hecho a veces, que yo quiero asignar una cadena 00:01:47
cualquiera 00:01:49
pues le asigno una cadena cualquiera 00:01:50
entre comillada a comillas dobles 00:01:53
es lo que hemos hecho hasta ahora, ¿vale? 00:01:55
podemos guardar cadenas de caracteres ahí 00:01:57
y podemos concatenarlas entre sí con el operador más 00:01:58
con la salvedad que tenemos que tener todos también en la memoria 00:02:02
que si concatenamos una cadena con cualquier dato primitivo que no sea cadena 00:02:06
automáticamente el dato primitivo que no es cadena 00:02:10
se convierte a cadena de caracteres para ser concatenado 00:02:14
y el resultado final es cadena de caracteres 00:02:19
bueno, todo eso es lo que hemos visto de cadenas, nada más 00:02:20
vale, entonces 00:02:22
que queremos recibir cadenas 00:02:24
como datos de entrada 00:02:27
igual que hemos recibido números hasta ahora 00:02:29
con next in, next double 00:02:30
vale, pues también podemos leerlas con el escáner 00:02:32
y así podemos ya hacer ejercicios 00:02:35
que reciban como datos de entrada cadenas 00:02:36
vale, pues por ejemplo 00:02:39
en lugar de asignar la cadena directamente por código 00:02:42
vamos a leer 00:02:45
una cadena de texto por teclado 00:02:47
el objeto este 00:02:51
hay que ponerle igualmente 00:02:54
bueno y ahora 00:02:56
como leemos con este objeto 00:03:07
pues igual que teníamos 00:03:10
la llamada a punto next in 00:03:11
para leer un entero del teclado 00:03:14
y guardarlo en la variable 00:03:16
pues tenemos una llamada 00:03:17
que es esta 00:03:20
next line 00:03:22
es esta entonces next line 00:03:23
se queda esperando 00:03:25
se queda esperando 00:03:27
A que tú metas texto 00:03:29
Y cuando le das a enter 00:03:30
En el momento de dar a enter 00:03:33
Él coge todos los caracteres 00:03:34
Que hayas metido, todos, da igual los que sean 00:03:37
Los coge todos 00:03:39
Y los guarda en la cadena de texto 00:03:40
¿Verdad? 00:03:42
¿Vale? O sea, si hacemos esto 00:03:57
El programa se quedará esperando aquí parado 00:03:59
Meteremos una cadena 00:04:01
Una vez que le hemos dado al enter 00:04:03
Pues ya saltará esta sentencia 00:04:05
Y nos dirá si ha introducido 00:04:08
Y aquí pondrá lo que ya hemos introducido 00:04:09
bueno 00:04:11
pues nada, ejecutamos esto 00:04:12
y ahí está esperando 00:04:15
efectivamente, ahí está esperando 00:04:20
ahí está parado, porque el next line fuerza 00:04:21
la parada del programa 00:04:23
y yo ya me pongo a escribir cosas 00:04:24
lo que a mí me dé la gana, letras, números, lo que sea 00:04:27
y en el momento de dar al enter, ese es el fin 00:04:29
esa es la marca de 00:04:31
he terminado, ya no quiero meter más 00:04:33
le doy al enter y ya está 00:04:35
y él coge todo eso 00:04:37
lo guarda en la variable 00:04:38
a la cual estamos asignando 00:04:41
lo guarda en la variable 00:04:43
y listo, y ahora ya me hace la siguiente 00:04:45
sentencia 00:04:47
bueno, en función 00:04:48
de las cadenas 00:04:53
también nos sirven como variables dentro del 00:04:55
switch case 00:04:57
por ejemplo yo podría hacer 00:04:57
esto, por ejemplo 00:05:01
si la cadena tiene hola 00:05:13
pues entonces puedo decir 00:05:15
que me conteste 00:05:16
si la cadena tiene 00:05:22
Adiós 00:05:27
No voy a poner tildes 00:05:29
Pues hala 00:05:32
Pues que me conteste 00:05:35
Que tiene cualquier otra 00:05:38
Break, me lo he saltado 00:05:40
Que tiene cualquier otra cosa 00:05:42
Que no es ni hola ni adiós 00:05:59
Pues lo que sea 00:06:01
¿Vale? Es decir 00:06:05
Lo que quiero ejemplificar es 00:06:11
Que la variable que va dentro del switch 00:06:13
la variable en función de la cual se decide 00:06:15
si voy por una rama o voy por otra 00:06:18
puede también ser de tipo string 00:06:19
no tiene que ser obligatoriamente 00:06:22
de tipo primitivo 00:06:24
puede ser de tipo string 00:06:25
puede ser de tipo string 00:06:27
y entonces los valores que pongo en el case 00:06:29
tienen que ser string 00:06:31
y eso son cadenas entrecomilladas 00:06:32
en el ejemplo anterior 00:06:35
aquí habíamos puesto números enteros 00:06:37
porque la variable nota 00:06:42
era entera 00:06:43
entonces habíamos puesto aquí números enteros 00:06:45
si la variable nota fuera double 00:06:49
pues yo aquí pondría números que puedan ser iguales a double 00:06:52
1.4, lo que sea, números decimales 00:06:55
pero aquí como cadena es string 00:06:58
yo pongo algo que es string 00:07:02
que es un texto entre comillas dobles 00:07:04
si yo pusiera un texto entre comillas simples 00:07:07
este se quejaría, obviamente 00:07:11
Porque un texto entre comillas simples no existe 00:07:13
Las comillas simples son para chat 00:07:15
Bueno, pues entonces 00:07:17
Este programa, vamos a suponer que le quitamos esto 00:07:21
Pues ya está 00:07:23
Este programa me contestará una cosa u otra 00:07:25
A función de lo que yo le haya dicho 00:07:27
Es lo que hará 00:07:28
Si yo ejecuto este mi programa 00:07:30
Le digo hola, pues hala, me contesta 00:07:32
Le digo adiós 00:07:35
Pues hala, me contesta 00:07:38
Le digo cualquier otra cosa 00:07:39
Pues no sabe 00:07:41
bueno, eso por un lado 00:07:44
las cadenas, por tanto, las podemos leer también por teclado 00:07:48
con esta sentencia, nextline, igual que leíamos los números 00:07:53
con next y nextdab, las podemos leer por teclado con nextline 00:07:58
vale, siguiente cosa 00:08:00
que os podéis encontrar, que os puede dar error y os podéis 00:08:07
volver locos, cuando uno encadena lecturas de números 00:08:11
y de cadenas 00:08:15
vamos a hacerlo aquí 00:08:16
ya hemos hecho esta parte del programa 00:08:18
ahora vamos a pedir un número 00:08:21
vamos a decirle ahora 00:08:23
introduzca 00:08:32
número 00:08:34
y vamos a leer un numerito 00:08:36
int n 00:08:38
vale 00:08:41
hemos leído el numerito 00:08:44
hemos pedido introduzca un número, muy bien, leemos el numerito 00:08:46
guardado en n 00:08:48
vamos a mostrarlo para ver que lo ha hecho bien 00:08:49
Ha introducido 00:08:52
Quito las tildes 00:08:55
El número y concatenamos 00:08:59
N, vale 00:09:01
Vamos a volver a 00:09:02
Pedirle ahora otra cadena 00:09:05
No pongo las tildes 00:09:09
El nombre del tío 00:09:14
Se supone que será 00:09:18
Una cadena de caracteres 00:09:19
Pues leemos aquí 00:09:22
Scan.next 00:09:23
Line 00:09:25
Vale 00:09:27
Y ahora vamos a poner 00:09:31
Hola 00:09:35
Quien sea 00:09:40
Vale 00:09:43
Bueno, pues este programa pide un número 00:09:45
Hola, no sé qué, le vamos a poner además 00:09:48
Introdujiste 00:09:52
Introdujiste 00:09:58
O ciste, ya ni lo sé 00:10:03
¿Es con J o con C? 00:10:04
Introdujiste, introdujo, introduciste 00:10:08
vale, por ejemplo 00:10:10
le pide un número 00:10:19
vale 00:10:21
y ahora, ¿cómo te llamas? 00:10:22
Pepito, hola Pepito, metiste 00:10:25
7, vale 00:10:27
si quisiéramos hacer eso, vete a saber por qué razón 00:10:28
para 00:10:31
estamos en un momento de interfaz 00:10:32
de una aplicación que estamos haciendo, le estamos pidiendo datos 00:10:34
le estamos realimentando 00:10:37
diciendo, ah sí, te llamas tal, has metido esto 00:10:38
bueno, estamos en esa fase 00:10:40
pues venga, vamos a ejecutar esto 00:10:41
Se supone que esto va a funcionar. Va a leer el número, se va a quedar primero aquí parado y va a decir este mensaje. Luego se va a quedar parado en NextLine. Se va a quedar parado después de cómo te llamas. Se va a quedar parado cuando ya metamos el nombre de la persona y ya nos dirá esto. 00:10:44
Bueno, y esto de aquí del principio 00:11:00
Bueno, antes nos va a pedir la cadena 00:11:03
Para decir 00:11:06
Vamos a comentarlo todo 00:11:07
Para no 00:11:09
Molestar 00:11:13
Se queda comentada la parte anterior 00:11:14
Nuestro programa ahora mismo solamente tiene 00:11:17
Esto 00:11:20
Entendemos todo el mundo 00:11:20
Vale, vamos a ejecutarlo 00:11:24
Ese es el código 00:11:27
Que queremos ejecutar, el que está ahí 00:11:31
Vale, estamos aquí 00:11:33
ha mostrado introduzca número, se queda aquí paradito 00:11:37
introduzca número, venga, vale 00:11:39
vamos a meter el 45 00:11:41
aquí ha llegado 00:11:43
ha introducido el número 45 00:11:46
muy bien 00:11:48
luego me dice, ¿cómo te llamas? 00:11:48
¿cómo te llamas? vale 00:11:51
y aquí, debería haberse quedado esperando 00:11:52
y me ha fallado 00:11:55
no debería haberse quedado aquí esperando 00:11:56
a que yo le metiera una cadena 00:11:59
ahí esperando 00:12:00
y una vez que se la he metido 00:12:02
ahora ya hubiera mostrado esto 00:12:04
Pues no lo ha hecho 00:12:06
No solo no se ha quedado esperando aquí 00:12:08
No solo no se ha quedado 00:12:10
Sino que encima le ha dado a nombre 00:12:11
Un valor vacío 00:12:14
O sea, aquí ha pasado algo raro 00:12:15
Que no preveíamos 00:12:18
¿Verdad? 00:12:20
Está claro, ¿no? Que no preveíamos que pasara esto 00:12:22
Preveíamos que se quedara parado ahí 00:12:24
Esperando un nombre 00:12:26
Pues no lo ha hecho 00:12:27
¿Por qué no lo ha hecho? 00:12:28
Por un funcionamiento del escáner 00:12:32
Que memorizaros y aprenderos desde ya 00:12:33
porque vais a tener que contar con él 00:12:35
y arreglarle cada vez que uséis scanner 00:12:38
en todos vuestros programas 00:12:39
bueno, pues que cuando uno usa 00:12:41
una lectura de número, me da igual que sea 00:12:43
next i, next double 00:12:46
cuando uno lee un numerito 00:12:47
en realidad ha metido el numerito 00:12:49
45, yo he metido aquí 45 00:12:52
y el enter 00:12:54
pero claro, en la variable n 00:12:55
la variable n solo quiere el numerito 00:12:57
el enter no lo quiere, solo quiere el numerito 00:12:59
entonces coge el 45 00:13:02
y el enter se ha quedado ahí 00:13:03
en el buffer del teclado 00:13:06
sin que nadie lo procese 00:13:07
muerto de risa y está en el buffer 00:13:09
entonces el buffer no se ha quedado vacío 00:13:11
es el problema, se ha quedado con el salto de línea 00:13:13
que yo di después del 45 00:13:16
vale, llega el como te llamas 00:13:18
ahora llega el next line 00:13:21
¿qué hacen esas sentencias? ya lo dijimos en su momento 00:13:22
se van al buffer del teclado 00:13:24
a sacar lo que haya y si no hay nada 00:13:26
es cuando se quedan esperando 00:13:28
¿qué ocurre? que aquí sí que hay algo 00:13:29
aquí está el enter 00:13:32
del next in anterior 00:13:34
está el enter 00:13:37
entonces este next line 00:13:38
coge eso, creyendo que es lo que le hemos metido 00:13:39
porque está ahí esperando, y eso que es 00:13:42
la nada y un enter 00:13:44
la nada, pues coge la nada 00:13:46
se le asigna nombre, porque el enter 00:13:48
es el fin del next line 00:13:50
y es lo que ha hecho, ha funcionado perfectamente 00:13:52
si ha ido al buffer del teclado 00:13:54
ha visto el vacío más el enter 00:13:56
que se ha quedado después del next in 00:13:59
lo ha visto y ha dicho, pues será esto 00:14:01
Lo ha cogido, aquí está ese vacío y ya está. 00:14:02
Entonces, situación del escáner que no nos gusta y funciona mal. 00:14:08
Cuando identificáis que tenéis una secuencia de sentencias en las cuales leéis un número, 00:14:13
next in, next double, next short, y luego después haces un next line. 00:14:18
Eso no va a funcionar nunca. 00:14:22
Por esto que os estoy diciendo. 00:14:24
Entonces uno se vuelve loco. 00:14:26
Dice, pero ¿por qué no se para? ¿Por qué sigue? 00:14:28
aquí lo estamos viendo pero el programa es muy corto 00:14:30
pero un programa más largo 00:14:33
creíamos que todo está bien 00:14:34
y resulta que 00:14:35
340 días después 00:14:38
está funcionando mal 00:14:41
porque cosas que creemos que tienen datos 00:14:44
tienen vacíos 00:14:45
el programa no ha fallado, no ha fallado en ningún momento 00:14:47
el programa no ha fallado, simplemente ha metido un vacío 00:14:49
donde yo creía que hay un nombre 00:14:51
ha metido un vacío 00:14:53
entonces a lo mejor nos damos cuenta 00:14:53
200 días después que el programa está trabajando 00:14:56
con vacíos y lo que está haciendo no vale para nada 00:14:59
bueno pues 00:15:01
no hay más manera de arreglarlo 00:15:03
que quitando 00:15:05
que después de leer un número 00:15:07
después de leer un número 00:15:09
si nosotros automáticamente hacemos un next line 00:15:10
limpiamos ese enter que se ha quedado ahí 00:15:13
lo limpiamos 00:15:17
así 00:15:18
ala 00:15:20
el enter que se quedó aquí limpito 00:15:21
lo acabo de limpiar, ya no hay nada en el buffer 00:15:25
claro 00:15:27
este scanless line que se ha quedado ahí suelto 00:15:28
diríamos, hombre, pero normalmente 00:15:31
siempre asignamos a las cosas 00:15:32
lo que hacemos, vamos a asignárselo a algún lado 00:15:35
sí, claro, yo puedo hacer ahí un string 00:15:36
lo que quiera para asignárselo 00:15:39
pero puedo pasar de él 00:15:40
o sea, si yo quito esto 00:15:42
lo que estoy diciendo es 00:15:44
haz la evaluación de la expresión 00:15:47
que la evaluación de la expresión es 00:15:49
lee del teclado 00:15:51
y el resultado 00:15:53
tíralo a la basura 00:15:54
no se lo asignes a nadie 00:15:56
tírala a la basura 00:15:58
cuando evalúo una expresión puedo optar 00:15:58
por asignársela a una variable 00:16:01
por asignársela 00:16:04
o por pasar de ella y lanzarla a la basura 00:16:05
pues en este caso como lo que quiero es 00:16:07
no asignarla a una variable 00:16:10
sino pasar de ella y tirársela a la basura 00:16:12
pues pongo la expresión sin más 00:16:13
¿vale? 00:16:15
entonces ahora ya, sí, uno tiene que acordarse 00:16:17
después de leer números 00:16:20
si va a leer caracteres 00:16:21
cadenas 00:16:24
limpiar ese enter que se ha quedado ahí muerto de risa 00:16:26
entonces ahora esto sí 00:16:28
ya sí que nos funcionará 00:16:30
introduzca número 76 00:16:31
ahora, ¿cómo te llamas? 00:16:34
ahora ya sí que se ha quedado esperando, ahora ya sí 00:16:36
porque este next line 00:16:38
limpió ese salto de línea 00:16:40
al limpiar ese salto de línea 00:16:41
el next line este cuando ha ido 00:16:43
al buffer ha visto que no tiene nada 00:16:46
entonces no le queda más remedio que estar esperando 00:16:47
ala, ya está 00:16:50
vale 00:16:52
bueno, pues entonces, ahora ya 00:16:56
podemos usar el escáner para leer cadenas 00:16:58
sin ningún miedo 00:17:00
pero cuidado con la combinación 00:17:01
leo número y después leo cadena 00:17:04
porque de la cadena va a pasar 00:17:07
porque se va a quedar con el enter anterior 00:17:09
cuando encadenáis varios números seguidos 00:17:11
varios next in seguidos, no hay problema 00:17:14
cuando hacéis un next in, next in 00:17:16
después de un next in el enter se ha quedado 00:17:18
eso está bien, eso siempre pasa 00:17:20
pero el siguiente next in 00:17:22
Cuando ve que lo que hay en el buffer 00:17:24
Es un enter 00:17:26
El objeto escáner está pensado 00:17:27
Para que diga, no, esto no me vale como número 00:17:31
Y se queda esperando igualmente 00:17:32
¿Vale? Pero la combinación peligrosa 00:17:34
La peligrosa, la que tenéis que memorizar 00:17:37
Que es peligrosa es 00:17:38
Lectura de número, inmediatamente después next line 00:17:39
Esa es la secuencia por la que 00:17:43
El escáner no funciona 00:17:44
No es que no funcione, es que tiene este efecto 00:17:46
¿Vale? Tiene este efecto 00:17:48
Y como es una secuencia que podemos utilizarla mucho 00:17:50
Querer leer números y después nombres o lo que sea 00:17:53
Pues acordaos de esto 00:17:55
¿Vale? Acordaos de esto 00:17:57
Lo memorizáis para que cuando os den errores 00:17:59
Automáticamente lo ubiquéis 00:18:01
Bueno, pues ahora ya sabiendo leer 00:18:02
No solo números, sino también cadenas 00:18:07
Se nos abren 00:18:09
Más opciones para poder hacer ejercicios 00:18:11
Para poder hacer cosas 00:18:14
¿Vale? 00:18:15
Por ejemplo, vamos a ver 00:18:27
Tenemos ahora 00:18:29
vamos a 00:18:30
con las cadenas estas de aquí 00:18:32
tenemos ya leído el nombrecito 00:18:34
con este nombre 00:18:37
yo que puedo hacer 00:18:39
con este nombre obviamente lo que puedo hacer es mostrarlo 00:18:40
por consola, como hemos hecho siempre 00:18:43
vale, pero hay una cosa 00:18:44
que también podemos hacer 00:18:47
que tenemos que incorporar desde ya 00:18:48
porque la necesitamos para muchos ejercicios 00:18:50
de una cadena de caracteres 00:18:53
puede ser que uno necesite 00:18:55
conocer el carácter 00:18:56
que hay en determinada posición 00:18:58
A lo mejor le interesa, sabe el carácter que hay en determinada posición 00:19:00
¿Vale? 00:19:03
Bueno, pues ¿cómo hacemos eso? 00:19:06
Pues si yo tengo una cadena cualquiera 00:19:08
Como por ejemplo nombre, una cadena cualquiera 00:19:09
Yo puedo hacer esta llamada 00:19:11
La llamada está de aquí 00:19:13
Y poner aquí una posición 00:19:16
Que empieza desde la 0, 1, 2 00:19:17
Y esta llamada ¿qué me hace? 00:19:20
Me devuelve el char 00:19:23
Que está en la posición 00:19:25
que yo haya puesto ahí 00:19:29
vale, entonces incorporar 00:19:30
esto desde ya 00:19:34
si yo tengo un string 00:19:36
y a ese string 00:19:37
le hago la llamada charat 00:19:39
con la A mayúscula 00:19:41
y pongo aquí un número entero 00:19:43
un número entero 00:19:45
lo que hace esta expresión es 00:19:46
devolverme un char 00:19:49
y es el char que está en esa 00:19:51
posición dentro de la cadena 00:19:53
asumiendo la primera 00:19:55
a la cero, asumiendo la primera 00:19:57
a la cero, entonces en este caso 00:19:59
por ejemplo 00:20:01
esta llamada 00:20:03
me haría, me devolvería 00:20:05
la inicial 00:20:07
la inicial 00:20:09
del nombre 00:20:10
vale, me devolvería 00:20:12
la inicial del nombre 00:20:15
en este caso, vale 00:20:16
pues venga, en lo que queda de 00:20:28
en lo que queda de 00:20:30
de clase 00:20:32
Para practicar, vamos a ver 00:20:34
Vamos a incorporar aquí 00:20:36
Vale, pues venga 00:20:38
Hacer este 00:21:22
Esto no 00:21:24
Esto no es de switch case ni de nada 00:21:25
Esto ahora mismo es para que practiquéis 00:21:28
Con esto último que hemos visto, la lectura de cadenas 00:21:30
Vale 00:21:33
Pues venga 00:21:34
A ver que, y lo muestre 00:21:36
Pero se supone que el nombre que ha introducido 00:21:38
Juan, Lourdes, lo que sea, todo en minúscula 00:21:40
Pues va a mostrarlo 00:21:42
pero poniendo la inicial en mayúscula 00:21:44
acordaos de, la idea ahora es que ligueis conocimientos que ya sabéis 00:21:49
de char, de tabla ASCII, de todo eso 00:21:53
y leer un nombre 00:21:57
venga a ver que 00:21:59
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
7
Fecha:
16 de octubre de 2023 - 13:34
Visibilidad:
Público
Centro:
IES ROSA CHACEL
Duración:
22′ 07″
Relación de aspecto:
1.78:1
Resolución:
1280x720 píxeles
Tamaño:
422.05 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid