Saltar navegación

20240919 ProgrEstruct-Variables_5 - 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 19 de septiembre de 2024 por Raquel G.

9 visualizaciones

Más información Transcripción

Descargar la transcripción

Seguimos 00:00:00
Bueno, pues entonces 00:00:02
Esto ya no nos tiene que asustar 00:00:05
¿Vale? 00:00:08
Luego, conclusión grabadísima 00:00:10
Del funcionamiento de asignación de variables 00:00:12
Ahora mismo 00:00:14
Incluso a los que no habéis programado 00:00:15
Os puede parecer que lo que estamos diciendo es trivial 00:00:18
Pero hacedme caso 00:00:20
Luego, de nuevo generalizando 00:00:21
Hacéis unas burradas 00:00:23
Pero es que de escándalo 00:00:25
Y cuando pregunto 00:00:27
¿Pero tú te das cuenta de esto que has hecho? 00:00:28
¿Me dais unas explicaciones? 00:00:30
que todavía son más de escándalo 00:00:31
generalizando 00:00:34
generalizando 00:00:36
de verdad 00:00:38
que pasa muchísimo 00:00:39
y yo tengo dos opciones 00:00:41
o asesinaros que no puedo 00:00:43
porque no es legal 00:00:46
o desesperarme 00:00:47
que trato de evitarlo 00:00:49
o a costa 00:00:52
de que os parezca trivial 00:00:54
insistir una y otra vez para que se os queden 00:00:55
las ideas de base de concepto claras 00:00:58
¿Vale? Entonces, ahora, ¿qué tiene que quedar clarísimo? 00:01:00
Que en una asignación que solo tiene esta opción sintáctica, la máquina virtual, primero, coge este valor. 00:01:04
El valor puede ser un número suelto, estupendo, lo tiene muy fácil. 00:01:14
Pero puede no ser un número suelto, sino que puede ser el resultado de una expresión matemática o lógica. 00:01:19
lógica, ¿vale? En este caso yo he puesto un ejemplo de expresión aritmética, una suma, ¿vale? Pero las 00:01:25
expresiones pueden ser mucho más complicadas, entonces tendremos que, cuando veamos un poquito 00:01:33
ya más o menos cómo funcionan todos los tipos de variables, ya nos meteremos un poquito más en cómo 00:01:37
construir expresiones válidas, todos los operadores que tenemos, los lógicos, los aritméticos, etcétera. 00:01:44
pero quede desde ya la idea 00:01:50
de que lo que se pone a la derecha es un valor 00:01:53
y ese valor puede ser un valor que yo he metido tal cual 00:01:55
sea por teclado con la sentencia que ya veremos 00:01:58
o porque lo he metido tal cual, el 9 00:02:02
puede ser un valor tal cual o puede ser el resultado 00:02:04
de una expresión aritmética o lógica 00:02:07
bueno, pues la máquina virtual evaluará 00:02:10
esa expresión y cuando ya tenga el valor final 00:02:14
Y solo cuando tenga el valor final ya se va y dice, ¿en qué cajita la tengo que meter? En la cajita que se llama número 1. Estupendo, ahí meto el valor resultante de evaluar esta expresión, ¿vale? 00:02:17
y de nuevo 00:02:32
en esta expresión 00:02:35
la siguiente cosa que ya se nos tiene que quedar grabada 00:02:36
ya para siempre 00:02:38
es que en esta expresión puede haber 00:02:39
números tal cual que yo meto 00:02:42
o puede haber 00:02:44
también contenidos de otras 00:02:46
variables, puede haber también 00:02:49
contenidos de otras variables 00:02:50
entonces cuando yo quiera que haya contenidos de otras 00:02:51
variables, pues pondré el nombre 00:02:54
porque así me refiero yo al contenido 00:02:56
de una variable, con su nombre 00:02:58
y esta expresión 00:03:00
Puede ser hiper mega compleja 00:03:02
Y hacer mil cosas 00:03:05
Y mil historias 00:03:07
¿Vale? Con un montón de variables 00:03:08
Con las que haga falta 00:03:11
Número 2, número 3 00:03:12
Bueno, es que con número 3 era long 00:03:15
¿Vale? No, pero bueno 00:03:17
Con las variables que sea 00:03:19
Sí, ahora vamos por partes 00:03:20
Vamos por partes, ¿vale? 00:03:25
Esta primera parte de la asignatura 00:03:27
Es un poco más rollo 00:03:30
Porque claro, todo esto son 00:03:32
pequeños cositas 00:03:33
que hay que introducir, pequeños matices 00:03:35
que hay que introducir 00:03:37
que no podemos todos, es imposible 00:03:39
pero bueno, lo suficiente es para 00:03:41
sobrevivir 00:03:43
significa esto 00:03:44
que este número que va adelante 00:03:50
lo tiene que guardar la máquina 00:03:51
virtual en 64 bits 00:03:54
porque si no le pones la L 00:03:56
lo guarda en 32, problema 00:03:58
que no le cabe 00:03:59
¿vale? 00:04:00
vale 00:04:02
bueno, pues entonces 00:04:04
estábamos diciendo 00:04:06
que esta expresión que se pone a la derecha 00:04:08
puede involucrar tropecientas 00:04:10
variables y lo que haga falta 00:04:13
puede involucrar cualquier cosa, vale 00:04:14
vale, a ver 00:04:16
voy a modificar 00:04:22
tengo yo aquí esta expresión 00:04:25
puesta, por ejemplo, ya que he puesto esta 00:04:28
tan tonta y tan rara 00:04:29
la voy a dejar, vale 00:04:31
Tengo esta expresión 00:04:33
Silencio 00:04:35
Pierdo el hilo si habláis 00:04:38
Vale 00:04:42
Tengo esta expresión 00:04:44
Que involucra unas cuantas variables 00:04:46
No hay ningún problema, ya sabemos que una expresión 00:04:47
Puede involucrar toda la variable que yo quiera 00:04:50
Vale, pero voy a cambiar un poquito mi código 00:04:51
Y con el cambio que voy a hacer 00:04:54
Pues ya, claro, me vais a contestar 00:04:56
Todos, lógicamente 00:04:58
Voy a cambiar aquí mi código 00:04:59
No quiero asignarle nada a número 00:05:02
la he declarado, está aquí declarada 00:05:04
y de repente 00:05:07
ha aparecido aquí un error de compilación 00:05:09
¿vale? 00:05:11
ahora, sin necesidad de que yo 00:05:13
ponga en la manita para que me diga 00:05:15
el error de compilación de Java C 00:05:17
me diríais 00:05:18
¿y por qué de repente esto 00:05:21
se me ha puesto en rojo y esto no compila? 00:05:22
la línea 00:05:26
es la misma que estaba antes 00:05:27
yo no la he modificado 00:05:29
y esto es sintácticamente 00:05:30
válido, todas estas variables 00:05:33
existen, están declaradas 00:05:35
los operadores son válidos, eso lo digo 00:05:37
desde ya, pues el más, la división 00:05:39
el menos, son operadores aritméticos que siempre 00:05:41
se pueden usar y de repente ha aparecido 00:05:43
ese error de compilación 00:05:45
vale 00:05:46
pues ¿por qué ha aparecido? 00:05:48
claro, porque 00:05:51
importante 00:05:53
si ponéis aquí la manita 00:05:54
lo dice número, no tiene ningún valor 00:05:57
vale, pues importante 00:05:59
cuando tenemos aquí 00:06:01
una expresión que involucra variables 00:06:03
que hace la máquina virtual. 00:06:05
Ya lo hemos dicho. Se pone a hacer los cálculos. 00:06:07
Evalúa esa expresión para obtener 00:06:09
el valor. Se pone a hacer cálculos. 00:06:11
Entonces, con los números tal cual 00:06:13
no tiene problemas. 00:06:15
Y con las variables que hace, se va a la cajita 00:06:17
a recoger lo que tenga. 00:06:19
Si en la cajita no hay nada, 00:06:21
pues no hay nada que vamos a hacer. 00:06:24
Pues nos quedamos con las ganas. 00:06:25
Y entonces, dice, 00:06:26
lo siento, no puedo evaluar esa expresión. 00:06:29
No puedo. 00:06:32
¿Vale? ¿Está el error en esta línea? No, el error no está en esta línea, el error está en otra parte del programa. Entonces, los errores de compilación no están normalmente en la línea donde salen, están en otra parte del programa que ha provocado que esa línea no pueda compilar correctamente. 00:06:33
Bueno, en este caso nos lo decía bien la derecha 00:06:51
Número no está inicializado 00:06:54
Vale, pues no pasa nada 00:06:55
Venga 00:06:57
Ah, es que me he equivocado y yo quería número darle 7 00:06:58
Ya está 00:07:02
En cuanto ya le doy un valor a número 00:07:03
Ya está 00:07:06
Estupendo, vale, compila 00:07:08
Bueno 00:07:09
Seguimos 00:07:11
Lo que me estabais diciendo 00:07:14
Estamos todavía 00:07:17
Con uso de variables enteras 00:07:19
en Java y cuestiones relacionadas 00:07:22
con la asignación de valores 00:07:24
de números enteros a variables, estamos todavía con eso 00:07:25
variables enteros 00:07:28
seguimos, justo en relación a lo que 00:07:29
decíais antes, jolín 00:07:32
son intercambiables, si yo tengo una variable 00:07:33
entera, le puedo asignar una variable 00:07:35
¿cómo puedo hacer eso? 00:07:37
¿hay alguna regla? ¿hay algún no sé qué? 00:07:40
bueno, pues ahí la natural 00:07:42
la que no se le ocurriría, porque al fin y al cabo 00:07:44
un lenguaje de programación está 00:07:46
para hacer cosas de la vida real 00:07:47
no está para otra cosa 00:07:50
todo lo que nos afecta a nosotros 00:07:51
todo está en el mundo real 00:07:53
entonces cualquier cosa 00:07:56
de la que la tecnología se ocupa 00:07:57
está obviamente 00:07:59
directamente relacionada con solucionar 00:08:01
problemas de la vida real 00:08:03
¿por qué quiero decir esto? 00:08:04
que entonces el diseño de herramientas 00:08:06
tecnológicas está hecho desde una perspectiva 00:08:09
de humanos 00:08:11
vale, pues es una 00:08:12
Ismael y Daniel también 00:08:14
sí 00:08:19
seguro que has hablado 00:08:20
bueno, pues tu voz la he oído 00:08:22
estará en la cabeza 00:08:24
en algún momento has hablado 00:08:25
bueno, entonces 00:08:28
desde una perspectiva, silencio 00:08:30
desde una perspectiva de humanos 00:08:32
tiene sentido que en una caja 00:08:34
así, me quepa una caja pequeña 00:08:37
y yo no tengo ningún problema 00:08:39
luego, desde una perspectiva 00:08:41
de humanos, en una variable 00:08:42
declarada como long, porque no voy a poder 00:08:44
meter un número entero 00:08:46
cabe perfectamente, entonces eso 00:08:48
que es algo que no es un problema 00:08:50
en la vida real y a la que estamos 00:08:52
habituados, pues se refleja 00:08:54
en el lenguaje de programación, se tiene que 00:08:56
reflejar, si no, el lenguaje de programación va por 00:08:58
libre y la humanidad por otro lado 00:09:00
y eso no tiene ningún sentido, vale 00:09:02
pero en la vida real, en una caja pequeña 00:09:04
nunca meteríamos una caja grande porque tenemos 00:09:06
un problema, o rompemos la caja 00:09:08
grande o no hay manera 00:09:10
pues efectivamente 00:09:12
eso se refleja en el lenguaje de programación 00:09:14
en una variable I yo no 00:09:16
meto un número long, ¿por qué? 00:09:17
porque le tendré que quitar una parte 00:09:20
¿vale? pues eso mismo se refleja 00:09:21
aquí, entonces, ¿en qué se traduce? 00:09:24
si yo tengo una variable 00:09:28
long como era 00:09:29
número 3, ¿vale? 00:09:30
en número 3 00:09:35
yo le puedo asignar 00:09:37
el numerito 7 sin ningún problema 00:09:39
y no tengo que poner la L 00:09:41
ni nada, ¿vale? 00:09:43
no hace falta 00:09:48
es decir, yo he dicho 00:09:48
que si no pongo la L 00:09:51
la máquina virtual guarda ese 00:09:53
7 en 32 bits, vale 00:09:55
pero es que 32 bits 00:09:58
caben en 64 00:09:59
entonces no hay ningún problema, y no solo eso 00:10:00
si yo le asigno una variable 00:10:04
que se entera como num 00:10:05
num es entera, la tengo aquí arriba 00:10:07
entonces 00:10:09
la máquina virtual coge el 00:10:11
valor de num que cabe en 32 00:10:13
bits y lo guarda 00:10:15
en número 3 que es una caja más grande, estupendo 00:10:17
un numerito que cabe 00:10:20
en esta caja, lo he guardado 00:10:21
en una caja en la que me sobra la mitad 00:10:24
del espacio, pero no hay ningún problema, me sobra 00:10:26
la mitad del espacio, pues ya está 00:10:28
entonces, número 3, se habrá quedado 00:10:29
con lo que tenía Num 00:10:32
sea lo que fuera, pero ya ha extendido 00:10:33
a 64, ya ha extendido a 64 00:10:36
bueno, esto es 00:10:38
lo que se llama 00:10:40
promoción automática 00:10:40
para que os suene 00:10:43
de estudiar por ahí 00:10:45
o de los vídeos que veáis 00:10:49
o de las cosas que hagáis para estudiar, ¿vale? 00:10:51
la promoción automática es 00:10:53
yo tengo una asignación cualquiera 00:10:56
y los tipos no son compatibles 00:10:58
eso ya es 00:11:00
una situación rara, porque yo hasta ahora 00:11:02
he dicho, dije ayer 00:11:04
que en una sentencia de asignación 00:11:06
que lo escribimos en la pizarra, el valor 00:11:08
tiene que ser del mismo tipo 00:11:10
de la variable a la que lo asignas 00:11:12
eso es lo que dijimos 00:11:14
si yo tengo una variable char, le tengo que dar un valor char 00:11:15
si tengo una variable boolean 00:11:18
le tengo que dar un valor boolean 00:11:20
Si tengo una variable int, le tengo que dar un valor int. Bueno, pues eso, que es esa verdad universal, tiene sus pequeñitas excepciones. Vale, pues esas pequeñitas excepciones tienen que ver con la posibilidad de que la máquina virtual haga lo que se llama promoción automática, que a veces la hace porque tiene sentido y cuando no tiene sentido no la hace. 00:11:21
promociones, te cambio 00:11:44
el tipo de dato del valor porque 00:11:47
te lo tengo que cambiar porque 00:11:49
este valor no es de este tipo, pues 00:11:51
te lo cambio 00:11:53
¿Hace ese cambio siempre? No, repito 00:11:53
lo hace solo cuando tiene sentido 00:11:57
entonces aquí lo puede hacer 00:11:58
num es una variable int, muy bien 00:12:00
cojo su valor 00:12:03
ese valor lo promociono 00:12:04
lo extiendo con 00:12:07
16 ceros a la izquierda 00:12:09
lo extiendo con 16 ceros 00:12:11
a la izquierda, ya está en una caja enorme 00:12:13
en la que 16 ceros me están sobrando 00:12:15
no pasa nada, y ahora ya ese 00:12:17
valor extendido con 00:12:19
16 ceros lo guardo en esta caja grande 00:12:21
y se acabó, esa es la promoción 00:12:23
automática de int a long 00:12:25
y no pasa nada y el compilador la traga 00:12:26
y la podemos hacer de byte a short 00:12:29
de byte a int, es decir, de cualquier entero 00:12:31
pequeño a uno más grande 00:12:33
no hay ningún 00:12:35
problema, esa promoción automática 00:12:37
de enteros siempre se puede hacer 00:12:39
cuidado, significa eso que la variable 00:12:41
num haya cambiado el tipo 00:12:47
no tiene nada que ver 00:12:49
la cajita num 00:12:50
sigue siendo una cajita de 32 bits 00:12:52
yo lo que he hecho ha sido de esa caja 00:12:55
sacar el valor 00:12:57
y ese valor meterlo en la caja grande 00:12:58
rellenando con ceros 00:13:01
pero la cajita num 00:13:03
sigue teniendo sus 32 bits, no ha cambiado 00:13:05
de hecho si yo ahora 00:13:07
a num le intentara 00:13:09
dar un valor largote 00:13:11
pues es que no me dejaría 00:13:13
¿vale? me diría 00:13:17
oye, este es un número 00:13:19
long de 64 00:13:21
bits, aunque quepa en menos 00:13:24
al poner la L ya le estoy diciendo que lo guarde 00:13:25
en 64, me estás diciendo un número 00:13:27
de 64 bits, lo siento 00:13:29
esta caja es de 32, aquí no cabe 00:13:31
pues la promoción automática 00:13:33
inversa, o sea 00:13:36
la despromoción, esa no se puede 00:13:37
hacer, un segundín, porque esa sí que 00:13:39
implica perder información 00:13:41
entonces las conversiones en las que no se pierde 00:13:42
información, como poner ceros a la izquierda 00:13:45
de int a long, no hay problema 00:13:47
las hace automáticamente 00:13:49
esta, pero las despromociones 00:13:51
que yo tengo 64 bits 00:13:54
y lo tengo que meter 00:13:56
en caja de 32 00:13:57
no la puedo hacer, porque tengo que 00:13:58
cortar una parte 00:14:01
en este caso en particular, como esto 00:14:03
cabe en int, por casualidad 00:14:05
no pasaría nada 00:14:07
porque los 16 00:14:09
bits de la izquierda son ceros 00:14:11
pero eso el compilador no lo sabe 00:14:13
ni la máquina virtual, digo, yo solo sé 00:14:15
que me das un número que está en 00:14:17
64 bits, aunque sean todos ceros 00:14:19
y aquí un 1, me lo da 64 00:14:21
y quieres que lo meta en 32, lo siento 00:14:23
pero yo no voy a cortar 16 00:14:26
por mucho que sean ceros, me da lo mismo 00:14:27
porque a lo mejor ahora lo son, luego no lo son 00:14:29
puede cambiar el valor, ¿vale? 00:14:31
luego, de int a long 00:14:33
podemos, de long a int no 00:14:35
de byte a int podemos, de int a byte no 00:14:37
¿Vale? ¿Está claro, no? 00:14:40
Dime 00:14:42
Claro, no es una caja 00:14:42
No, no la meto en número 00:14:47
Meto su valor 00:14:48
Claro, a ver, esto 00:14:50
Espera, para no poner la pizarra que es un rollo 00:14:53
Vamos 00:14:55
Vale, a ver 00:14:56
Yo tengo aquí 00:15:00
Mi cajita 00:15:06
Y esta cajita 00:15:10
Es la que se llama 00:15:12
num, ¿vale? 00:15:14
vale, esta 00:15:27
cajita se llama num 00:15:28
¿vale? 00:15:31
esta cajita tiene un valor 00:15:33
por ejemplo el 7 00:15:34
vale, tiene el 7 00:15:36
y esta cajita 00:15:43
es una cajita que mide 00:15:46
no, no quería esto 00:15:48
ahí 00:15:55
esta no es para 00:15:59
hacer la que yo quiera 00:16:08
bueno da igual 00:16:11
esta cajita mide 00:16:13
32 bits 00:16:14
eso está claro 00:16:18
ahora yo tengo otra variable 00:16:19
tengo mi variable 00:16:21
long más larga 00:16:23
que esta variable ahora mide 00:16:25
64 es más grande 00:16:27
y esta variable 00:16:29
se llama 00:16:31
num2 por ejemplo 00:16:32
entonces que hago yo cuando estoy 00:16:37
haciendo esta asignación 00:16:40
num2 00:16:41
igual a num 00:16:45
¿qué hago cuando estoy haciendo la sentencia de abajo? 00:16:47
primero, recordad 00:16:51
lo que hace la máquina virtual, primero 00:16:52
se va a esa expresión 00:16:53
es lo primero que hace, se va ahí 00:16:55
¿no es esto para? 00:16:57
arriba a la izquierda 00:17:01
¿cómo arriba a la izquierda? 00:17:03
ahí, la izquierda y el lápiz, el lápiz 00:17:05
amarillo, ah, pero esto 00:17:07
claro, pero no tenía que seleccionar el lápiz antes 00:17:08
Ah, vale, que le estaba dando a esto directamente 00:17:11
Vale 00:17:13
Vale, pues ¿qué hago? 00:17:14
Claro, se me lo estaba quitando 00:17:17
Vale, ¿qué hago cuando yo hago 00:17:19
Esta 00:17:21
Expresión de aquí? 00:17:22
Recordad lo que hace la máquina virtual 00:17:25
Primero, evalúa eso 00:17:26
Evaluar eso es, como solo tiene el nombre 00:17:29
De una variable 00:17:33
Se va a su contenido, vale, se va al 7 00:17:34
Saca el 7 de ahí 00:17:37
y lo lleva aquí dentro 00:17:39
el 7 00:17:41
cabe en 64 bits 00:17:43
claro que cabe, pues me copia aquí 00:17:45
el 7 y ya está 00:17:47
pero esta cajita num 00:17:49
sigue siendo una cajita de 32 bits 00:17:51
claro, claro, claro, sigue estando en la caja 00:17:53
la variable no ha desaparecido 00:17:57
la variable no ha desaparecido, lo que pasa es que 00:17:58
yo he utilizado ese valor 00:18:01
para construir ahí una expresión 00:18:03
que en ese caso es una expresión muy sencilla, que es el valor 00:18:05
tal cual, pero podría ser num más 7 00:18:07
por ejemplo, he utilizado el valor 00:18:09
y lo puedo utilizar 7 líneas más abajo 00:18:11
a lo mejor 7 líneas 00:18:14
puedo utilizar otra vez num2 igual a 00:18:15
num más 7, la variable sigue ahí 00:18:17
con el valor que tuviera 00:18:19
yo la utilizo, no la puedes eliminar 00:18:20
yo la utilizo siempre que quiera 00:18:25
una vez que la he declarado, la caja está ahí 00:18:27
le cambio el valor cuando 00:18:29
quiera y utilizo 00:18:31
su valor en expresiones 00:18:33
como esta, siempre que quiera 00:18:35
y la variable no ha desaparecido 00:18:37
y en este caso ni siquiera ha cambiado de tamaño. 00:18:39
Yo he cogido su valor 7, lo he llevado aquí. 00:18:42
No hay problema porque cabe. 00:18:45
Pero la cajita num sigue estando como estaba. 00:18:47
Una variable, una vez que está declarada de un tipo, 00:18:50
sigue declarada de ese tipo. 00:18:52
No se puede cambiar. 00:18:54
No es como en Python ni como en algunos otros lenguajes 00:18:55
menos restrictivos, ¿vale? 00:18:58
Bueno. 00:19:01
Vale, pues hablábamos que la promoción se puede hacer 00:19:05
de tipos 00:19:07
de almacenamiento de un tamaño 00:19:09
a más superior, pero a la inversa no 00:19:11
la despromoción, o sea, esto no se puede hacer 00:19:13
porque esto es un long, no podría hacer 00:19:14
num igual a 00:19:17
número 3 00:19:18
¿vale? no podría hacerlo porque 00:19:20
número 3 es de tipo int, perdón 00:19:23
número 3 la he declarado de tipo long 00:19:25
aquí arriba, número 3 00:19:27
está de tipo long, entonces 00:19:29
no me deja el compilador directamente, no me 00:19:31
deja, yo le pongo 00:19:33
número 3 más 7 00:19:34
me dice, no puedo 00:19:36
claro, porque esta es de tipo long 00:19:37
número 3 00:19:43
el compilador dice, a ver, número 3 es un nombre 00:19:44
de variable, muy bien, que es lo primero que hago 00:19:47
me voy a buscar 00:19:49
donde está esa variable declarada 00:19:50
está aquí 00:19:53
uy, está declarada 00:19:55
como 64 00:19:57
entonces yo, cuando recoja su valor 00:19:58
de 64, cuando lo recoja 00:20:01
para hacer la suma 00:20:03
ese valor de 64 00:20:05
si luego lo quiero meter 00:20:07
en una cajita de 32 00:20:09
lo voy a tener que cortar 00:20:10
no puedo 00:20:11
entonces 00:20:13
en una expresión 00:20:15
en una expresión 00:20:18
cuyo resultado va a ir un int 00:20:20
en esa expresión no puede haber 00:20:22
variables que sean log 00:20:24
en ningún caso, no puede haber variables que sean log 00:20:26
¿vale? 00:20:28
esta no molesta, por ejemplo 00:20:33
Imaginaos que yo tengo esta expresión. 00:20:37
Número 1 era entero, ¿verdad? 00:20:39
Sí, vale. 00:20:41
Aquí tengo a la variable num, dale, 00:20:43
el resultado de coger el valor de número 3 00:20:48
y coger el valor de número 1. 00:20:52
Vale, esta no molesta, 00:20:54
porque el valor de número 1 está en 32, es así. 00:20:56
Pero ahora el compilador cuando coge este valor 00:20:59
y lo va a sumar con este, dice, 00:21:01
uy, este sí molesta, 00:21:02
porque número 3 está en una caja 00:21:04
de 64, entonces lo que yo coja ahí 00:21:06
lo voy a tener que cortar 00:21:09
para luego guardarlo en 00:21:10
num, entonces este es 00:21:13
el que molesta, el error de compilación viene 00:21:14
de aquí, ¿vale? 00:21:16
Cuando la suma de los dos números que aunque sean 00:21:18
no caben en un int 00:21:20
en ese caso no te lo 00:21:22
transforma a un num 00:21:24
No, no, no, claro 00:21:26
Pero me quiero decir 00:21:28
num está declarado 00:21:29
num está como int 00:21:31
y pongamos que número 3 y número 1 también son 00:21:32
pero la suma de los dos 00:21:35
es un 00:21:38
ah, te da un número muy grande 00:21:39
desborda, a ver 00:21:41
no te da un error, pero desborda 00:21:43
claro, no, no, no, eso sintácticamente 00:21:45
es válido, claro, imagínate 00:21:48
por ejemplo que yo tengo esto 00:21:50
vale, entonces 00:21:51
número 1 es entero, número 1 es entero 00:21:53
está en 32 bits 00:21:56
luego el compilador, que lo único que hace es ver 00:21:57
que no haya incoherencias 00:22:00
que no hay incoherencias, le parece perfectamente válido 00:22:01
y esto compila, ahora que puede pasar 00:22:03
en tiempo de ejecución, en tiempo de ejecución 00:22:05
es otra cosa, imagínate 00:22:07
que en tiempo de ejecución hemos metido en número 1 00:22:09
el número entero más grande que se puede 00:22:11
no hay problema 00:22:14
cabe en int ese número, yo lo he metido 00:22:15
y ahora 00:22:17
al sumar número 1 más número 1 00:22:19
ese número 00:22:21
ya no cabe en 32 00:22:22
ya no cabe 00:22:25
¿vale? pues 00:22:26
ese número 00:22:28
necesitará un bit más 00:22:30
pero es que directamente te mete lo que quepa 00:22:32
en 32, o sea, ha desbordado 00:22:34
entonces el resultado no va a tener ningún 00:22:36
sentido, no va a tener sentido porque te va 00:22:38
a quitar los bits de la izquierda, no va a tener sentido 00:22:40
pero el programa ejecuta y no tiene ningún 00:22:42
problema, ¿vale? 00:22:44
no te das cuenta a simple vista 00:22:46
salvo cuando ves que la suma de tropecientos mil 00:22:48
a tropecientos mil te da uno 00:22:50
dices, uy, qué raro, claro, porque 00:22:51
me ha desbordado, se ha ido uno ahí 00:22:54
y claro, ¿vale? 00:22:55
entonces lo que ocurre es que si tú prevés 00:22:58
que tu aplicación va a tener 00:23:00
números tan próximos al límite 00:23:03
superior, pues ya lo declaras 00:23:05
como long directamente 00:23:07
pero sí, efectivamente 00:23:08
esa pregunta 00:23:11
está muy bien porque esa situación se da 00:23:12
y el compilador 00:23:14
le encaja todo, pero luego en la ejecución 00:23:16
te da un número 00:23:19
que no es correcto 00:23:20
para que se ponga en 64 bits hay que poner 00:23:22
L al final, cierto 00:23:24
entonces, si el número 00:23:25
del resultado es long 00:23:27
tú pones long, o sea, ¿cómo se 00:23:29
pondría la L al final? ¿o no es necesario? 00:23:31
hay que declarar long como long 00:23:33
a ver, es que 00:23:35
si está declarado como long 00:23:36
esta 00:23:40
vale, es que da igual, eso tampoco te lo 00:23:40
soluciona, porque lo primero que hace 00:23:43
esto es 00:23:45
no puedes 00:23:46
ese truco de poner la L al final, como dices tú 00:23:49
no puedes hacerlo aquí 00:23:51
en nombres de variables 00:23:53
entonces, como esto no se mira hasta el final 00:23:54
lo que hay en la máquina virtual 00:23:57
como esto es entero, te hace la suma 00:23:59
con esta, entero también 00:24:01
y te trunca 32 bits 00:24:02
y eso no tienes forma 00:24:05
de decir, extiéndelo 00:24:07
no tienes manera 00:24:08
y luego ya después, lo mete aquí 00:24:09
pero lo mete aquí cuando ya lo ha truncado 00:24:13
¿vale? no es que tengas la opción 00:24:14
que es lo que imagino tienes en mente 00:24:17
de ponerle aquí una L como para decir 00:24:18
guárdalo en 64, no puedes 00:24:20
entonces usted tendría que estar número uno declarado como long 00:24:23
claro, entonces 00:24:25
número uno tendría que estar como long 00:24:26
efectivamente, entonces claro 00:24:28
la declaración de variables, pues tú 00:24:30
si prevés que puedes trabajar 00:24:33
con números muy grandes, pues directamente long 00:24:35
porque de 32, 64 tampoco 00:24:36
te vas a quedar sin memoria 00:24:39
no importa que el num esté declarado como long 00:24:40
lo que importa es que el número uno esté declarado como long 00:24:42
en este caso 00:24:45
claro, en este caso 00:24:46
que el num esté declarado como long 00:24:48
no da ninguna ventaja, porque el truncado 00:24:50
se va a hacer antes, en la evaluación de la expresión. 00:24:52
Claro, aquí habría 00:24:55
que arreglarlo cambiando la declaración de número 1. 00:24:57
¿Vale? 00:24:59
Vale. Por 00:25:01
curiosidad, 00:25:02
vamos a ver cuáles son los mayores números 00:25:05
enteros y long que se 00:25:07
pueden, pues 00:25:08
tenemos 00:25:10
de nuevo, aunque ahora tampoco lo 00:25:11
entendemos muy bien, 00:25:14
hay una 00:25:18
recordad que 00:25:18
Os dije, pues ayer, que esto que aparece aquí, os dije simplemente que era la máquina virtual con la que se va a ejecutar la aplicación. 00:25:22
Ya está, os dije eso y se acabó, ¿vale? 00:25:34
La máquina virtual con la que se va a ejecutar. 00:25:36
Bueno, pues la máquina virtual con la que se va a ejecutar tiene un montón de clases de estas que yo puedo usar si quiero. 00:25:40
de hecho, nosotros 00:25:48
sin ser conscientes de ello 00:25:51
cuando hemos ejecutado 00:25:53
cuando hemos escrito esta sentencia 00:25:55
esa sentencia 00:25:57
está en realidad 00:25:59
llamando a un programa muy complejo 00:26:01
de mostrar por consola 00:26:03
y ese programa muy 00:26:05
complejo de mostrar por consola 00:26:07
pues no lo hemos hecho nosotros, ¿cómo es que 00:26:09
funciona? porque está 00:26:11
lo tiene metido ese programita 00:26:13
la máquina virtual, entonces 00:26:15
¿Qué quiero decir con esto? Que nuestras aplicaciones, que ahora mismo van a ser un ficherito sin más haciendo cosas, pueden también, si quieren, llamar a códigos que ya están hechos en otros programas dentro de la máquina virtual. Y eso lo estamos haciendo aquí, por ejemplo. 00:26:17
Pues igual que podemos llamar a programas que ya están hechos para hacer cosas como este, que es el de mostrar por consola, podemos llamar a, llamémosle variables que ya están hechas, que no las he hecho yo y puedo usar, que me dan información. 00:26:36
Entonces, ahora mismo vamos a ver, por curiosidad, unas variables que tienen un valor constante, que tienen guardada ya en la máquina virtual el máximo valor posible para que, por ejemplo, vamos a declarar una variable int máximo entero. 00:26:54
vale, pues 00:27:16
pues esto que yo he escrito aquí 00:27:21
que ahora mismo lo creéis tal cual, es solo para que tengamos 00:27:27
el dato, por curiosidad 00:27:29
esto es 00:27:30
un valor, esto es un valor 00:27:32
un número, un valor 00:27:35
que está guardada en esta variable tan rara 00:27:37
que se llama maxValue, con mayúscula 00:27:39
que está guardada en esta variable 00:27:41
y esta variable ya existe, ya está hecha 00:27:42
pero no en mi programa, sino en otro 00:27:45
que está en la máquina virtual 00:27:47
por eso podemos acceder a él cuando nos dé la gana 00:27:49
al igual que hemos podido acceder, repito 00:27:51
al system.println porque ya está 00:27:54
hecho en la máquina virtual 00:27:55
y yo lo puedo llamar, bueno pues 00:27:57
ahora mismo creámonos que esto 00:27:59
es una variable que se llama así 00:28:01
que ya existe, tiene este nombre tan raro 00:28:03
ya entenderemos lo del punto a que viene 00:28:06
que sean mayúsculas, etcétera 00:28:07
pues esta variable ya existe 00:28:09
y está declarada en algún 00:28:11
sitio, no en mi programa 00:28:13
en algún sitio, pero yo puedo 00:28:16
acceder a ella también, bueno vamos 00:28:17
a ver qué valor tiene. Y no solo 00:28:19
esta, sino que tengo muchas más. 00:28:21
Vamos a poner 00:28:25
por ejemplo, vale, 00:28:25
pues vamos a mostrar 00:28:36
el contenido. ¿Qué contienen 00:28:38
estas variables? Estas variables, ahí 00:28:40
en ese programa donde se han declarado, al que yo 00:28:42
no tengo acceso, que es un programa que está ahí, 00:28:44
no tengo acceso al código. 00:28:46
Uy, quería poner min. 00:28:49
Vale. 00:28:54
Pues estas dos variables 00:28:55
que ya están declaradas y tienen un valor 00:28:56
asignado en algún programa que no es mío, 00:28:58
Pero yo puedo llamar las esas variables siempre que quiera, 00:29:00
las puedo llamar para asignar un valor. 00:29:03
Las puedo llamar siempre que quiera. 00:29:05
Pues estas en particular, ¿qué contienen? 00:29:06
Pues contienen el máximo valor entero posible 00:29:09
que se puede codificar en 32 bits 00:29:12
y el mínimo valor entero posible 00:29:15
que se puede codificar en 32 bits. 00:29:16
Entonces, pues uno puede, 00:29:19
está bien que tengamos ese dato 00:29:21
para cuando uno haga sus programas 00:29:22
saber si va a usar números mayores que esos, 00:29:25
porque si los va a usar, pues entonces usa un long. 00:29:27
¿Vale? 00:29:29
Entonces 00:29:30
Si los mostramos 00:29:30
Para poner la variable más rápido 00:29:34
Pongo siso control espacio 00:29:42
Para poner esto dices 00:29:46
Lo que pasa es que no os lo 00:29:47
No os lo digo 00:29:50
Para que lo aprendáis de memoria 00:29:52
Pero cuando ya lo habéis aprendido de memoria 00:29:54
Es que de nuevo 00:29:56
Generalizando otra vez 00:29:57
Pero allá por febrero todavía hay gente que me pone 00:29:59
El system con la s en minúscula 00:30:02
Y no se da cuenta 00:30:03
Vale, voy a poner aquí 00:30:05
Antes una barrita separadora 00:30:12
Porque como tengo ya un montón de 00:30:14
System out por ahí, arriba 00:30:16
Vale, pues vamos a ver 00:30:18
Por curiosidad 00:30:20
Esos valores máximos 00:30:21
Y mínimos, ¿cuáles son? 00:30:24
Vale, pues este es el mayor valor 00:30:27
Entero que se puede almacenar 00:30:29
En 32 bits 00:30:31
Entonces si vais a usar números enteros más grandes que este 00:30:32
Long 00:30:35
O más pequeños que este 00:30:36
Long, ¿vale? 00:30:38
Y tenemos lo mismo con las variables long 00:30:40
Pero esto está guardado en una variable 00:30:45
Que no se llama así, sino que se llama long 00:30:51
Vale, pues estas cuatro variables 00:30:54
Que he puesto, que tienen estos nombres tan raros 00:31:27
Repito, son variables que están declaradas en algún sitio 00:31:29
Y yo tengo acceso a usarlas 00:31:33
Para verlas, para hacer con ellas operaciones, lo que sea 00:31:35
Y en particular el contenido de esas variables tiene ese significado. 00:31:38
Pues esto es el mayor número long que podemos codificar. 00:31:45
A ver, es muy grande, muchísimo. 00:31:54
Entonces, ¿qué aplicación necesita un dato tan más grande que esto? 00:32:00
¿Tú crees? 00:32:08
Hombre, sí, no creo. 00:32:09
Alguna aplicación 00:32:10
De contar estrellas 00:32:13
Pero esas no se harán en Java, seguro 00:32:15
¿Vale? 00:32:17
Bueno, ese es decimal 00:32:22
Claro, ese iría en otro lado 00:32:23
¿Vale? 00:32:25
Bueno, pues nada, que tengamos ese dato 00:32:27
Venga, pues nos vamos al recreo 00:32:29
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
9
Fecha:
19 de septiembre de 2024 - 17:01
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
32′ 35″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
109.59 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid