Saltar navegación

20251006 ProgEstr-EjerTernario_3 - 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 6 de octubre de 2025 por Raquel G.

1 visualizaciones

Más información Transcripción

Descargar la transcripción

Vale, pues ahora ya sí, vamos a abrir nuestro eclipse, para no aburrirnos tanto. 00:00:00
Vamos a hacer unas pruebitas chorras con variables, así que da igual. 00:00:11
Son nada, 4, 5, 6 líneas chorras para experimentar un poquito con variables, nada más. 00:00:16
Bueno, pues que... Ah, que no he compartido aquí nada. A ver... 00:00:28
Vale 00:00:35
Vale, pues a nadie 00:00:39
Se le olvida que todo esto 00:00:45
Pues porque sí 00:00:47
Y aquí entre estas llaves correctamente colocadas 00:00:48
Está lo que es 00:00:51
Nuestro bloque de código 00:00:53
¿Vale? 00:00:55
Que para nosotros ahora mismo es nuestro programa 00:00:57
No va a haber más programa que lo que no haya ahí dentro 00:00:59
Y ahí dentro habrá 00:01:01
Una línea una tras otra 00:01:03
Con las sentencias que pongamos 00:01:04
Bueno, pues sacar algo por consola 00:01:07
ya sabemos. Pues ya está. Vale, pues resulta que mi programa necesito yo una variable numérica 00:01:10
para guardar una edad. Pues ya está. Selecciono el tipo de dato, número entero. Normalmente 00:01:23
seleccionaré siempre edad, int y cojo el nombrecito y punto y coma y ya está. Y automáticamente 00:01:33
Te apareció en la memoria RAM una variable edad. 00:01:44
Que no tiene nada, que está indefinida. 00:01:49
Vale, mi System.out.println, aparte de para mostrar texto, 00:01:53
también vale para que yo muestre contenidos de variables. 00:01:58
Me vale para mostrar cualquier cosa. 00:02:02
Pues, vamos a intentar mostrar el contenido de esta variable. 00:02:07
Entonces, un, vale. 00:02:11
¿Qué pongo yo aquí si quiero mostrar el contenido de una variable? 00:02:18
Pues pongo su nombre, el nombre de la variable. 00:02:25
Pongo el nombre de la variable. 00:02:28
Yo quiero mostrar el contenido de la variable edad. 00:02:31
Pues pongo el nombre de la variable edad. 00:02:34
Entonces, el system out de arriba y el de abajo son distintos 00:02:38
porque el de arriba, al estar entrecomillado, 00:02:42
yo le estoy diciendo, oye, muéstrame 00:02:45
literalmente ese texto, ese texto 00:02:48
tal cual, pero lo de 00:02:50
abajo como no está entrecomillado 00:02:52
entonces me 00:02:54
refiero a un nombre de variable 00:02:56
claro, si yo le pongo 00:02:58
esto, ahora es 00:03:00
distinto, ahora no tiene nada que ver 00:03:02
ahora le estoy diciendo, oye 00:03:04
muéstrame directamente 00:03:06
el texto edad 00:03:08
si yo 00:03:12
ejecuto este código 00:03:14
esto funciona perfectamente 00:03:15
vale, si yo ejecuto este código 00:03:21
me muestra el primer texto 00:03:33
y el segundo texto que yo 00:03:35
le he puesto, edad, porque le he dicho 00:03:37
oye, muéstrame literalmente el texto 00:03:39
edad, pero no es lo que yo 00:03:41
quiero hacer ahora 00:03:43
lo que yo quiero hacer ahora es mostrar el 00:03:44
contenido de la variable 00:03:47
que se llame edad 00:03:49
pues entonces para decirle a java 00:03:50
oye tú 00:03:53
quiero el contenido de esa variable 00:03:54
pues entonces le doy 00:03:57
el nombre de la variable 00:03:59
¿vale? ¿qué ocurre? 00:04:00
que aún así me ha salido 00:04:07
un error de compilación 00:04:08
veréis que se os ha 00:04:09
puesto aquí rojito 00:04:12
¿por qué se ha puesto 00:04:13
rojito? porque 00:04:16
claro, porque el 00:04:18
compilador que está compilando 00:04:20
sobre la marcha ha visto que hay un error. 00:04:22
¿Vale? ¿Ese error cuál es? Ya lo podemos 00:04:24
intuir, pero si uno 00:04:26
quiere ver qué información 00:04:27
le da el compilador, pone 00:04:30
el cursor 00:04:32
apoyado en la 00:04:34
cosita roja, que sale a la izquierda, 00:04:36
pone el cursor apoyado ahí 00:04:39
y te sale el mensaje que te da el compilador. 00:04:40
Y el compilador 00:04:43
te dice, perdóname, 00:04:44
pero la variabilidad me da 00:04:46
que no tiene ningún valor. 00:04:48
Justo es lo que está pasando. 00:04:51
Yo he creado el espacio en memoria, edad, pero dentro está indefinido, con lo cual, si yo le digo muéstrame lo que contiene edad, me dice, es que edad no tiene nada, claro, porque antes de usar una variable, antes de acceder al contenido de una variable, para mostrarla, para lo que sea, tengo que darle un valor, ¿vale? 00:04:52
Entonces, mi variable edad, ¿vale? 00:05:16
Voy a ir introduciendo ya comentarios. 00:05:21
Los comentarios ya más o menos sabéis lo que son. 00:05:23
Comentarios es texto que uno pone en el programa, 00:05:26
pero que no es para ejecutarse ni es para nada. 00:05:30
Es una ayuda para el programador. 00:05:33
Son los comentarios en el código. 00:05:35
Yo comento mi código poniendo, explicando cosas. 00:05:38
Pero lo explico para mí, me lo explico a mí. 00:05:42
o se lo explico al que lo lea 00:05:44
pero en la máquina virtual 00:05:47
los comentarios no los ve obviamente 00:05:49
para ella no existen 00:05:51
los comentarios son explicaciones 00:05:52
que puedo dejar ahí en el código colocaditos 00:05:55
porque son muy útiles 00:05:57
para cuando lo vuelva a mirar enterarme 00:05:58
vale, entonces todas las explicaciones 00:06:00
que pueda poner en un código 00:06:02
todos los comentarios mejor 00:06:04
cuando lo vuelva a abrir me acordaré 00:06:05
de por qué narices hice yo eso 00:06:07
bueno, pues entonces voy a poner aquí un comentario 00:06:09
que en Java hay varias maneras 00:06:11
pero la más sencilla es estas dos barras un comentario declaró la variable edad pero se 00:06:14
queda como se queda sin valor se ha quedado sin ningún valor luego antes de mostrar edad tengo 00:06:24
que darle un valor si no le doy un valor con toda la razón del mundo si no le doy un valor 00:06:39
con toda la razón del mundo 00:06:55
el compilador se queja 00:06:58
y no te deja ejecutar nada, se queja 00:06:59
porque mientras haya errores de compilación 00:07:02
pues no ejecutes 00:07:05
vale 00:07:06
¿cómo arreglo esto? 00:07:08
vamos a darle un valor 00:07:10
vale, darle un valor 00:07:11
a una variable, meter un valor 00:07:16
en la cajita, en el espacio en round 00:07:18
darle un valor, se llama 00:07:20
asignar un valor 00:07:22
vale, sería 00:07:24
y se haría mediante una sentencia de asignación. 00:07:26
Vamos a ponerlo aquí, ¿vale? 00:07:31
Para dar un valor a una variable, ¿qué hacemos? 00:07:36
Usamos la sentencia de asignación, 00:07:44
que como su propio nombre indica, 00:07:51
sirve para asignar un valor a una variable. 00:07:55
La sentencia de asignación, que no la hemos usado todavía, 00:07:58
sentencia de asignación 00:08:02
la sentencia de asignación 00:08:04
sirve para dar valor a una variable 00:08:09
vale, ¿cómo es? 00:08:11
¿cómo se usa 00:08:15
la sentencia de asignación? 00:08:16
se usa 00:08:19
como todo en Java 00:08:20
con unas reglas muy estrictas 00:08:21
exclusivamente lo vamos a hacer ahora 00:08:23
y solo así 00:08:26
la sentencia de asignación siempre es 00:08:27
la voy a poner primero 00:08:31
en comentarios y luego la escribimos 00:08:32
A la izquierda, nombre de la variable, el que sea, nombre de la variable a la que yo quiero asignar un valor. 00:08:34
Luego pongo el igual, luego pongo el valor que quiero darle y termino con un punto y coma. 00:08:48
¿Vale? Así es la sentencia de asignación y siempre es así. 00:08:57
izquierda 00:09:03
un nombre de variable 00:09:06
una cajita, un nombre de variable 00:09:08
igual 00:09:10
y a la derecha 00:09:12
el valor que yo quiera 00:09:16
el que me dé la gana 00:09:17
terminado en punto y coma 00:09:19
esa es la sentencia 00:09:22
de asignación 00:09:24
y por eso al operador igual 00:09:25
se le llama el operador de 00:09:27
asignación 00:09:30
ese es el operador igual 00:09:31
El operador de asignación. 00:09:37
Bueno, pues vamos a asignar un primer valor a mi variable edad. 00:09:47
Pues edad igual el valor. 00:09:52
Pero claro, el valor tiene que ser del tipo para el que yo he declarado la variable. 00:09:57
Tiene que ser de ese tipo. 00:10:04
Si no es de ese tipo, el compilador se va a quejar otra vez. 00:10:05
Si yo pongo 45, maravilloso. 00:10:11
Porque 45 es un número entero. 00:10:15
No se queja. 00:10:18
Termino con punto y coma. 00:10:20
Y ahora ya el errorcito que me daba aquí se quitó. 00:10:22
Porque ahora ya edad tiene un valor. 00:10:26
¿Vale? 00:10:30
Que pongo menos 45. 00:10:31
También. 00:10:35
¿Vale? 00:10:36
No se queja el compilador. 00:10:37
No se queja porque menos 45 es un número entero válido. 00:10:39
Cualquier cosa que sea un número entero, maravilloso. 00:10:43
porque edad está como entera 00:10:46
y los números enteros 00:10:47
¿cómo los escribimos en Java? 00:10:50
pues como los escribimos sobre el papel 00:10:52
las cifras que sean y un menos delante 00:10:53
y el negativo, ya está, no hay ninguna duda 00:10:56
sobre cómo escribir un número entero 00:10:58
la cifra que sea 00:10:59
con los dígitos que sean, menos el negativo 00:11:01
y ya está 00:11:04
yo le doy un número entero tal y como lo escribo 00:11:05
yo sobre el papel 00:11:08
y Java ya lo entiende, lo asigna 00:11:09
y se acabó, dime 00:11:11
¿cómo lo ponemos en el primer instante? 00:11:13
no, porque eso no es un número entero 00:11:15
y aparte para ponerlo 00:11:17
tendría que poder ponerlo 00:11:20
y en logaritmo neperiano de 5 no hay un operador 00:11:22
para hacer logaritmo neperiano 00:11:24
tendría que llamar a un objeto 00:11:25
que sea capaz de hacerlo 00:11:27
porque solamente se pueden hacer 00:11:28
sin utilizar objetos adicionales 00:11:31
las operaciones aritméticas básicas 00:11:33
como revisar el número 00:11:35
entonces 00:11:37
¿qué pasa si yo 00:11:38
pretendo poner 00:11:42
45.9 00:11:42
claro, 45.9 00:11:45
sería la forma 00:11:50
en la que ponemos en Java los decimales 00:11:51
en lugar de una copita ponemos un punto 00:11:53
bueno, pues Java entiende 00:11:55
45.9 o menos 12.7 00:12:00
como números decimales 00:12:03
y me dice 00:12:05
no, no, no, error de compilación 00:12:06
no te dejo 00:12:09
entonces efectivamente nos restringe 00:12:10
un montón la libertad, a mi me encantaría una variable 00:12:12
en la que le pueda poner 00:12:14
a un entero, a un decimal, 00:12:17
lo que me dé la gana. Maravilloso, 00:12:19
eso hace Python. Vale, me meto lo que 00:12:21
quiera. Los códigos 00:12:23
me salen señores de compilación a la primera. 00:12:25
Ojo con las ejecuciones. 00:12:28
Aquí, 00:12:30
desde el principio, tienes que ser tan 00:12:31
cuidadoso, 00:12:33
porque como cometas errores, 00:12:35
como no está todo bien diseñado, bien pensado, 00:12:37
el compilador no te deja 00:12:40
seguir. Gracias a eso, 00:12:41
el programa cuando ya está hecho y se ejecuta 00:12:43
es más robusto. 00:12:45
Pues 45.9 no podemos 00:12:46
porque no es un tipo compatible. 00:12:49
¿Vale? 00:12:51
Pero 00:12:53
45 sí. 00:12:53
Y de hecho, si ahora ejecutamos 00:12:57
este programa, 00:12:59
pues ahora 00:13:01
efectivamente 00:13:02
me ha mostrado 00:13:04
el contenido de la variable. 00:13:07
¿Vale? 00:13:09
45. 00:13:10
¿Hasta dónde? 00:13:13
Vale 00:13:27
Aquí ahora ya hay 00:13:28
Pues pequeñas 00:13:34
Cositas de manejo 00:13:37
De números enteros 00:13:39
Vamos, pues bueno, para entretenernos 00:13:40
Algunas 00:13:42
En edad, cabe hasta donde cabe 00:13:43
Si aquí va aumentando la esperanza de vida 00:13:47
Aumentando la esperanza de vida 00:13:50
Pues vale 00:13:52
Uy, llega un momento en que ya 00:13:54
Este número 00:13:55
Me cabe en un int 00:13:59
si hacemos las operaciones 00:14:01
matemáticas entre 00:14:03
menos 2 a la 31 00:14:05
este cabe 00:14:07
pero como sigo aumentando la esperanza de vida 00:14:09
y yo pretendo 00:14:11
en edades así 00:14:13
como veis, este ya el compilador 00:14:14
dice 00:14:18
nanay, ¿por qué? 00:14:19
porque este número no cabe en 32 bits 00:14:21
luego te dice 00:14:23
no puede seguir 00:14:25
si tú quieres usar una edad así de 00:14:26
grandota, tendrás que 00:14:29
declararte una variable long 00:14:31
porque esto no cabe 00:14:33
en 32 bits 00:14:34
¿vale? por curiosidad 00:14:36
para que veamos cuál es el margen 00:14:44
de enteros 00:14:46
vamos a ver aquí 00:14:47
menor número 00:14:53
almacenable 00:14:55
en int 00:14:58
vale, aunque ahora no entendamos muy bien 00:14:59
por qué 00:15:08
esta cosita de aquí, esta variable 00:15:09
que ya está hecha 00:15:12
esto, porque 00:15:13
Java, como todos los 00:15:18
lenguajes, tiene 00:15:20
algunas variables 00:15:22
que están en un contexto 00:15:23
de este integer. Olvidaos, 00:15:27
como si no hubiera dicho nada. Esto es 00:15:29
solo, lo he puesto 00:15:32
solo, porque os digo 00:15:34
y os tenéis que creer, porque ahí no podemos entenderlo, 00:15:36
que esto 00:15:38
tiene el menor valor entero posible. 00:15:39
Lo he puesto solo para que veamos por curiosidad 00:15:42
cuál es. 00:15:44
Sí, voy a poner también el máximo, 00:15:46
que es el max value. 00:15:49
Sí, esto es 00:15:58
solo para que lo veamos por curiosidad. 00:15:59
Mayor número almacenable 00:16:02
en int. Vale. 00:16:03
Entonces, si yo hago este system.out.println, 00:16:07
esto 00:16:11
es una variable, 00:16:11
hemos creado nosotros, pero creámoslo, 00:16:13
es una variable, está por ahí, ya entenderemos 00:16:15
por qué está por ahí, por qué puede acceder a ella, 00:16:17
ya lo entenderemos, que guarda 00:16:19
el menor número posible almacenable 00:16:21
Y esta es una variable que está por ahí, ya veremos por qué la podemos usar sin haberla creado nosotros, que guarda el mayor número almacenable en int. 00:16:23
Vamos a ejecutar esto a ver qué contenido tiene esto y qué contenido tiene esto para ver cuáles son estos dos valores. 00:16:30
Pues este es el menor número posible almacenable en int y este es el mayor número posible almacenable en int. 00:16:40
Según el complemento a dos 00:16:50
Si necesitamos programas 00:16:52
Que trabajen con números enteros 00:16:58
Más grandotes que estos 00:17:01
Tenemos que usarlo 00:17:02
¿Vale? 00:17:04
Porque long ya sí que 00:17:07
Son un montón más 00:17:11
Vamos a ponerlos por curiosidad 00:17:13
Voy a copiar y pegar esto 00:17:14
Mayor número almacenable en long 00:17:19
Acto de fe 00:17:27
que hacéis 00:17:31
para creeros que en esa variable 00:17:33
que está ahí se guarda el menor número 00:17:36
almacenable en long. 00:17:38
Mayor número almacenable en long. 00:17:40
De nuevo, acto de fe 00:17:42
que hacéis 00:17:44
para creeros que en esta variable extraña 00:17:45
que no sabemos de dónde ha salido, 00:17:48
se guarda el mayor 00:17:49
número almacenable en long. 00:17:52
Vamos a ejecutarlo solo para 00:17:54
conocer esos datos, solo para eso. 00:17:56
Pues hombre, muy gordo. 00:18:01
Es muy grandote. 00:18:05
Eso sí, si alguien intenta almacenar 00:18:07
un número mayor que ese, 00:18:09
tiene ya 00:18:11
que hacer su propio código 00:18:12
que desmonte el número, 00:18:15
lo guarde en diferentes partes, etc. 00:18:17
¿Por qué no? 00:18:20
En una variable primitiva tal cual, 00:18:21
en una variable long, 00:18:23
ese es el mayor número entero que se puede guardar. 00:18:25
Digamos que tenemos una cantidad de datos. 00:18:26
Si tú tienes un... 00:18:30
No, una cosa es una cantidad de datos enorme 00:18:31
y otra cosa es el mayor valor posible. 00:18:34
de cada número 00:18:36
de cada número long 00:18:37
que tú guardes, el mayor valor posible 00:18:39
que puede alcanzar ese número es este 00:18:42
pero realmente hay alguna 00:18:44
situación en la que tú 00:18:46
tengas una cantidad 00:18:48
de cosas que gestionar 00:18:49
de ordenadores, de alumnos 00:18:52
que sea más grande que esta 00:18:54
es difícil 00:18:56
pero bueno, tendrá sus propios 00:18:57
lenguajes de programación con sus propias cosas 00:19:00
la NASA no programajaba 00:19:02
eso seguro 00:19:04
pues estrellarían todos los cohetes 00:19:07
tendrán su fron 00:19:09
un punto y coma mal puesto 00:19:11
y ya se estrelló 00:19:13
bueno, un punto y coma no llegaría 00:19:14
a ejecutarse el programa, pero el tema no es ese 00:19:17
no es por problemas 00:19:19
de Java, sino es por la lentitud 00:19:21
de la máquina virtual, hasta que el programa 00:19:23
arranca, pues la 00:19:25
nave ya se ha salido de la atmósfera 00:19:27
y ya le da igual que le den la trayectoria 00:19:29
porque ya se ha salido 00:19:31
Es por la lentitud del código el problema 00:19:32
La lentitud de la ejecución 00:19:35
Vale, pues resulta 00:19:37
Que aún así 00:19:41
Nosotros queremos 00:19:42
Un número más grandote que este 00:19:44
Este es el más grande almacenable 00:19:46
En int, ¿verdad? 00:19:49
Pues entonces 00:19:51
Vamos a darle a nuestra variable edad 00:19:52
Este número 00:19:54
Y este lo coge 00:19:57
Este lo coge 00:20:00
Pero como yo me salté al 8 00:20:02
como ya me saltea el 8 ese ya no le gusta 00:20:04
porque ese ya se ha salido 00:20:08
de lo máximo almacenable 00:20:09
que pasa si yo 00:20:11
quiero guardar este numerito 00:20:15
necesito una variable 00:20:17
long 00:20:20
no hay tu tía, una variable long 00:20:20
este numerito 00:20:23
ya lo puedo 00:20:29
guardar en 00:20:31
una variable long 00:20:33
vale 00:20:35
este no, sigue saliendo 00:20:37
rojo, ahora os explico por qué, ¿vale? 00:20:41
Entonces, ahora 00:20:44
os lo digo, pero está claro, ¿no? 00:20:45
Aquí ya con el 8 ya no puedo. 00:20:47
Este ya sí 00:20:50
que me cabe en long, sí que me cabe 00:20:51
en long, pero 00:20:53
cosita, 00:20:54
la máquina virtual 00:20:57
¿cómo funciona? Porque luego el funcionamiento 00:20:58
de la máquina virtual tiene sus cositas. 00:21:01
La máquina virtual 00:21:04
lo primero que hace es 00:21:05
coge 00:21:06
Este identificador 00:21:11
Crea el espacio en memoria 00:21:14
Bueno, en este caso era de 32 00:21:16
Que lo creo de antes, en este de 64 00:21:17
Y ahí lo deja esperando 00:21:19
Bueno, a ver, perdón, os he liado 00:21:21
He asignado la vez que he declarado 00:21:24
Que esto se puede hacer 00:21:25
Pero vamos por partes 00:21:27
Para no liaros 00:21:30
Declaro longe edad tocha 00:21:31
Y ahora ya sí, a edad tocha 00:21:33
Le asigno el valor 00:21:35
Que era este, para hacerlo igual que antes 00:21:37
y no complicar la vida al que se líe. 00:21:39
Vale. 00:21:45
A edad tocha le doy el 8. 00:21:47
Y ahora me diréis, pero Jolines, que no puede ser. 00:21:49
Que esto cabe en long. 00:21:52
Que hemos visto antes los posibles valores de long 00:21:53
y ese cabe. 00:21:57
¿Por qué me sale en rojo? 00:21:59
Bueno, por una chorradita que se arregla rápido, 00:22:01
pero os voy a explicar por qué. 00:22:02
Bueno, la máquina virtual, ¿qué hace? 00:22:04
Ha cogido esta. 00:22:06
Primero ha declarado la variable. 00:22:07
Fenomenal. 00:22:08
ha creado un espacio de 64 bits 00:22:09
en RAM muy grande 00:22:11
le ha puesto el nombrecito 00:22:12
edadtoche y se acabó 00:22:14
vale, siguiente sentencia 00:22:16
dice 00:22:19
aquí tenemos una asignación 00:22:20
maravilloso, una asignación 00:22:22
él se pone ya en chip de asignación 00:22:24
en ese chip que hace la máquina virtual 00:22:27
mira a ver 00:22:29
lo que hay aquí 00:22:30
si eso es una lista de cifras 00:22:31
normal y corriente, sin puntos 00:22:35
y sin nada, una lista 00:22:36
de cifras normales y corrientes 00:22:38
3, 5, 8 o menos 4, 3, 2 00:22:40
pues él 00:22:43
interpreta que tú le quieres dar 00:22:44
un número entero 00:22:46
interpreta que le quieres dar un índice 00:22:48
entonces lo construye 00:22:50
en 32 bits 00:22:52
pero claro 00:22:53
él está intentando construir esto 00:22:57
en 32 bits 00:23:00
y no puede 00:23:01
entonces cuando le damos un numerito 00:23:02
que queremos que lo construya 00:23:06
en 64, porque luego 00:23:08
se lo vamos a pasar a una variable 00:23:11
compatible, que la asignación ya 00:23:13
viene después, primero lo construye 00:23:15
y luego ya decide a quién se lo mete 00:23:16
pues hay que decirle 00:23:18
oye, construyemelo 00:23:21
en 64 bits 00:23:23
y eso se lo decimos poniendo 00:23:24
una L al final 00:23:27
¿vale? 00:23:29
entonces, lo ponemos 00:23:32
aquí abajo, la L 00:23:35
del final 00:23:39
es para que la 00:23:40
máquina virtual de Java 00:23:44
construya 00:23:46
ese número 00:23:52
con 64 bits 00:23:53
no con 32 00:23:56
ve la L y dice 00:23:58
ah, que lo vas a guardar en un long 00:24:00
tus intenciones con este número 00:24:03
tus intenciones es llevarlo a un long 00:24:05
es tus intenciones 00:24:07
lo ve con la L, dice vale, muy bien 00:24:08
me voy a coger 64 bits 00:24:11
codifico y ya que lo tengo construido 00:24:13
ahora ya me voy a ver 00:24:15
a quién se lo quieres dar 00:24:17
a edad tocha 00:24:18
menos mal que edad tocha está declarada como long 00:24:19
porque después de que me lo has hecho construir en 64 00:24:22
me das una que no es long 00:24:25
y te vuelvo a decir que no 00:24:26
pero como edad tocha está como long 00:24:28
eso que ella ha construido en 64 bits 00:24:30
cabe aquí, lo asigna y ningún problema 00:24:32
un segundito 00:24:35
si yo aquí me hubiera 00:24:36
vuelto a equivocar 00:24:39
y hubiera vuelto un int 00:24:40
Me volvería a salir un error 00:24:42
Porque claro, él ve la L 00:24:48
Dice, ah, vale 00:24:51
Quieres construir un número 64 00:24:52
Construye el numerito en 64 bits 00:24:54
Ningún problema 00:24:57
Siguiente paso 00:24:58
A ver, ¿dónde quieres que meta este número que he construido en 64? 00:24:59
Porque tiene una L 00:25:03
¿Dónde quieres que lo meta? 00:25:04
Edad tocha, vale, voy a meterlo 00:25:05
Edad tocha 00:25:07
Uy, no me cabe 00:25:08
No me cabe porque lo he declarado como L 00:25:10
Pues eso es lo que te dice 00:25:12
¿Vale? 00:25:14
Dime 00:25:19
¿Por qué no es suficiente con declarar el valor? 00:25:20
¿Por qué hay que poner la E? 00:25:23
Porque la máquina virtual 00:25:25
Actúa en secuencia 00:25:28
O sea, una cosa es el compilador 00:25:29
Y otra cosa es la máquina virtual 00:25:30
Entonces, la máquina virtual 00:25:32
No mira antes la variable a la que va 00:25:34
Lo primero que hace es construirte el valor 00:25:37
Entonces, para construirte el valor 00:25:40
Tiene que tener ya la información 00:25:42
De si lo quiere construir en 64 o en 16 00:25:44
¿Vale? Entonces, como es lo primero 00:25:46
que hace, si tú quieres que lo construya 00:25:49
64, si tú quieres 00:25:50
que este número vaya a 64, que en este 00:25:52
caso tiene que ir por el 00:25:54
direccionar la L, es por la forma de funcionamiento de la máquina 00:25:56
virtual, ¿vale? No es que ya lo 00:25:59
mire en conjunto y diga, ah, vale 00:26:00
deduzco, lo expando 00:26:02
a 64 porque va a lo, podría 00:26:04
pero no, ¿vale? 00:26:06
Eso no significa 00:26:12
un segundito ya, eso no significa 00:26:13
que yo aquí, en la variable 00:26:15
log, tenga que ponerlo todo con L 00:26:17
No, yo puedo darle 78 00:26:19
¿Por qué? 00:26:22
¿Aquí qué ocurrirá? 00:26:27
Y ya terminamos 00:26:28
Después de las preguntas terminamos con esto 00:26:30
Aquí yo le he dado 78 00:26:31
Pero le he puesto la L 00:26:34
Pero ya sabemos que 00:26:36
En la máquina virtual lo primero que hace es 00:26:38
Que quieres construir un entero 00:26:40
78, ah muy bien 00:26:42
Como no está la L 00:26:44
Te lo construyo en 32 bits 00:26:46
Ningún problema porque cabe en 32 00:26:48
te lo construye 00:26:50
ahora ya dice, ya lo tengo construido en 32 bits 00:26:51
porque no está la L, 32 00:26:54
¿dónde quieres meterlo? 00:26:55
en edad tocha 00:26:57
edad tocha tiene espacio para 64 00:26:58
lo que yo he construido 00:27:02
cabe en 32 00:27:04
no pasa nada, 32 00:27:06
en 64 cabe 00:27:08
y lo asigna igualmente 00:27:09
¿vale? si lo hiciéramos al revés, no 00:27:11
si yo una variable int 00:27:15
como hemos hecho antes, le pasara un número de 64 00:27:17
Ya hemos visto que ha dado el error 00:27:20
Pero este sí 00:27:22
Porque 32 bits 00:27:24
Cabe en una variable de 64 00:27:27
¿Vale? 00:27:28
Preguntas 00:27:32
O sea que, por cierto, el sistema 00:27:33
Usa 32 bits 00:27:36
A ver, cuando 00:27:39
La máquina virtual ve que tiene que construir 00:27:40
Un valor numérico que tú se le has dado 00:27:42
Con una sucesión de cifras y más 00:27:44
Automáticamente 00:27:45
Él lo construye en 32 bits 00:27:48
Bueno, a ver, para que no se salga de aquí 00:27:51
Se ve más claro 00:28:07
Por claridad, no es que sea una línea gigante 00:28:08
No se ve 00:28:11
Hombre, a ver, claro 00:28:11
La norma es 00:28:16
Que sea lo más legible posible 00:28:18
entonces si hay diferentes líneas 00:28:20
va a salir mejor, que es una línea gigante 00:28:22
que tiene que llegar hasta el final 00:28:24
en general los comentarios 00:28:25
cuantos más haya 00:28:29
y más legibles sean mejor 00:28:30
¿vale? 00:28:32
pues subir un poco 00:28:34
subir es irse hacia 00:28:35
acá 00:28:41
vale, ¿más preguntas? 00:28:43
venga, pues nos vamos entonces 00:28:50
Voy a parar esto y miramos a ver qué te pasa. 00:28:54
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:
1
Fecha:
6 de octubre de 2025 - 18:51
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
28′ 59″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
105.30 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid