Saltar navegación

20260924 Operadores_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 24 de septiembre de 2026 por Raquel G.

1 visualizaciones

Más información Transcripción

Descargar la transcripción

Vale, porque hay dos versiones. Vale, esta es la versión que hace el trabajo para la máquina virtual más ágil y esta lo hace más lento. Vamos a ver a qué significa eso. 00:00:01
Pero en ambos casos los dos son unan y si las dos son ciertas, la resultante es cierta. Y en ambos casos estos dos son unor. Si una de las dos es cierta, la resultante es cierta. 00:00:18
Es decir, el resultado que dan es el mismo, ambas son un AND lógico, ambas ciertas, la total cierta, alguna de las dos cierta, la total cierta, pues esta funciona igual que esta y esta funciona igual que esta. 00:00:31
La diferencia es cómo las procesa la máquina virtual y eso tiene implicaciones. 00:00:50
Ejemplo, ejemplo, a ver, esta misma condición de aquí, vamos a volver a ponerla aquí, vale, vamos, uy, vale, esta misma condición de aquí. 00:00:54
Vamos a evaluar lo que me sale 00:01:21
Ejecuto esto 00:01:30
Falso 00:01:32
Muy bien, me sale falso porque 00:01:34
A no es menor que B y C simultáneamente 00:01:36
Es de esperar que me salga falso 00:01:40
Porque A es menor que B, sí 00:01:41
Pero A no es menor que C 00:01:44
Luego esta es true 00:01:46
Esta es falso 00:01:48
True y falso 00:01:50
Falso 00:01:52
¿Vale? 00:01:53
¿Sí? Vale, voy a poner yo la versión abreviada del operador, a ver qué me sale, lo mismo, porque ambos son operadores lógicos idénticos en cuanto al resultado que producen, esta es true, pero esta es mentira, con lo cual, verdad y mentira, es mentira. 00:01:55
Vale, pues efectivamente eso me ha salido 00:02:22
Entonces, ¿por qué existe el doble si es más pesado de escribir? 00:02:24
¿Vale? 00:02:30
Porque el doble le quita trabajo a la máquina virtual 00:02:31
¿Cómo? 00:02:34
Vamos a cambiar estas para que la falsa sea la primera 00:02:35
Voy a poner la falsa la primera 00:02:39
Y la true la segunda 00:02:42
Vale 00:02:48
Pues con el doble operador 00:02:49
Seguirá siendo falsa 00:02:52
Porque ahí hay, son conmutativas, ¿no? Porque esta es falsa y esta es true, falso y true, falso, muy bien, lo ejecuto y falso, vale, pongo el operador sencillo y me seguirá dando false, porque esta es false y esta es true, false y true, false, muy bien, efectivamente me sigue saliendo false, vale. 00:02:54
pero el funcionamiento interno ha sido 00:03:21
distinto 00:03:24
¿qué ha pasado cuando hemos puesto el doble ampersand? 00:03:24
la máquina virtual ha llegado 00:03:28
y se ha puesto a evaluar 00:03:29
ha hecho A menor que C 00:03:31
voy a ver lo que vale A 00:03:34
8, voy a ver lo que vale 00:03:35
5, A menor que C 00:03:38
false 00:03:42
y luego ha visto que hay un AND 00:03:43
y ha dicho 00:03:46
me da igual lo que haya después 00:03:47
false y cualquier otra cosa 00:03:49
es que va a ser false 00:03:51
es que me da igual 00:03:53
en cuanto ha visto esto ha dicho 00:03:54
como si esto es un true gigante 00:03:57
que más me da 00:03:59
false y cualquier otra cosa 00:03:59
true o false es false 00:04:02
con lo cual la máquina virtual esto ni lo mira 00:04:03
pasa completamente de ello 00:04:07
lo ignora completamente 00:04:09
pasa 00:04:11
con lo cual ahorramos ciclos de memoria 00:04:11
ahorramos tiempo 00:04:14
la máquina virtual no se ha entretenido 00:04:15
a buscar el valor de A, ni a buscar el valor de B, a compararlos 00:04:18
ha pasado, no se ha entretenido, hemos ahorrado tiempo 00:04:23
vale 00:04:27
esto en el caso, con el doble 00:04:29
ampersand, si la primera es falsa 00:04:36
no se detiene a mirar 00:04:44
la segunda, porque le da igual, no se detiene a 00:04:48
Mirar la segunda 00:04:50
Ni se detiene 00:04:53
Vale 00:04:54
Vamos a hacer esto mismo pero con un ampersand simple 00:04:55
Vale 00:05:02
Con un ampersand simple 00:05:13
Con el simple 00:05:14
Ampersand 00:05:18
Vamos a ver 00:05:20
Vale 00:05:24
Misma expresión, simple ampersand 00:05:29
Me da falsa igualmente, ¿verdad? 00:05:31
Me da falsa igual 00:05:34
Eso no cambia 00:05:35
Pero internamente, ¿qué ha ocurrido? 00:05:35
Él ha evaluado todo sí o sí 00:05:37
Si hay solo una en persán 00:05:40
Aunque esto no le haga falta evaluarlo 00:05:42
Aunque no le haga falta 00:05:44
Lo evalúa igualmente 00:05:45
Este es falso 00:05:47
Dice 00:05:49
Sé que me va a dar igual lo que haya detrás 00:05:51
Sé que me va a dar igual 00:05:53
El total va a ser falso, seguro 00:05:54
Porque falso y cualquier otra cosa es falso 00:05:56
¿Verdad que sí? 00:05:59
Hasta ahí lo tenemos claro 00:06:01
Entonces, me va a dar igual 00:06:02
Pero voy a entrar a evaluarlo igualmente 00:06:05
porque me están obligando 00:06:07
o porque hay una empresa en simple 00:06:08
me están obligando, pues entro y lo evalúo 00:06:10
pero el resultado final es el mismo 00:06:12
ahí no hay tutía 00:06:14
esa es la diferencia 00:06:14
y ahora 00:06:17
debería surgir una pregunta natural en vosotros 00:06:19
entendida la diferencia 00:06:22
que esta la evalúa sí o sí 00:06:23
aunque no le haga falta porque le estamos obligando 00:06:25
¿qué pregunta me haríais? 00:06:28
muy bien 00:06:34
la pregunta natural es 00:06:35
¿y de qué me sirve a mí 00:06:36
obligarle a evaluar algo 00:06:38
que no va a utilizar 00:06:41
¿de qué me va a servir? 00:06:42
bueno, pues 00:06:45
nos puede servir 00:06:46
porque dentro de una expresión 00:06:48
de estas 00:06:51
a la vez 00:06:52
a la vez que ponemos 00:06:54
una variable para que forme parte de la expresión 00:06:57
podemos a la vez 00:07:00
por ejemplo 00:07:02
es un ejemplito, pero hay unas cosas 00:07:03
asignarle un valor 00:07:05
por ejemplo, podemos, si yo quiero 00:07:06
vale, y esto sí que muchas veces lo hacemos 00:07:09
pero bueno, ya estamos en contextos más adelante 00:07:12
y lo iréis viendo, entonces por ejemplo 00:07:15
yo puedo, esto de aquí a menor que b 00:07:17
a la vez que uso una variable 00:07:22
en cualquier expresión, a la vez que la uso 00:07:25
en el momento de usarla, se me permite 00:07:28
darle ahí un valor, en el momento de usarla en una expresión 00:07:31
exactamente igual que hemos visto 00:07:35
que en el momento de declararla 00:07:37
se nos ha permitido darle un valor 00:07:39
pues en el momento de usarla 00:07:40
en una expresión se nos permite también 00:07:43
darle un valor, en el momento de usarla 00:07:45
aquí la estoy usando para compararla 00:07:47
con B y en ese momento 00:07:49
de usarla, si me da la gana 00:07:51
puedo darle un valor 00:07:53
mediante una asignación 00:07:55
por ejemplo así 00:07:56
a la vez que 00:07:59
la estoy usando, le doy 00:08:01
un valor, en el momento de 00:08:03
usarla, puedo 00:08:05
vale 00:08:06
entonces 00:08:09
¿qué implica? 00:08:11
aquí, que cuando yo la compare 00:08:14
con la b, cuando la compare 00:08:16
la voy a comparar ahora con el valor 8 00:08:18
no con el valor que tenía 00:08:20
porque la acabo de reasignar 00:08:21
la acabo de reasignar 00:08:24
¿vale? 00:08:26
entonces voy a hacerlo aquí también 00:08:28
a igual a 00:08:30
¿vale? lo voy a hacer aquí también 00:08:35
las dos versiones 00:08:39
entonces 00:08:40
son idénticas las dos expresiones 00:08:43
entonces aquí en el momento 00:08:46
de usarla la reasigno 00:08:49
y una vez que ya la he asignado ya la uso 00:08:51
en la expresión 00:08:53
¿vale? pero ¿qué ocurre? 00:08:54
el resultado 00:08:58
final del AND 00:08:59
ese es el mismo 00:09:00
ponga yo el doble ampersand que el simple ampersand 00:09:03
sigue siendo el mismo, como esta es 00:09:05
falso, es que esto nos da igual 00:09:07
lo que pase, es que nos da igual 00:09:09
aunque sea a 8 o 7 nos da lo mismo 00:09:10
va a ser falso, y aquí igual 00:09:13
como esta es falso 00:09:14
aquí esto nos da igual, va a ser 00:09:16
falso, pero la diferencia 00:09:19
es que aquí, aquí no 00:09:21
entra, porque hay 00:09:23
el doble ampersand, esto es como de repente 00:09:25
ha desaparecido del mapa 00:09:27
porque hay un doble ampersand y no lo necesito 00:09:28
y con el simple ampersand 00:09:31
le obligo a entrar 00:09:33
con lo cual si pongo un simple ampersand 00:09:34
la A se quedaría con 8 00:09:37
porque le he obligado a entrar aquí 00:09:39
pero si pongo un doble ampersand 00:09:41
esto lo tira a la basura 00:09:44
la A no se reasignaría 00:09:46
se quedaría con el valor de arriba 00:09:48
luego esa es la implicación 00:09:49
de un doble ampersand y un simple ampersand 00:09:53
el resultado final del boolean 00:09:54
es idéntico en ambos casos 00:09:56
pero si en la segunda parte 00:09:58
hacemos alguna asignación 00:10:02
además de comparar 00:10:04
hacemos alguna asignación 00:10:06
con el doble ampersand esa asignación se ignora 00:10:07
porque ni entramos 00:10:10
pero con el simple ampersand 00:10:12
esa asignación no se ignora 00:10:14
y se hace 00:10:16
¿vale? 00:10:16
vamos a comprobarlo aquí, yo aquí voy a mostrar 00:10:19
a cuánto tenía, ojo es que qué casualidad 00:10:22
a 8, pues le voy a poner 00:10:24
a igual a 00:10:25
para cambiarle, a igual a 1 00:10:30
¿vale? entonces voy a mostrar aquí 00:10:31
el valor final de la condición y el valor de A 00:10:34
A igual a 00:10:38
el valor que tenga A, vale, y ahora voy a mostrarlo 00:10:45
aquí, control V 00:10:52
en ambos casos, vale, vale, pues 00:10:55
cuando yo ejecute esto, me dará 00:11:02
falso, porque a menor que c es falso, y al no haber entrado aquí, a no habrá modificado 00:11:05
su valor, a no lo habrá modificado, porque aquí no ha entrado, con lo cual a me va a 00:11:13
dar que vale 8, sigue valiendo 8, pero cuando haga esta parte, el condicional va a seguir 00:11:18
siendo falso, eso no cambia, va a seguir siendo falso, porque a es menor que c va a seguir 00:11:27
Pero aquí A sí se va a reasignar, porque aquí habremos entrado porque nos obliga el simple ampersand. 00:11:31
Aquí sí que se va a reasignar, con lo cual aquí A habrá acabado valiendo 1. 00:11:41
Vamos a ejecutarlo y efectivamente los valores resultantes del condicional van a ser siempre idénticos. 00:11:47
Me da igual doble ampersand que simple, pero pueden pasar cosas distintas en las variables que haya a mi izquierda, porque si se están reasignando, que yo puedo reasignar a la vez que uso, a la vez que uso en una expresión puedo reasignar, si se están reasignando, esta reasignación se hace y esta no. 00:11:55
si esta fuera true 00:12:20
ahora sí que funcionarían 00:12:26
idénticas las dos, por ejemplo 00:12:29
si c es igual a 00:12:30
si fuera true 00:12:34
ahora 00:12:37
el doble ampersand 00:12:40
también entraría aquí 00:12:42
¿por qué? porque a menor que c le he dado true 00:12:43
le he dado true 00:12:46
con lo cual necesita saber la siguiente 00:12:47
entonces ahí es que tiene que entrar 00:12:50
para evaluar el condicional, tiene que entrar, sí o sí 00:12:51
Entonces, al entrar aquí, ya reasignará a A1. 00:12:54
¿Vale? 00:12:58
Entonces, si ejecutamos esto, veremos que ya en la primera vez ha reasignado a A1. 00:13:00
Porque ha tenido que entrar. 00:13:08
Ha tenido que entrar porque estará true, con lo cual necesita la segunda parte. 00:13:09
Para saber si es false o true. 00:13:14
Si es false, el total será false. 00:13:16
Y si es true, el total será true. 00:13:18
El total será true, sí. 00:13:19
¿Vale? 00:13:25
bueno, pues por eso existen 00:13:25
las dos variantes 00:13:28
normalmente, pues veréis 00:13:30
en la mayoría de los casos, pues depende 00:13:33
porque hay muchos estilos de programación distintos 00:13:34
en gustos de programación 00:13:36
pues el ampersand simple, lógicamente es muy común 00:13:38
pero claro, hay que 00:13:41
tener cuidado cuando se usa de que yo 00:13:43
en la segunda parte no haga instrucciones 00:13:45
que cuando accedemos a ficheros 00:13:47
a bases de datos, solemos meter 00:13:49
las instrucciones de acceso ahí en esa 00:13:51
segunda parte, con lo cual en ese caso 00:13:53
doble ampersand, claro 00:13:55
¿entendidísimo? 00:13:56
muy bien 00:14:03
bueno, pues ahora sí que sí 00:14:03
para que podamos 00:14:09
hacer alguno de los primerillos ejercicios 00:14:11
sencillos de la hoja 00:14:12
que ahora 00:14:15
os paso 00:14:18
¿no nos va a quedar más remedio que ver el input? 00:14:19
vamos a tener que ver el input, ¿no? 00:14:22
¿qué vamos a hacer? 00:14:23
bueno, pues 00:14:25
nosotros hasta ahora hemos asignado 00:14:27
a nuestras variables 00:14:30
valores directamente por programa 00:14:32
no las hemos jarcodeado 00:14:34
como se dice, las he metido ahí 00:14:36
pero hombre, no metemos los datos 00:14:38
a los programas así 00:14:40
porque entonces si yo quiero hacer este programa 00:14:41
con valores distintos 00:14:44
tendría que irme al código fuente y cambiar el valor 00:14:45
y no, el usuario de un código 00:14:48
no tiene acceso al código fuente 00:14:50
lógicamente 00:14:52
entonces nosotros necesitamos 00:14:53
poder dar los datos de trabajo 00:14:55
en el momento de ejecutarlo 00:14:57
y desde el teclado, entonces el programa te dirá 00:15:00
¿qué valor quiere para la variable A? 00:15:03
tú se lo asignas por teclado y ya tenemos que ver 00:15:07
qué sentencia hacer para que el programa sea capaz de leer del teclado 00:15:10
un valor y asignarse a la variable 00:15:14
bueno, pues ahora para ver eso 00:15:15
hay cosas que vamos a tener que creernos sí o sí 00:15:20
porque nos falta información 00:15:23
¿por qué? porque para leer del teclado necesitamos un objeto 00:15:25
Y ni siquiera sabemos lo que es un objeto 00:15:29
Con lo cual vamos a usar el objeto 00:15:30
Sin más 00:15:33
Aunque no entendamos que es un objeto 00:15:34
Pero por ahora vamos a usarlo 00:15:37
Para la tarea concreta de leer del teclado 00:15:39
¿Vale? 00:15:41
Venga, lo voy a hacer en 00:15:44
Otra 00:15:45
Otro 00:15:46
Otro paquete 00:15:50
Teclado, venga 00:16:00
Entrada, salida 00:16:01
Entrada, salida por consola 00:16:05
La consola es el teclado y el monitor 00:16:10
vamos, entrada y salida 00:16:11
por consola 00:16:14
vale, pues vengo 00:16:14
yo tengo mi variable 00:16:29
a, nombre muy feo elegido 00:16:31
pero bueno, mi variable a 00:16:34
venga voy a ponerle un nombre que tenga sentido 00:16:36
para que no sea todo a, x, y 00:16:38
tengo mi variable edad 00:16:39
y yo con esta edad quiero hacer 00:16:41
cosas, lo que sea 00:16:44
pero el valor de la edad 00:16:45
tiene que ser el valor del usuario 00:16:48
de mi programa 00:16:50
con lo cual yo no puedo 00:16:50
ponerle aquí edad 00:16:53
igual a 34, pues no 00:16:55
porque a veces usará el programa 00:16:57
alguien de 34, a veces alguien de 12, a veces alguien 00:16:59
de 85, entonces 00:17:01
el valor de la edad 00:17:03
no se mete aquí, el valor 00:17:04
de la edad tendremos que 00:17:07
el usuario introducirlo en el momento 00:17:09
de la ejecución del programa 00:17:11
lo introduce y se 00:17:13
asigna, entonces tendremos 00:17:15
que ver como 00:17:17
leer un valor del teclado 00:17:18
vale, pues para leer 00:17:21
un valor del teclado 00:17:23
se puede hacer de muchas maneras, pero bueno 00:17:24
vamos a la opción más cómoda 00:17:27
necesitamos una cosa 00:17:29
que se llama 00:17:31
escáner 00:17:33
vale 00:17:34
entonces, igual que cuando necesitamos un int 00:17:35
ponemos int a 00:17:39
o cuando necesitamos un string 00:17:40
ponemos string texto 00:17:43
pues resulta que ahora no necesitamos 00:17:44
un int a y un string text, ahora necesitamos un objeto scanner 00:17:47
pues pongo scanner que es el tipo que necesito y aquí el nombre que le quiera dar yo a ese objeto 00:17:50
el que me dé la gana, vale 00:17:55
bueno pues scanner es otro tipo de dato 00:17:58
igual que int, que string, pero en particular 00:18:02
el tipo scanner es un tipo de dato objeto y sirve 00:18:07
para una cosa en concreto, que es para leer del teclado 00:18:11
Igual que string vale para guardar cadenas de caracteres, pues escáner vale para leer del teclado. 00:18:14
Pues yo lo necesito y lo declaro ahí, igual que declaro una variable cualquiera. 00:18:22
Pero claro, le tengo que dar un valor a ese objeto, para que ese objeto exista y pueda leer. 00:18:29
Pues ¿cómo hago que ese objeto exista? 00:18:38
igual que a texto 00:18:41
yo hago que ese objeto exista 00:18:42
dándole un valor concreto 00:18:44
pues para hacer que el objeto escáner 00:18:45
exista, tengo que hacer 00:18:48
algo un pelín más complicado 00:18:50
que es escribir esto 00:18:52
¿vale? 00:18:54
entonces escribiendo esto, hago que 00:19:02
ese objeto exista 00:19:04
de nuevo tenemos que creérnoslo 00:19:06
no lo entendemos, porque ¿qué significa new? 00:19:09
el espacio, ¿qué es esto? 00:19:12
bueno, pues 00:19:14
significa cosas muy concretas de la programación 00:19:14
entrada objetos, que ya veremos 00:19:18
ahora mismo nos tenemos 00:19:20
que quedar con que para 00:19:22
crear este objeto 00:19:23
y yo poder usarlo para leer del teclado 00:19:25
lo tengo que crear de esta 00:19:27
manera 00:19:30
igual que cuando creo un string lo creo de esta manera 00:19:30
poniendo aquí la cadena 00:19:34
de texto que yo quiera, pues cuando creo un 00:19:35
escáner lo creo de esta manera, poniendo 00:19:37
esto, sí o sí 00:19:39
vemos que nos sale rojito 00:19:43
nos sale rojito 00:19:45
porque este tipo de dato 00:19:48
está ya creado 00:19:49
pero guardado 00:19:51
en una carpeta de cosas 00:19:53
porque de nuevo, como ya entenderemos 00:19:55
Java, la máquina virtual 00:19:57
organiza todas las clases 00:20:00
de las que dispone 00:20:02
que string es una de ellas 00:20:03
las organiza en carpetitas 00:20:06
entonces, él sabe siempre 00:20:07
en qué carpeta está esto 00:20:09
en qué carpeta está esto 00:20:11
pero no sabe en qué carpeta está scanner 00:20:12
ni muchas otras cosas que usaremos, no las sabe 00:20:15
entonces te dice 00:20:17
no tengo ni idea 00:20:19
de donde está esto que me has pedido 00:20:21
que yo cree, no tengo ni idea 00:20:23
vale, pues tenemos que decirle 00:20:24
donde está y se lo decimos 00:20:27
escribiendo esto 00:20:29
eeeh 00:20:31
donde está 00:20:41
un momentito 00:20:42
vale, escribiendo esto 00:20:43
esto que tiene que ir 00:20:50
después del package, obligatoriamente 00:20:54
no antes, sino aquí 00:20:55
justo después del package 00:20:57
significa, oye este 00:20:59
escáner que yo te estoy diciendo 00:21:01
que me hagas, está aquí 00:21:03
está aquí 00:21:05
ah vale, ya lo encuentro 00:21:06
y me sale aquí rojo 00:21:08
que no entendemos por qué hay que 00:21:11
decirle esto, que significa el in, por qué 00:21:13
significa el útil, por qué he puesto el new, pues claro 00:21:15
lógicamente no lo entendemos 00:21:17
porque no sabemos cómo funciona el pronunciamiento de objetos 00:21:19
pero ya lo entenderemos, ahora solamente 00:21:21
nos importa saber cómo leer 00:21:23
un dato de un teclado 00:21:25
vale 00:21:27
pues el primer paso está 00:21:29
hemos creado esta cosa 00:21:31
a la que le puedo dar el nombre 00:21:34
que me dé la gana 00:21:36
igual que a la variable cadena de texto 00:21:37
le doy el nombre que me da la gana 00:21:40
o a la variable a le doy el nombre que me da la gana 00:21:42
pues a este objeto le doy el nombre que me da la gana 00:21:44
vale 00:21:46
vale, pues ahora que ya tengo este 00:21:47
objetillo creado 00:21:50
¿cómo puedo yo 00:21:51
leer, por ejemplo, un número entero del teclado. 00:21:54
Pues este objeto, por ser un objeto, 00:21:58
de nuevo, aunque aún no lo entendamos, 00:22:01
es capaz de ejecutar acciones. 00:22:03
¿Vale? O sea, los objetos pueden ejecutar acciones. 00:22:07
¿Y cómo las ejecutan? 00:22:09
Con un punto poniendo el nombre de la acción, 00:22:10
de la acción a ejecutar. 00:22:13
Pues resulta que la acción nextInt 00:22:16
Next int significa, oye, quédate ahí esperando a que alguien meta un número entero en el teclado 00:22:20
y cuando lo metan, cógelo. 00:22:27
Vale, pues eso es lo que hace esto, cógelo. 00:22:31
¿Y ahí ese cógelo dónde? 00:22:34
Hay que asignarlo a una variable, si no lo pierdo. 00:22:36
Yo podría ejecutar esto. 00:22:38
¿Y qué haría esta sentencia? 00:22:41
Esta sentencia significa exactamente lo siguiente. 00:22:44
Oye tú, Java, programa. Oye tú, programa. Quédate ahí cruzado de brazos, parado, atascado. Espera a que yo escriba un número en el teclado. Cuando yo lo escriba, cógelo y déjatelo ahí guardadito. Pero como no le he dicho nada más, lo ha tirado a la basura. Vamos a ejecutarlo. A ver qué pasa. 00:22:46
yo ejecuto esto 00:23:11
y efectivamente 00:23:13
mirad mi consola 00:23:17
mi consola no pone terminado 00:23:19
el programa no ha terminado 00:23:22
el programa tiene el cursor ahí 00:23:24
este está cruzado de brazos hasta el infinito 00:23:25
el programa se ha quedado aquí parado 00:23:27
porque esta sentencia 00:23:29
significa, oye 00:23:31
quédate ahí parado esperando 00:23:33
y no vamos a la siguiente sentencia 00:23:35
por mucho que aquí haya cosas 00:23:38
Por ejemplo, vamos a saludar aquí 00:23:39
Voy a terminar este con cualquier cosa 00:23:46
Voy a ejecutarlo de nuevo 00:23:50
¡Hala! Ahí está para esperando 00:23:52
Está parado en esta sentencia, ahí atascado 00:23:59
Como veis, la siguiente, que es la de mostrar a Dios 00:24:01
No la ha ejecutado, ¿por qué? Porque está aquí parado 00:24:05
Ahí está, y de ahí no va a salir nunca jamás 00:24:09
hasta que no tecleemos algo 00:24:11
vale, pues vamos a teclearle el numerito 00:24:13
que está esperando, lo que sea 00:24:16
numerito y enter, para que se entere que he terminado 00:24:17
claro, enter 00:24:20
ala, ya sale a la siguiente 00:24:21
¿y qué ha pasado con ese número? 00:24:24
lo ha cogido 00:24:27
pero como no le hemos dicho que hacer con él 00:24:28
se ha perdido 00:24:30
claro, es que yo 00:24:31
tengo que asignar ese valor 00:24:34
a alguna variable 00:24:36
por ejemplo, si me da la gana edad 00:24:37
ahora ya sí 00:24:40
tu edad es 00:24:45
más edad 00:24:53
ahora ya sí 00:24:55
el programa se quedará ahí parado 00:25:01
y ahí se podría estar hasta siempre jamás 00:25:02
nunca va a salir de ahí 00:25:05
hasta que no tecleemos algo en el teclado y demos a enter 00:25:06
cuando ya lo hayamos hecho 00:25:09
lo coge, uy que bien 00:25:11
tengo a quien asignárselo 00:25:13
menos mal, pues no lo tiro a la basura 00:25:15
lo asigna a esta variable 00:25:17
a partir de aquí edad tiene eso 00:25:19
y ahora ya el programa 00:25:21
ya puede seguir, ya puede seguir 00:25:24
porque ya hemos introducido el dato 00:25:25
ya puede seguir, vale 00:25:28
entonces 00:25:29
ahora ya ejecutamos esto, ya está esperando 00:25:31
hasta el infinito, introduce 00:25:34
tu edad 00:25:36
vale, y ya está 00:25:36
lo normal es que antes de una 00:25:38
sentencia que pide datos 00:25:51
pongamos un mensaje 00:25:52
para que el programa sea un poco más amigable 00:25:54
porque si no, se queda el cursor esperando 00:25:57
y el usuario no sabe que tiene que hacer 00:25:59
lo normal es siempre 00:26:01
acompañarlo de un mensaje 00:26:03
delante 00:26:04
vale 00:26:05
lo acompañamos de un mensajito delante 00:26:08
para que el usuario sepa 00:26:10
porque ese cursor se ha quedado ahí atascado 00:26:13
entonces se muestra el mensaje 00:26:15
y luego ya si, esta se queda ahí atascada 00:26:17
esperando 00:26:19
esta aplicación ya es un poquito más amigable 00:26:19
introduce tu edad y ahí estoy esperando 00:26:23
y de ahí no me muevo hasta que no pongas 00:26:24
tu edad y desalentes 00:26:26
Y así podríamos meter tantos como quisiéramos 00:26:28
Por ejemplo, ahora quiero que meta el peso 00:26:37
Pues reutilizo ese objeto todas las veces que quiera 00:26:40
Lo reutilizo todas las veces que quiera 00:26:44
Introduce tu peso 00:26:47
Pues lo vuelvo a reutilizar 00:26:50
Ahora el peso, inPeso, declaro la variable 00:26:56
int peso, pues 00:26:59
scan.next 00:27:01
int 00:27:04
vale, pues ahora 00:27:04
de nuevo, se quedará ahí atascado esperando 00:27:07
se quedará atascado 00:27:09
cuando yo le meta un número 00:27:10
lo cogerá y 00:27:13
le he dicho que lo lleve a algún sitio, menos mal 00:27:15
porque si no ese número se va a la basura 00:27:17
a la variable peso que declaro en ese 00:27:19
momento, pero no la tengo de antes 00:27:21
por ejemplo, y ahora ya 00:27:23
pues 00:27:26
Es decir, puedo reutilizar ese objeto para leer diferentes cosas 00:27:26
Todas las veces que a mí me dé la gana 00:27:37
¿Vale? 00:27:40
Introduce tu edad, bla, bla, bla 00:27:46
Introduce tu peso, bla, bla, bla 00:27:48
¿Vale? Y así todas las veces que yo quiera 00:27:51
Cuidado porque los objetos 00:27:53
Lógicamente tienen todo un sistema de excepciones 00:28:02
Que de nuevo no conocemos 00:28:07
Pero ya conoceremos 00:28:08
Entonces, si yo le he dicho next int, que es una de las cosas que puede hacer, que puede hacer muchas, int viene de entero. Le estoy diciendo, quédate esperando un número entero. Como se me ocurra meter algo que no sea un entero, se va a quejar y como forma de protesta, el programa se va a terminar. Se acabó, terminado. 00:28:10
vale, vamos a probar 00:28:36
introduce tu edad 00:28:38
como yo le he dicho next int 00:28:40
él está esperando un número entero 00:28:42
porque int viene de entero 00:28:45
que meto algo que no es un entero como esto 00:28:48
se me queja y me dice 00:28:50
esto no es un número entero 00:28:54
y qué forma de quejar se tiene 00:28:56
parando el programa 00:28:59
se acabó, el programa se terminó 00:29:01
terminado 00:29:03
pasa y ya no ejecuta nada más de lo que hay 00:29:04
después, programa terminado y ya no ejecuta 00:29:07
más, vale 00:29:09
si quisiéramos evitar esto, teníamos que 00:29:10
hacer un tema de captura de excepciones, etcétera 00:29:13
que todavía no sabemos 00:29:15
ahora mismo quedémonos con que si yo pido 00:29:15
un entero, mete un entero, porque si no el programa 00:29:19
se te para, ya está, no hay otra 00:29:21
vale 00:29:23
que en lugar de un entero quiero meter 00:29:24
un double 00:29:29
pues con next int no puedo, es que next int 00:29:30
me pide un entero, entonces yo no 00:29:33
puedo decirle 00:29:35
oye, introduce tu edad, pues 00:29:36
mi edad es 45,8 00:29:39
no, porque 45.8 00:29:41
no es un entero 00:29:45
se queja también y para 00:29:46
pero jo, yo quiero hacer un programa que sea un entero 00:29:48
por ejemplo, mi peso 00:29:51
yo lo quiero dar con decimales 00:29:53
no quiero el peso redondeado, el peso 00:29:55
lo quiero con decimales 00:29:57
pues entonces 00:29:58
no uso el método nextInt 00:30:00
uso el que se llama 00:30:03
next double 00:30:06
¿vale? 00:30:06
next int cuando yo vaya a meter un número entero 00:30:12
pero cuando yo vaya a meter un número 00:30:15
con decimales, no uso next int 00:30:17
uso next double 00:30:19
y entonces el ya 00:30:20
si le metes una coma 00:30:23
ya no se vuelve loco 00:30:24
dice, vale, me gusta 00:30:27
es una coma, me gusta, es un decimal 00:30:28
vamos a probarlo 00:30:30
introduce tu edad 00:30:33
la que sea 00:30:35
introduce tu peso 00:30:36
lo único es que para el next table 00:30:37
te trata como muy humano 00:30:40
él asume que tú no sabes que para Java 00:30:42
las comas son puntos 00:30:45
entonces él espera que se lo pongas con una comita 00:30:46
que es como lo escribimos 00:30:49
los humanos en un papel 00:30:51
entonces yo quiero decirle que mi peso 00:30:52
es 67,5 00:30:54
se lo pongo con coma 00:30:56
¿vale? 00:30:58
luego él cuando me he hecho el system out 00:31:00
me lo ha puesto lógicamente como él muestra 00:31:02
los decimales 00:31:04
entonces si yo no se lo pusiera con coma 00:31:05
sino que se lo pusiera con punto 00:31:07
se queja 00:31:09
porque introduce tu peso 00:31:11
punto 5 00:31:13
no le gusta 00:31:15
¿vale? 00:31:17
ese único matiz 00:31:18
que él asume que tú vas a usar la coma 00:31:20
de los humanos 00:31:23
y él ya luego lo traduce lógicamente 00:31:24
a su 00:31:29
notación, que siempre es con punto 00:31:30
el dabel. Vale, pues entonces sabemos leer números enteros, números decimales, podemos 00:31:33
leer todos los genos de la gana, uno tras otro, guardarlos en variables correspondientes, 00:31:39
operar con ellos, lo que sea. Vale, y con esto, pues bueno, para que se nos haga un 00:31:43
poco más llevadero, vamos a ver de la hoja de ejercicios que podáis hacer algunos. Vamos 00:31:48
Materias:
Programación
Niveles educativos:
▼ Mostrar / ocultar niveles
  • Formación Profesional
    • Ciclo formativo de grado básico
      • Primer Curso
      • Segundo Curso
    • Ciclo formativo de grado medio
      • Primer Curso
      • Segundo Curso
    • Ciclo formativo de grado superior
      • Primer Curso
      • Segundo Curso
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
1
Fecha:
24 de septiembre de 2026 - 13:51
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
31′ 59″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
123.98 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid