Saltar navegación

20250922-ProgEstr-Variables_4 - 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 22 de septiembre de 2025 por Raquel G.

5 visualizaciones

Más información Transcripción

Descargar la transcripción

bueno, pues 00:00:00
vale, pues todos o casi todos 00:00:03
recordáis lo que estábamos mirando 00:00:11
¿verdad? 00:00:12
pues ahora mismo antes de podernos 00:00:14
poner a hacer cosas 00:00:17
tenemos que tener lógicamente los conceptos básicos 00:00:18
y entre ellos 00:00:21
el fundamental era el concepto de variable 00:00:22
que ya todo el mundo 00:00:25
lo tiene claro, ¿verdad? 00:00:27
en el aula virtual 00:00:28
bueno, he subido 00:00:30
un pequeño documento un poco con 00:00:32
resumen de estas cositas de 00:00:34
programación estructurada, pero vamos 00:00:36
no hay ni que mirarlo 00:00:37
entonces el concepto 00:00:39
de variable, todo el mundo lo tiene 00:00:42
claro, un espacio en memoria RAM 00:00:44
donde se van a 00:00:46
guardar los datos con los que el programa 00:00:48
trabaja, el programa tiene que 00:00:50
trabajar con datos, esos datos tienen que estar 00:00:52
obligatoriamente en memoria RAM 00:00:54
y en 00:00:55
espacios de memoria RAM que se llaman variables 00:00:58
a nuestro programa Java, antes 00:01:00
de acceder a esos espacios hay que hacer una cosa 00:01:04
llamamos declararlos, que era poner el nombre 00:01:07
de la variable, el tipo de dato 00:01:10
que va a contener la variable, terminado en punto y coma 00:01:14
y en cuanto a la máquina virtual ya se pone a ejecutar un programa 00:01:17
en cuanto encuentra esta sentencia de declaración 00:01:20
que esto ya es una sentencia válida en Java 00:01:24
pues crea el espacio en memoria 00:01:26
este espacio en memoria RAM 00:01:28
¿de cuánto tamaño? 00:01:30
el que le dé la gana 00:01:32
no, porque nosotros estamos obligados 00:01:32
a especificar el tipo de dato 00:01:35
que va a contener esa variable 00:01:37
entonces estos tipos de datos 00:01:39
ya dijimos que eran 8 00:01:41
byte, short, int y long 00:01:43
para contener números enteros 00:01:56
¿vale? para contener números decimales 00:01:59
el float y el double 00:02:02
que todavía no hemos puesto 00:02:05
ningún ejemplito 00:02:06
vale 00:02:07
si no es números lo que queremos 00:02:09
sino texto 00:02:12
entendiendo por texto cualquiera 00:02:14
de los caracteres que están en esa 00:02:16
tabla ASCII 00:02:18
en esa tabla ASCII famosa que hemos abierto 00:02:19
alguna vez que identifica 00:02:24
todos los caracteres 00:02:26
que se pueden escribir en un fichero 00:02:28
de texto, todos los caracteres que pueden escribir, pues si queremos 00:02:30
para comunicarnos con un lenguaje natural, si queremos 00:02:34
alguno de esos caracteres, el tipo es el char 00:02:38
y luego ya teníamos este otro tipo, boolean 00:02:42
que describimos un poquito el sentido que tenía 00:02:46
aunque todavía sin ver ningún ejemplo 00:02:55
vale, hicimos ejemplos de esto 00:02:59
y estábamos con esto, ¿vale? 00:03:04
Ninguna duda de lo del otro día, ¿no? 00:03:08
Vale, pues este era el programita con el que estábamos el otro día, ¿verdad? 00:03:12
En el que vimos pequeños matices del trabajo con números enteros, ¿verdad? 00:03:31
Sobre todo aquí es importante entender la diferencia entre int y long. 00:03:37
Recordad que la diferencia es la cantidad de bits para su representación 00:03:42
Y por tanto la cantidad de números que caben 00:03:46
¿Vale? 00:03:50
Entonces si queremos almacenar un número en 64 bits 00:03:52
Ponemos la L después para que la máquina virtual diga 00:03:55
Ah, esto es un número en 64 bits 00:03:59
Vale 00:04:02
Si no poníamos la L 00:04:02
Recordad que la máquina virtual coge el numerito y dice 00:04:04
Por defecto asumo que lo quieres en 32 00:04:08
porque ese es su funcionamiento por defecto 00:04:11
en 32 este número tan grande no me cabe 00:04:13
por eso te lo ponía en rojo 00:04:16
no, no, oye, cuidado que yo lo quiero en 64 00:04:17
vale, pones la L y ya te lo hace en 64 00:04:21
ahora otro problema era la asignación 00:04:24
una vez que la máquina virtual ha construido el número 00:04:28
mediante la sentencia de asignación 00:04:30
que era esta, nombre de la variable a la izquierda 00:04:33
operador igual valor que yo le doy a la derecha 00:04:37
mediante la sentencia de asignación 00:04:41
ahora ya ese número construido 00:04:44
la máquina virtual lo asigna 00:04:47
aquí como este lo va a haber construido 00:04:49
en 64 bits 00:04:54
hay que guardarlo en una variable declarada de 64 bits 00:04:55
porque si no, no va a caber 00:05:00
por eso decíamos 00:05:01
y si yo intento guardar este numerito 00:05:04
en mi variable edad 00:05:07
pues el compilador 00:05:09
que es el vigilante 00:05:11
de errores 00:05:13
de sintaxis, errores 00:05:15
de incoherencias 00:05:17
es el vigilante de las incoherencias 00:05:18
el compilador no es el vigilante 00:05:21
de que nuestro programa haga lo que tiene que hacer 00:05:23
en absoluto 00:05:25
el programa hará lo que tiene que hacer 00:05:26
si nosotros hemos establecido correctamente el algoritmo 00:05:29
no nos hemos equivocado a la hora de hacer 00:05:33
algoritmo. El compilador 00:05:35
no es el vigilante de que el programa 00:05:37
haga lo que tenga que ejecutar. Ese es nuestro 00:05:39
problema. El compilador es el 00:05:41
vigilante de que eso tenga una coherencia 00:05:43
sintáctica 00:05:45
y semántica en el sentido de que si tú 00:05:46
me has dado una variable log, no me des un valor 00:05:49
long. Si me has dado una variable char, no me des 00:05:51
un valor float. 00:05:55
De que no te has equivocado poniendo 00:05:57
el nombre 00:05:59
de una variable. Es el 00:06:01
vigilante de la sintaxis 00:06:03
luego el programa una vez 00:06:05
que no tiene errores de coherencia 00:06:07
sintáctica ni semántica 00:06:09
ya se podrá ejecutar 00:06:10
y puede ocurrir que una vez ejecutándose 00:06:12
no hagan nada de lo que tienen que hacer 00:06:15
y además generen errores de ejecución 00:06:16
vale, pero es que es más problema de confinamiento 00:06:18
es problema nuestro, claro 00:06:20
cuando ve una secuencia de cifras 00:06:22
sin más 00:06:31
sabe que le toca construir un número 00:06:32
Vale, pues ese número lo construye en 32 bits 00:06:35
Ya, sí, tienes razón 00:06:38
Tienes razón 00:06:47
Tú te refieres, si pones esto 00:06:52
B igual a 9, por ejemplo 00:06:54
Vale 00:06:56
Tienes razón 00:06:57
Lo que pasa es que normalmente como trabajamos siempre en int 00:06:59
Entonces, él te va a construir el numerito 00:07:01
Luego a la hora de asignarlo 00:07:04
A la hora de asignarlo 00:07:06
Si ve que es 00:07:07
Byte 00:07:09
short o long 00:07:11
en ambos, en los tres casos 00:07:13
hace la adaptación 00:07:15
¿vale? entonces 00:07:17
en el caso de byte y short 00:07:19
hará la adaptación 00:07:21
si el numerito 00:07:23
cabe, si no, no 00:07:26
¿vale? si el numerito cabe, si no, no 00:07:27
así no la hace y te dice 00:07:30
lo siento no puedes porque este número 00:07:31
no cabe en byte ¿vale? 00:07:33
pero si le ponemos este 00:07:35
como este si cabe en byte, este te deja 00:07:37
¿vale? entonces 00:07:40
con el short igual 00:07:41
tú puedes declarar una variable 00:07:42
short, ¿vale? 00:07:45
este te cabe 00:07:51
pero este no, no, no, no 00:07:51
no, no, no, no 00:07:58
él ve el número 00:07:59
él asume 00:08:02
que por defecto es un número 00:08:03
entero, entonces lo construye 00:08:05
bueno, entonces ahora ya llega la asignación 00:08:08
entonces ahora ya hay varias 00:08:10
situaciones, varias casuísticas para él 00:08:12
entonces, una casuística 00:08:14
es, que identifique que es un int 00:08:16
no hay nada más que tocar 00:08:18
el espacio en memoria se queda de 32 bits 00:08:20
con ese numerito entero, se queda de 32 bits 00:08:22
ahora 00:08:24
que vea que es un byte, donde lo tiene que guardar 00:08:25
pues mira 00:08:28
pues lo aporta 00:08:29
porque si tú has llegado a la máquina virtual 00:08:31
es porque no tienes un error de compilación 00:08:34
o sea, me refiero 00:08:36
tú no podrías haber llegado nunca a la máquina virtual 00:08:37
con esto así 00:08:40
porque ya el compilador 00:08:41
te ha frenado antes 00:08:44
entonces a la máquina virtual 00:08:45
nunca habrías llegado asignando 00:08:47
a una variable byte esto 00:08:49
entonces si has llegado 00:08:51
a la máquina virtual, o dicho de otra manera 00:08:54
si has llegado a ejecutar este programa 00:08:56
es obligatoriamente 00:08:58
porque aquí hay un número 00:09:00
que cabe en byte 00:09:02
entonces si lo construye, como tiene que 00:09:02
guardarlo en byte, se pulen 00:09:06
los tres bytes más significativos 00:09:08
y no pasa nada porque se los haya pulido 00:09:09
porque es que no eran necesarios 00:09:11
para representar ese número 00:09:13
porque si no, no habrías llegado a poder ejecutarlo 00:09:15
solo puedes ejecutar un programa sin errores de ejecución 00:09:18
con el short 00:09:20
es igual, vale 00:09:21
tú solo vas a haber llegado a ejecutar 00:09:23
el programa si el numerito este 00:09:26
solo necesita 16 bits 00:09:27
entonces él lo construye 00:09:29
lo tengo que guardar en short, me pulo eso 00:09:31
y ya está, pero Fizz responde a tu pregunta 00:09:33
en memoria 00:09:35
esta variable va a ocupar 00:09:37
16 siempre por ser short 00:09:40
y esta variable va a ocupar 00:09:42
8, siempre, ¿vale? 00:09:44
Y la int va a ocupar 32 00:09:45
Siempre 00:09:47
Vale 00:09:49
Entonces, este problema, sobre todo 00:09:50
Ataña el compilador 00:09:53
Con los int y con los long 00:09:56
Y es eso, el compilador 00:09:57
Aquí es que 00:10:00
Al compilador ya sí que le sale ambigüedad 00:10:06
Y es, vamos a ver 00:10:08
Este numerito 00:10:09
Este numerito 00:10:10
Yo lo construyo por defecto como int 00:10:12
Y este numerito 00:10:16
no me va a caber en un int, entonces aquí el compilador 00:10:18
ya como él ya sabe que la máquina 00:10:21
virtual por defecto te construye 00:10:22
32, como 00:10:24
ya sabe que la máquina virtual te construye 00:10:26
32 por defecto, pues 00:10:28
él te dice, uy ese número, cuando la 00:10:30
máquina virtual te haga construirlo, es que no va a 00:10:32
poder, ya se está adelantando 00:10:34
y te está diciendo, cuando la 00:10:37
máquina virtual vaya a construir ese número 00:10:38
lo siento pero no va a poder, porque la máquina virtual 00:10:40
lo mete por defecto cuando ve una secuencia 00:10:42
de cifras en 32 00:10:44
entonces ya se adelanta lo que 00:10:45
te dice, no, lo siento, no te dejo 00:10:48
que tires con este programa porque la máquina 00:10:50
virtual no va a poder meter eso en 32 00:10:52
pero tú le dices al compilador 00:10:54
no, espérate, es que yo voy 00:10:56
a añadir esta indicación 00:10:58
voy a añadir esta indicación 00:11:00
entonces tú le dices, no, no, espérate 00:11:02
ya sé que la máquina virtual cuando ejecute esto 00:11:12
ya sé que al ver una secuencia 00:11:15
de cifras lo va a meter en 00:11:17
va a crear un espacio de 32 bits 00:11:18
para él, ya lo sé 00:11:21
y ya sé que, y entonces 00:11:22
le doy una pequeña indicación 00:11:24
a la máquina virtual, le digo 00:11:27
no, pero espérate, le indico 00:11:28
desde ya L mayúscula, minúscula es lo de menos 00:11:30
¿vale? con L mayúscula 00:11:33
está más claro porque 00:11:34
no se confunde con el 1 00:11:36
¿vale? por eso siempre usamos la L mayúscula 00:11:38
para que, aunque el carácter es distinto 00:11:40
y la máquina virtual y el copiador nunca se van a ejecutar 00:11:42
porque es un carácter así diferente 00:11:44
la L minúscula y el 1 00:11:46
a la vista sí puede generar confusión 00:11:48
Por eso usamos el L mayúsculo 00:11:50
Entonces tú ya desde tiempo de compilación 00:11:52
Antes de ejecutar ya dices 00:11:55
No, no, perdona, es que tengo una forma de avisar 00:11:56
Tengo una forma de avisar 00:11:58
Para que esto lo haga en 64 00:11:59
Dice, ah, vale, vale, que estás avisando 00:12:01
Que lo haga de partida en 64 00:12:04
Vale, entonces te dejo 00:12:06
Aquí no avisas de partida 00:12:07
Lo que he puesto yo antes 00:12:09
Que lo he borrado 00:12:11
Byte B igual a 9 00:12:13
O short 00:12:23
igual a 120 o lo que sea 00:12:27
aquí no tienes que avisar 00:12:30
de partida a la máquina virtual 00:12:32
que lo construya 00:12:34
en 8 bits o en 00:12:36
16, no hace falta, lo puede construir 00:12:38
en 32, porque luego 00:12:40
lo que se pula 00:12:42
para dejarlo en 8 o en 16 00:12:43
lo que se pula no valía para nada, porque no hacía 00:12:46
falta, no hacían falta 00:12:48
esos bits, entonces aquí no tienes que 00:12:50
avisar con antelación a la máquina virtual 00:12:52
no, no, que no es de 32 el espacio, cuidado 00:12:54
que va a ser de 8 al final 00:12:56
o cuidado que va a ser de 16 00:12:58
no hace falta, por eso el compilador te deja 00:12:59
que lo metas 00:13:02
sin avisar que esto va a acabar siendo 00:13:03
de 8 y esto va a acabar siendo de 16 00:13:06
no hace falta que tú avises 00:13:08
pero aquí sí 00:13:10
aquí sí 00:13:13
tienes que darle el aviso, no, espérate 00:13:17
es que ya sé que este número no cabe en 32 00:13:19
ya lo sé, entonces te aviso 00:13:21
desde ya, máquina virtual 00:13:23
que hagas un espacio de 64 00:13:25
y ahora ya viene la asignación 00:13:27
En estas asignaciones 00:13:29
Toca asignar a bytes 00:13:31
Se pulen los 3 bytes más significativos 00:13:33
En esta toca asignar a short 00:13:36
Se pulen los 2 bytes más significativos 00:13:37
No pasa nada porque se los pula 00:13:40
Si es que no era necesario 00:13:41
No tenía ni información 00:13:42
Porque estos números ya caben en 8 y 16 00:13:43
Aquí ya tiene el número de 64 00:13:46
Toca asignar 00:13:50
Aquí ya no hay más tutía 00:13:51
De asignar a long 00:13:54
No hay otra posibilidad 00:13:54
Porque este número está construido en 64 00:13:57
¿por qué le hemos dado el aviso a la máquina virtual 00:13:59
de que tiene que conseguir los 64? 00:14:01
bueno, pues bien, magnífico 00:14:03
el compilador de partida 00:14:05
ya te prohibiría otra cosa 00:14:07
ya te lo prohíbe de partida el compilador 00:14:09
te dice, es que esto en la máquina virtual 00:14:11
solo va a funcionar correctamente 00:14:13
si lo guardas en un alón 00:14:15
¿por qué? 00:14:17
porque podríamos decir, ah vale, no pasa nada 00:14:19
podríamos dejar compiladores abiertos 00:14:22
lenguajes de programación 00:14:26
Poco protegidos, por decirlo así 00:14:27
Espera 00:14:29
Como Python 00:14:30
Que lo deja que encaje todo 00:14:32
En tiempo de compilación 00:14:35
Entonces uno podría decir 00:14:37
A ver, edad es int, que la tengo aquí arriba 00:14:39
Edad la tengo aquí arriba 00:14:41
Declarada 00:14:43
Edad es int 00:14:44
Vale 00:14:46
Podría haber otra forma 00:14:49
De programar 00:14:53
Que es 00:14:54
Construido en 64 00:14:55
me estás diciendo que lo guarden in 00:14:57
no pasa nada, vale 00:14:59
me pulo los 4 bytes más significativos 00:15:01
y dejo los 4 bytes más pequeñitos 00:15:04
los 32, claro 00:15:06
me lo pulo y caben 32, pero he perdido 00:15:08
el número, lógicamente, porque he quitado 00:15:10
un montón de información, he perdido el número 00:15:12
si este número necesitaba 00:15:14
de los 00:15:16
8 bytes 00:15:17
necesitaba 00:15:19
¿dónde la he escrito? 00:15:21
aquí 00:15:26
si este número 00:15:27
necesitaba 00:15:37
estos son 64 bits, 8 bytes 00:15:38
este número ha necesitado 00:15:43
esto para codificarse, 5 00:15:45
estos 3 no los ha necesitado 00:15:47
todos ceros, ningún problema 00:15:49
entonces una alternativa 00:15:50
podría ser que este lenguaje 00:15:53
de programación funcionara 00:15:54
ya he construido el numerito en estos 5 bytes 00:15:56
me dices que lo guarde en edad 00:15:58
que es int, con lo cual es una 00:16:01
variable que solo tiene reservado 4 00:16:03
no pasa nada, lo guardo en 4 00:16:05
y esto lo tiro a la basura 00:16:07
vale, pero he destrozado el número 00:16:09
el número que he guardado aquí 00:16:11
ya no es este, es otro 00:16:13
entonces eso ya 00:16:15
desde tiempo de compilación de escritura 00:16:17
de código tiene que estar prohibido 00:16:19
lógicamente el cambio de información 00:16:21
vale 00:16:22
el lenguaje te pone muchas restricciones 00:16:24
pero precisamente 00:16:28
para evitar que en tiempo de ejecución 00:16:29
pasen cosas 00:16:31
que pueden generar errores 00:16:33
como que un numerito 00:16:35
pierda parte de su contenido 00:16:36
en el caso que hemos 00:16:39
puesto antes, el 9 00:16:41
el 9 de los 00:16:43
32 bits 00:16:45
solo necesita esto 00:16:46
para codificarse, el resto son ceros 00:16:48
con lo cual cuando 00:16:51
la máquina virtual tenga que guardar esto 00:16:53
en byte, tira esto a la basura, no pasa nada 00:16:55
que lo tire, si ahí no había nada más que 00:16:57
ceros, el 120 00:16:59
o bueno, el 120 o el 230 00:17:00
solo necesita 00:17:03
estos bytes, el resto 00:17:05
serán todos ceros 00:17:07
cuando la máquina virtual lo guarde en short 00:17:08
dirá, esto fuera, la basura 00:17:11
pero no pasa nada, porque el número no se ve 00:17:13
modificado porque lo que ha perdido son los ceros 00:17:15
¿vale? pero en este 00:17:17
caso, en este caso 00:17:19
el compilador te dice, ojo 00:17:21
que si le dejáramos a la máquina 00:17:23
virtual hacer eso 00:17:25
estarías perdiendo información 00:17:26
Pues el compilador te pone reglas 00:17:29
Te pone reglas 00:17:31
Para que las respetes desde el momento de escribir el código 00:17:32
Si no cumples con esas reglas 00:17:35
No puedes ejecutar 00:17:39
¿Vale? 00:17:40
Bueno, pues una de esas reglas es esta 00:17:42
Ahora, vale, pues sí, efectivamente 00:17:44
En id no puedo, pero aquí sí 00:17:47
En esta sí, porque esta es long 00:17:49
Y fenomenal 00:17:51
Vale 00:17:53
Y lo otro que habíamos dicho 00:17:56
Tú no puedes asignar 00:17:59
un número long a una 00:18:02
¿dónde está esto? 00:18:04
no puedes asignar un número long 00:18:08
a una variable int 00:18:10
eso lo acabamos de volver a ejemplificar 00:18:11
¿por qué? no puedes 00:18:15
pero esto 00:18:16
esto sí puedes 00:18:18
esto es 00:18:23
a una variable declarada 00:18:25
como long 00:18:27
y por tanto 00:18:28
con un espacio reservado 00:18:30
de 64 bits 00:18:33
y edad tocha está declarada 00:18:36
como long, con lo cual 00:18:39
el espacio que ha reservado la máquina virtual 00:18:41
que reservará la máquina 00:18:43
virtual para 64, a este 00:18:45
sí que puedes darle 00:18:47
cualquier cosa que esté construida 00:18:49
en menos espacio. En 32 00:18:51
como este, porque al ser 00:18:53
una sucesión de cifras, la máquina 00:18:55
virtual lo habrá guardado en 32 bits. 00:18:57
En el momento de construirlo, 00:19:00
en el momento de construirlo, luego otra cosa 00:19:02
es asignarlo, lo construye 00:19:03
en 32 bits, bueno pues esto 00:19:05
es una asignación en la que 00:19:08
un valor de tipo entero 00:19:10
en 32 bits, se lo asignas 00:19:12
a uno long 00:19:14
y como veis el compilador te dice, aquí no tengo problema 00:19:15
no tengo problema, aunque 00:19:18
los tipos no son el mismo 00:19:20
un int va a un long 00:19:21
aunque el tipo no es el mismo 00:19:24
la regla 00:19:25
del lenguaje te dice, es que no pasa nada 00:19:27
porque lo único que voy a tener que hacer yo va a ser 00:19:30
meter aquí el numerito, el 78 00:19:31
y el resto 00:19:34
lo completo con ceros 00:19:35
ya está, lo completo con ceros 00:19:38
y ya lo tengo 64 00:19:40
¿que tú lo quieres en una variable de 64? 00:19:41
no pasa nada 00:19:44
porque 32 cabe en 64 00:19:45
¿vale? 00:19:49
y esto es lo que se llama 00:19:50
está en el documento 00:19:51
ese que os he subido para que tengáis 00:19:54
estos primeros conceptos más o menos organizados 00:19:56
promoción automática 00:19:58
de variables 00:20:00
Promoción automática 00:20:01
No digo variables porque aquí no se promociona ninguna variable 00:20:06
La variable sigue igual 00:20:09
Dime 00:20:09
Es un programa que tiene que asignarle un valor 00:20:10
Más a la de, digamos 00:20:13
A poner un valor 00:20:15
Por ejemplo 00:20:19
Si ponemos un valor 00:20:21
Que sea un long, por ejemplo 00:20:23
Lo que asigna más memoria, digamos 00:20:25
No puedes 00:20:27
Tú a un int no puedes asignarle un valor que sea un long 00:20:28
No, perdón, a un long 00:20:31
Sí, a un long sí porque cabe 00:20:32
Esto 00:20:35
Sí, claro 00:20:36
Estás usando el doble 00:20:41
De memoria RAM 00:20:43
Cuando necesitarías solo la mitad 00:20:45
Pero bueno, a lo mejor es que 00:20:47
En otros momentos a esta variable 00:20:49
Sí que vas a necesitar asignar números mayores 00:20:51
Como los datos son variables 00:20:53
Claro, esta variable no va a tener 00:20:54
Contenido siempre 68, a lo mejor dentro de no sé cuánto 00:20:56
Pues contiene 200.000 millones 00:20:59
Ya, pero tú reservas espacio 00:21:01
en función de las expectativas 00:21:10
de hasta dónde puedes llegar 00:21:13
entonces tú, una aplicación 00:21:14
que maneja usuarios 00:21:17
a lo mejor una variable es para 00:21:18
contabilizar el número de usuarios 00:21:20
tú en cada ejecución no sabes 00:21:22
qué va a tener de partida, pero te dice 00:21:24
el que ha hecho el análisis del sistema, el analista 00:21:26
te dice, yo he estudiado el problema, la situación 00:21:28
Me he entrevistado con los que me han pedido esta aplicación 00:21:30
Y me han dicho que podría haber 00:21:32
Hasta 200.000 millones de usuarios 00:21:34
Podría, a lo mejor no los hay 00:21:37
Pero podría 00:21:38
Entonces tú reservas un log 00:21:39
Para que el programa no falle 00:21:41
En caso de que en alguna ejecución en concreto 00:21:42
Ese número tenga que tener 00:21:45
¿Vale? 00:21:47
Tú reservas el tipo de atón función 00:21:47
De lo que prevés que puede llegar a ocurrir 00:21:49
Porque cada ejecución es distinta 00:21:52
Cada ejecución trabaja con datos distintos 00:21:55
¿Vale? 00:21:56
¿me vas a preguntar algo? 00:21:58
si, y si fuese en vez de 00:22:00
200.000 usuarios 00:22:02
o sea que no cabe en long 00:22:03
si no cabe en long 00:22:07
pues lo que no quepa en long 00:22:09
ya lo tienes que manejar tú por programa 00:22:11
pues dividiéndolo en dos variables 00:22:12
ya tendrás que tú ver 00:22:15
cómo gestionarlo 00:22:17
o sea que long es el máximo que lleva 00:22:17
el mayor número 00:22:20
que se puede almacenar en una variable 00:22:22
única es el mayor valor de long 00:22:25
el que nos salía ayer en el otro día, ¿vale? 00:22:27
Entonces, ya que hemos mencionado esta de la promoción automática, 00:22:31
pues podemos enunciar el principio básico de las asignaciones, ¿vale? 00:22:37
Es decir, ahora ya que sabemos una variable 00:22:44
y sabemos lo que es la sentencia de asignación, 00:22:48
que es a nombre de variable vamos a darle un valor concreto, 00:22:51
a través de este operador 00:22:55
que es el operador de asignación 00:22:58
bueno, pues 00:22:59
en general es de cajón 00:23:01
porque para eso el lenguaje te obliga 00:23:04
a especificar los tipos 00:23:05
que el valor que tú des 00:23:06
sea del mismo tipo que la variable 00:23:09
declarada, ese sería el principio 00:23:12
básico, ¿vale? 00:23:14
Sí, ¿vale? 00:23:21
Entonces el compilador 00:23:34
a la hora de poner 00:23:36
sus reglas y fijar sus reglas 00:23:39
cuando vea una sentencia 00:23:41
de asignación, por supuesto 00:23:43
lo primero, el compilador 00:23:45
que es el que pone las reglas, también no estamos ejecutando nada 00:23:47
el compilador empieza 00:23:49
a seguir, a ver, vamos a ver si esta persona 00:23:51
ha cumplido todas sus obligaciones 00:23:52
para que esta sentencia de asignación 00:23:55
yo la dé por correcta 00:23:57
y no la marque en rojito como 00:23:59
error de compilación 00:24:01
pues primero, mirará 00:24:02
lo que hay a la izquierda que será 00:24:05
el identificador de la variable 00:24:07
el nombre de la variable 00:24:09
¿Qué es lo que hará? Se pondrá a buscar en el código, antes de esa sentencia irá hacia arriba, a ver dónde está esa variable declarada, porque si esa variable no está declarada, dice, ¿y esta variable quién es? No existe, ¿cómo voy a dar yo un valor a algo que no existe? 00:24:10
entonces el compilador, primera regla que mira 00:24:29
bueno, por supuesto 00:24:32
que esto esté correctamente 00:24:34
nombre de variable 00:24:35
igual valor terminado en punto y coma 00:24:37
o sea que esa sintaxis básica se cumple 00:24:39
ahora ya se va a mirar 00:24:42
lo que pone en concreto 00:24:44
a ver, ¿existe 00:24:45
alguna variable con este nombre? 00:24:48
porque si no existe ninguna variable con ese 00:24:50
nombre, ¿cómo voy a dar yo un valor a algo 00:24:52
a una cajita que no existe? 00:24:54
¿cómo voy a meter algo en una caja que no tengo? 00:24:56
no me puedes dar algo para tener una caja que no tengo 00:24:58
entonces el compilador se pone a mirar 00:25:00
para arriba, pa pa pa pa pa pa, a ver si existe 00:25:02
si no existiera, ahí ya la hemos cagado 00:25:04
por ejemplo 00:25:07
imaginaos que esta variable int edad 00:25:07
yo no la hubiera declarado, porque se me ha olvidado 00:25:10
automáticamente 00:25:12
no hay ninguna 00:25:14
cajita ni espacio en memoria 00:25:16
RAM de 32 bits que se 00:25:18
llame edad, no la hay 00:25:20
¿vale? luego, si yo 00:25:21
tratara de hacer esta sentencia de asignación 00:25:24
ahí ya el compilador diría 00:25:26
¿qué es esto? 00:25:29
no hay ninguna variable 00:25:32
declarada con ese nombre 00:25:33
entonces imposible 00:25:34
asignar, ¿vale? 00:25:37
bueno, eso es lo primero que mira el compilador 00:25:38
que la variable esté declarada 00:25:40
antes de su primer uso 00:25:42
no vale que la declare después 00:25:44
no vale que yo la declare después, ¿vale? 00:25:46
tiene que estar declarada antes de su primer uso 00:25:48
ah, vale, uno mira 00:25:51
y aparte el mensajito 00:25:52
que sale es bien claro 00:25:54
para que uno se vaya acostumbrado porque 00:25:55
es normal, pues uno 00:25:58
escribe código y se olvida de cosas 00:26:00
entonces rápidamente 00:26:02
vamos asociando 00:26:04
los mensajes del compilador con las 00:26:07
cosas para ahí no perdemos tiempo 00:26:08
en cuanto algo te dice 00:26:10
no puedo resolverlo, si te dice que 00:26:12
un término no lo puedes resolver 00:26:14
se refiere a que no está declarado 00:26:16
que no está declarado, entonces puede ser 00:26:18
que realmente se te ha olvidado declararlo 00:26:20
o puede ser que 00:26:23
te hayas equivocado escribiéndolo 00:26:24
porque hayas tecleado muy rápido 00:26:26
puede ser mil cosas, pero lo que 00:26:28
importa es que entendamos que 00:26:30
esa variable con ese nombre no existe 00:26:32
entonces revisamos, ah vale 00:26:34
es que se me olvidó, ya está 00:26:36
¿vale? 00:26:38
de nuevo, otra restricción 00:26:41
de Java, otros lenguajes no la tienen 00:26:44
como Python 00:26:46
que tú usas una variable 00:26:47
pues 00:26:50
se la inventa en ese momento 00:26:52
entonces por eso se hizo Python 00:26:53
se hizo un lenguaje rápido, que lo trague todo 00:26:56
que lo coja todo, que sea muy fácil de aprender 00:26:58
y entonces hace 00:27:00
es más operativo y más rápido 00:27:02
pero claro, las aplicaciones 00:27:04
comerciales 00:27:06
son muy poco robustas en Python 00:27:08
por eso Python tiene otro 00:27:10
campo, que es más el universitario 00:27:12
el científico, todo eso 00:27:14
bueno, pues seguimos con la asignación 00:27:15
que decíamos para 00:27:24
una vez que ve que esta variable 00:27:25
existe 00:27:30
operador igual 00:27:31
y se pone 00:27:35
a mirar el valor 00:27:38
coge el valor, lo construye 00:27:38
si es un, hasta ahora 00:27:41
como solamente hemos usado valores números, pues construye 00:27:43
el numerito 00:27:45
y mira a ver 00:27:46
si es un valor del mismo tipo 00:27:49
el que hemos dado ahí 00:27:52
que la variable declarada 00:27:53
¿vale? del mismo tipo 00:27:55
entonces 00:27:58
en general, ahora 00:27:59
vamos incorporando los matices 00:28:01
el valor tiene que ser del mismo 00:28:03
tipo que la variable en la que yo lo voy a meter 00:28:06
porque si no es del mismo tipo 00:28:08
pues va a decir, lo siento 00:28:09
no me puedes dar que meta una 00:28:11
botella en el espacio para meter 00:28:14
un vaso, lo siento 00:28:15
pero no, en el espacio 00:28:17
para meter una botella, dame una botella 00:28:19
si no, nada, eso es lo que te dice 00:28:22
el compilador 00:28:24
por en general 00:28:24
pero en determinadas situaciones 00:28:27
a lo mejor puede él deformar 00:28:29
un poquito, dice vale 00:28:32
tengo espacio con la botella y me has dado un vaso 00:28:34
es una de las situaciones 00:28:36
contadas 1, 2, 3, 4, 5 00:28:38
en las que yo puedo hacer 00:28:40
esa deformación 00:28:42
no es que la haga siempre, por defecto no 00:28:43
esa deformación para que un vaso 00:28:45
quepa en el espacio de una botella 00:28:48
esa deformación la hace en 1, 2, 3, 4, 5 00:28:49
situaciones 00:28:52
Si es alguna de esas, lo hace 00:28:53
Si no, no 00:28:55
Vale, pues algunas situaciones ya las hemos visto 00:28:56
Cuando 00:28:58
Queremos meter un numerito que ha construido 00:29:01
Como int en un byte 00:29:03
Esa adaptación la hace 00:29:05
Pudiéndose los dos bytes más significativos 00:29:08
Que da igual porque todos solo tenían ceros 00:29:10
Si le damos un numerito 00:29:12
Que lo ha construido así 00:29:16
Y lo tiene que meter en un short 00:29:18
Pues de nuevo 00:29:20
hace la adaptación en forma 00:29:22
puliendo los 16 bits 00:29:24
que le damos un long 00:29:26
como este 00:29:30
como hemos visto antes 00:29:33
y lo queremos meter en un int 00:29:35
no, ahí no lo hace 00:29:36
es lo que acabamos de decir 00:29:38
hay nada de aplastar el long para que quepa en int 00:29:39
esa no la hace 00:29:42
pero si hace la inversa 00:29:43
si hace la inversa 00:29:47
que es esta de aquí 00:29:49
yo aquí le he dado un int 00:29:52
y la inversa 00:29:54
que es estirarlo 00:29:56
para que quepa en los 64 bits 00:29:57
de la variable dactocha 00:30:01
la inversa sí que la hace 00:30:02
y eso es 00:30:03
lo que acabo de decir 00:30:06
que esto se llama 00:30:08
promoción automática 00:30:10
la promoción automática en general es 00:30:12
yo tengo un dato 00:30:21
que me dicen que lo guarda 00:30:22
en una variable que no es del mismo tipo 00:30:25
pero esta variable 00:30:27
en el caso 00:30:29
de los números es muy fácil de ver 00:30:31
esta variable, este dato 00:30:32
perdón, es lo evidentemente pequeñito 00:30:35
como para que me quepa en este espacio tan grande 00:30:37
pues entonces lo estiro 00:30:39
poniendo ceros, lo estiro 00:30:41
pongo ceros, lo estiro y te vas a 64 00:30:42
eso es lo que se llama general promoción automática 00:30:44
que se hace no solo con números 00:30:47
por ejemplo, si declaras 00:30:48
una variable aquí 00:30:52
y luego le pones un carácter 00:30:53
eso también sería 00:30:54
no exactamente 00:30:55
le tienes que poner un carácter pero que sea cadena 00:31:00
No, no, ahí no es promoción automática 00:31:03
Porque si no es un objeto, eso es otra cosa 00:31:05
¿Vale? Eso ahora ya lo miraremos 00:31:06
No es exactamente promoción automática 00:31:09
Vale, promoción automática 00:31:11
Se hace esencialmente con números 00:31:13
Con valores numéricos 00:31:15
¿Vale? Porque el otro ya involucra objetos 00:31:17
Y ahí ya la promoción a objetos no existe 00:31:18
Se hace con números, la promoción automática 00:31:20
Vale, sí 00:31:23
¿Perdón? 00:31:25
No, no, no 00:31:31
Es que esto es una variable 00:31:32
y una variable significa que su valor 00:31:33
varía las veces que a mí me dé la gana 00:31:35
en un momento dado me hace falta 00:31:38
que tenga 13, ahora necesito que tenga 15 00:31:40
ahora me apetece que tenga 28 00:31:42
ahora me meten el dato 00:31:44
por una base de datos y ahora tiene 37 00:31:45
entonces coge el dato que el último dato 00:31:48
que ha puesto lo pone 00:31:50
claro, claro, cuando tú haces una asignación 00:31:50
a esta variable, da tocha 00:31:53
esta asignación, ¿qué ha hecho? 00:31:55
pues mete el 21 este aquí 00:31:58
lo que sea, ha metido este 00:32:00
y se queda así 00:32:01
y ahora la maquina virtual 00:32:02
hace lo que sea, opera con ese valor lo que sea 00:32:04
ahora llegamos a esta sentencia 00:32:06
esta sentencia 00:32:08
tira esto a la basura, ya ha desaparecido 00:32:10
ese número y ahora 00:32:13
se queda con el 78 00:32:14
entonces cada vez que haces una asignación 00:32:16
pisas el valor anterior 00:32:18
el valor anterior ya 00:32:20
desaparece y se queda 00:32:21
el nuevo valor 00:32:26
¿vale? 00:32:27
Dime 00:32:28
Esa 00:32:29
No, no, no 00:32:33
A ver, esa en particular lo hace 00:32:37
Porque tú le has dicho que va en un byte 00:32:39
Pero esa no se hace por defecto 00:32:40
Vamos a 00:32:43
Ir viendo ejemplos 00:32:44
Aquí 00:32:47
Esto, en realidad 00:32:47
Esto no es 00:32:51
Promoción es siempre ir 00:32:53
De un valor con una información pequeñita 00:32:54
a un espacio de memoria con un tamaño más grande. 00:32:57
Eso es la promoción, ¿vale? 00:33:00
Entonces, ¿dónde es? 00:33:02
Ah, aquí. 00:33:07
Vale. 00:33:09
Entonces, esto de aquí, 00:33:10
esto de aquí, aunque yo os he explicado por dentro 00:33:11
cómo funciona, 00:33:14
esto en realidad es transparente, 00:33:15
lo podemos olvidar. 00:33:17
O sea, nosotros cuando le asignamos, 00:33:18
cuando estamos escribiendo código 00:33:20
y seleccionamos una variable byte, 00:33:21
porque sabemos que el numerito solamente va a ocupar 8 bits, 00:33:23
o seleccionamos una variable short 00:33:25
porque sabemos que el numerito se lo va a ocupar 16 00:33:28
como mucho, pues lo único 00:33:30
que nos tenemos que preocupar es de asignarle 00:33:32
números que no se escapen 00:33:34
de esos valores, es lo único que nos tenemos que preocupar 00:33:36
que internamente la máquina virtual 00:33:38
lo vaya a meter en 32 00:33:40
y luego se pula al otro 00:33:42
es que nos podemos olvidar desde ya 00:33:44
nosotros, con preocuparnos de 00:33:46
cuando decae una variable byte 00:33:48
numerito 00:33:50
que quepa en 16 00:33:51
porque es en 8, perdón 00:33:54
porque si no el compilador 00:33:55
es que ya de partida no me va a dejar 00:33:57
y me olvido 00:33:59
no tengo que preocuparme de nada más 00:34:02
short igual, declaro una variable short 00:34:04
pues solo me tengo que preocupar 00:34:06
que los valores que yo asigne 00:34:08
los valores que yo asigne 00:34:10
quepan en 16 bits 00:34:12
porque si no 00:34:14
el compilador ya de partida 00:34:16
va a decir que no, vale 00:34:18
entonces aquí no hay 00:34:20
promoción ni despromoción automática 00:34:22
aquí el numerito 00:34:25
que yo le ponga 00:34:27
cabrá en 8 e irá a 8 00:34:28
aunque internamente 00:34:30
haya una especie de valor temporal de i 00:34:32
pero es que hasta podemos olvidar nuestro valor temporal de la máquina virtual 00:34:34
aquí lo mismo, aquí no hay ni promoción 00:34:36
ni despromoción 00:34:39
el numerito que yo ponga i 00:34:40
cabrá en 16 y va a 16 00:34:41
vale, esta otra situación 00:34:44
ya la hemos visto 00:34:47
si yo aquí 00:34:47
construye un valor de 64 00:34:51
tiene que ir sí o sí 00:34:53
a 64 00:34:55
porque la despromoción no existe 00:34:56
o sea, un valor 00:34:59
que es así, que la máquina virtual 00:35:00
lo encoja y lo meta en un espacio así 00:35:03
eso sí que no existe 00:35:05
la despromoción no existe 00:35:07
la puedo forzar, pero es otra cosa que se llama casting 00:35:09
que ya veremos, pues la forzo y me cargo el número 00:35:11
pero eso no existe 00:35:13
vale, pero 00:35:15
otro caso de promoción automática 00:35:18
por ejemplo, bueno, este que ya hemos visto 00:35:20
ahora tenemos edad y edad tocha 00:35:25
vale, imaginaos que ahora a edad tocha 00:35:27
en lugar del 78 00:35:29
yo le asigno edad 00:35:30
¿vale? 00:35:33
esta es la asignación 00:35:37
ahora ya es un pelinín 00:35:38
más 00:35:42
sofisticada 00:35:43
edad tocha 00:35:47
igual a 13, todo el mundo lo entiende 00:35:49
coges el 13 y se va a la variable 00:35:51
ahora edad tocha igual a edad 00:35:53
también es una sentencia de asignación 00:35:56
la máquina virtual 00:35:58
verificará, bueno el compilador 00:36:00
que edad tocha 00:36:02
y edad estén declaradas 00:36:04
porque si no nada 00:36:06
y lo están, edad tocha está aquí 00:36:07
que tiene 64 bits 00:36:10
y ahí está declarada 00:36:12
edad también está declarada por ahí arriba 00:36:15
edad tiene 00:36:18
4 bytes 00:36:21
32 bits 00:36:24
edad, tocha y edad están ahí, con la diferencia 00:36:26
de que estas son 64 y esta 00:36:28
32, vale 00:36:30
están las dos detonadas por ahí, con lo cual 00:36:31
ya existen estos dos espacios en memoria 00:36:34
existe el espacio edad con 00:36:36
32 y existe el espacio edad 00:36:38
con 64, vale, ahora vamos a 00:36:40
hacer una sentencia de asignación 00:36:42
como esta 00:36:43
la sentencia de asignación 00:36:45
cumple las reglas 00:36:48
que es 00:36:50
valor de la izquierda 00:36:51
una variable declarada 00:36:53
previamente, correcto 00:36:56
edad tocha es una variable declarada 00:36:58
previamente, esa primera regla 00:37:00
el compilador dice, la has cumplido 00:37:02
operador de asignación 00:37:04
inciso 00:37:07
esto ya es regla de estilo 00:37:08
exclusivamente, recordad lo que hablábamos 00:37:10
de reglas de estilo, tratad de seguirla 00:37:12
siempre para que nuestros códigos sean legibles 00:37:14
antes y después de los 00:37:16
operadores, se suele poner 00:37:18
un espacio para que no esté todavía piñado 00:37:20
entonces acostumbrados a poner un espacio 00:37:22
para que no esté todo piñado 00:37:24
al compilador le da igual, como si yo lo pongo todo a piña en una línea 00:37:25
pero bueno, es una regla de estilo 00:37:28
que convendría que siguiéramos 00:37:30
pero el compilador no va a mirar, el compilador va a mirar 00:37:32
que después del identificador de variable 00:37:34
que ya existe, esté el operador igual 00:37:36
bien, y ahora hemos dicho 00:37:39
que aquí tiene que haber un valor 00:37:41
vale, entonces ese valor 00:37:42
puede ser, bien porque 00:37:45
solo hemos dado a tiro fijo nosotros, como aquí 00:37:47
que le hemos dado 00:37:49
el valor 37 00:37:51
o bien 00:37:54
porque le hemos dado 00:37:55
un nombre de variable 00:37:58
donde ya hay un valor dentro 00:38:01
entonces los valores 00:38:03
no tenemos por qué dárselos a las asignaciones 00:38:05
directamente 00:38:07
nosotros el valor 97 00:38:08
12, 13, estoy ahora particularizando 00:38:10
solo en números porque nosotros estamos trabajando con números 00:38:13
¿vale? le podemos dar 00:38:15
un nombre de variable 00:38:17
porque el compilador 00:38:19
dirá, ah, me han dado 00:38:21
un identificador 00:38:23
pues será que esto es un nombre 00:38:24
de variable, se pone a buscar 00:38:27
primero que la variable 00:38:29
esté correctamente declarada 00:38:31
y después 00:38:33
va a mirar lo que hay dentro 00:38:35
eso es lo que va a hacer 00:38:37
¿vale? entonces 00:38:39
¿cómo se completa 00:38:43
la sentencia de asignación? 00:38:54
la máquina virtual dirá 00:38:56
a ver, edad 00:38:58
es una variable, voy a buscarla 00:38:59
donde está aquí 00:39:02
porque tiene que estar, porque si no el compilador 00:39:03
ya antes nos habría dicho 00:39:06
que edad no está declarada, ya habría cortado ahí 00:39:08
y no nos habría dejado ejecutar 00:39:10
si no se ha dejado ejecutar 00:39:12
es porque edad es una variable 00:39:14
correctamente declarada 00:39:16
bueno, pues se va a buscarla 00:39:17
y coge el valor que tiene dentro 00:39:20
coge el valor que tiene dentro 00:39:24
y ese valor 00:39:26
lo asigna este 00:39:28
Y se quedan las dos con el mismo valor 00:39:29
Esto es como decir 00:39:32
Por favor, pasa a esta caja 00:39:37
El contenido de esta otra 00:39:39
Tú puedes decirle, mete en esta caja 00:39:40
Este vaso 00:39:43
Das el vaso para la caja 00:39:44
Puedes decir, mete en esta caja lo que haya en esta caja 00:39:46
Si en esta caja hay un vaso 00:39:49
Coges el vaso y lo metes en 00:39:51
La diferencia es que en este caso 00:39:52
Estás duplicando el vaso 00:39:55
El vaso se queda en los dos lados 00:39:56
No mueves 00:39:57
No mueves, ¿vale? 00:39:59
Perfecto, yo te voy a ejecutar edad 00:40:00
Si pones que escriba la edad 00:40:03
¿Va a ser el 78 igual? 00:40:07
Sí, sí, sí, sí, o sea, esta variable 00:40:09
Solo ha servido para 00:40:10
Informar de qué valor 00:40:12
Hay que dar a la otra, pero ella no pierde 00:40:15
Su valor, ¿vale? 00:40:17
Ya no pierde su valor, no es que se traslade de una a otra 00:40:19
Es decir 00:40:21
Esto, esto es el nombre de una caja 00:40:23
Entonces la máquina virtual se va a ver 00:40:25
que hay dentro de la caja, dice hay un 78 00:40:27
pues 00:40:29
el valor 78 00:40:31
lo escribe aquí también 00:40:33
sin hacer desaparecer este 00:40:35
edad sigue teniendo 78 00:40:37
este no lo hace desaparecer 00:40:39
ahora las dos variables 00:40:41
tendrían 78 00:40:43
entonces una forma 00:40:44
de obtener 00:40:47
los valores 00:40:49
para las asignaciones 00:40:50
aparte de darlo tal cual 00:40:52
es dar 00:40:55
un nombre de identificador, variable 00:40:57
o cajita para decirte 00:40:59
el que está aquí 00:41:01
el que tienes que asignar es el que está 00:41:02
aquí, entonces la máquina virtual 00:41:05
se va a ver, ¿y cuál hay ahí? 00:41:07
se va a verlo, ah, que ahí hay un 78 00:41:09
vale, pues copio 00:41:11
un 78 aquí 00:41:13
y los dos se quedan con el mismo valor 00:41:15
¿vale? entonces es una asignación 00:41:17
puntual en ese momento 00:41:19
si ahora yo cambio 00:41:21
la variable edad 00:41:22
Aquí parece que he grabado 00:41:25
Si ahora yo cambio la variable edad 00:41:27
Y le pongo 89 00:41:32
Por ejemplo 00:41:34
Y previamente tenía 78 00:41:35
Para dejarlo así 00:41:39
¿Vale? 00:41:40
Por ejemplo estas tres sentencias 00:41:44
Estas tres sentencias de aquí 00:41:46
¿Vale? 00:41:51
Esas tres sentencias ya sabemos que efecto tienen 00:41:53
Aquí tenemos edad 00:41:56
Que resulta que tiene un 78 00:41:58
Porque se lo he puesto 00:42:01
aquí tenemos edad tocha 00:42:02
no sé lo que tiene, bueno, tiene eso 00:42:04
lo que tenga 00:42:07
de antes 00:42:09
ahora, hago esta asignación, ya sabemos que la asignación 00:42:10
implica que la máquina 00:42:13
virtual dice, uy, aquí hay una 00:42:15
hay una variable 00:42:17
voy a ver que tiene, se asoma 00:42:19
y dice, ah, tiene un 78 00:42:20
vale, pues voy a copiarlo 00:42:22
aquí, 78 00:42:25
después de esta segunda 00:42:26
sentencia nos quedamos así 00:42:29
y esas variables 00:42:30
no es que se queden ligadas de por vida 00:42:33
esto ha sido 00:42:34
una asignación puntual 00:42:35
ahora 00:42:39
a edad le ponemos 00:42:41
89, ¿vale? 00:42:43
¿qué significa eso? que el valor que tenía edad 00:42:44
fuera la basura 00:42:47
y ahora ya tiene 89 00:42:48
y el actocha sigue igual que tenía de antes 00:42:50
no se ve afectada, esto no significa 00:42:52
que estas variables 00:42:55
se queden ya unidas de por vida 00:42:57
y que una vaya a seguir a la otra siempre 00:42:59
nada que ver, siguen siendo dos variables 00:43:00
separadas 00:43:03
lo que pasa es que para esta asignación 00:43:04
puntual y solo para 00:43:07
esa asignación puntual 00:43:09
esta variable 00:43:10
ha recibido lo que en este momento 00:43:12
tenía esta otra, lo que tenía en este momento 00:43:14
y a partir de ahí 00:43:16
ya está, siguen cada una por libre con sus valores 00:43:18
¿vale? 00:43:20
¿pues aún bien? 00:43:23
sí, claro, es una cosa 00:43:23
ese signo de igual no funciona como 00:43:25
No, no, no, no. 00:43:27
No funciona como son la misma variable. 00:43:31
No. Es el operador asignación. 00:43:33
Edad tocha siempre va a ser 00:43:36
una variable y edad otra muy distinta. 00:43:37
Siempre van a ser distintas. 00:43:40
Iguales para 00:43:42
asignar puntualmente un valor. 00:43:43
No significa esta variable y esta 00:43:45
se convierten en la misma. 00:43:47
No significa automáticamente se funden 00:43:49
y son un único espacio en memoria. 00:43:51
No, no, no. 00:43:54
Claro, fundamental. 00:43:56
no significa se han fundido 00:43:57
y a partir de ahí son el mismo. 00:44:00
Porque si significara eso, 00:44:02
efectivamente, cuando yo hago ahora 00:44:03
el 89 aquí, el 89 00:44:05
también iría a la otra 00:44:07
variable. No, no, no, no. 00:44:09
Esto es un operador 00:44:11
para asignar 00:44:13
en ese momento el valor 00:44:14
que yo ponga aquí, que ese valor puede proceder 00:44:17
de una variable, de un número, 00:44:19
de operaciones, como después veremos, 00:44:21
de expresiones complejas. Ese valor 00:44:23
de donde sea procederá 00:44:25
de donde sea, pues en ese momento 00:44:27
ese valor va aquí 00:44:29
pero las variables que estén aquí involucradas 00:44:31
esas variables solo han servido 00:44:33
para enseñarte 00:44:36
lo que tiene, nada más 00:44:38
esa variable sigue ahí su vida libre 00:44:39
solo sirve aquí 00:44:42
para enseñar lo que tiene, dice oye 00:44:43
tengo un 78, te lo enseño 00:44:45
entonces tú ya lo coges 00:44:48
y lo asignas a este, la variable da 00:44:50
su vida independiente de la otra 00:44:51
¿Vale? 00:44:53
¿No has preguntado antes de parar? 00:44:55
¿Para qué querrías hacer eso? 00:45:01
Eso sería como hacer desaparecer una 00:45:05
Si ya no necesitas dos variables 00:45:09
Y no puedes hacer desaparecer una variable 00:45:11
O sea, modificar las variables 00:45:14
De repente una desaparezca 00:45:16
Una y otra sean la misma 00:45:18
Venga, pues vamos a parar entonces 00:45:19
Un momentico 00:45:24
Gracias. 00:45:26
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:
5
Fecha:
22 de septiembre de 2025 - 17:08
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
45′ 27″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
1.68

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid