Saltar navegación

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

Clase 25-09-23 - 2 - Contenido educativo

Ajuste de pantalla

El ajuste de pantalla se aprecia al ver el vídeo en pantalla completa. Elige la presentación que más te guste:

Subido el 25 de septiembre de 2023 por Raquel G.

10 visualizaciones

Más información Transcripción

Descargar la transcripción

Vale, vamos a continuar. Ninguna pregunta, ¿no? Por lo que veo. 00:00:01
Bueno, pues entonces, estábamos con la asignación de variables y la compatibilidad de tipos, ¿vale? 00:00:08
Recordad que como principio básico, el tipo de dato del valor que ponemos ahí tiene que ser igual, salvo con este matiz. 00:00:16
salvo con este matiz, si se puede 00:00:25
modificar sin perder 00:00:28
información, lo deja hacer 00:00:29
de hecho 00:00:31
con los int y los long, ya está haciendo 00:00:34
aquí una promoción automática, aquí 00:00:36
que vamos a 00:00:37
a ver ahora, que vamos a mencionar ahora 00:00:40
a ver, vamos a volver a asignar 00:00:43
a la variable 00:00:46
número 3, que era long 00:00:47
a la variable número 3 00:00:49
vamos a volverle a hacer una asignación 00:00:51
por ejemplo, esto de aquí 00:00:53
Entonces 00:00:55
Estas son cosas que tenéis que ir 00:00:57
Vale, 6, 7 00:01:00
La máquina virtual ahora se encuentra esta sentencia 00:01:02
Silencio 00:01:05
La máquina virtual se encuentra esta sentencia 00:01:07
Entonces ahí se encuentra un número 00:01:10
Se encuentra un número entero 00:01:13
Entonces cuando la máquina virtual 00:01:14
Se encuentra un número así 00:01:16
6, 7, 5 00:01:18
Menos 6, 7, 5, o sea un número entero 00:01:20
Así por las buenas 00:01:22
interpreta que le estamos dando un int 00:01:23
interpreta un int 00:01:27
con lo cual esa asignación a int 00:01:28
es perfectamente válida 00:01:31
porque interpreta que es un int 00:01:32
y lo construye dentro como int con 32 bits 00:01:33
lo construye dentro 00:01:36
interpreta que es un int 00:01:37
aquí este int lo está asignando una variable log 00:01:38
no hay problema porque hemos dicho 00:01:43
que se puede hacer la promoción automática 00:01:44
no hay ningún problema 00:01:47
entonces la máquina virtual lo interpreta como int 00:01:48
porque es un número 00:01:50
Lo interpreta como int 00:01:51
Ahora, punto 2 00:01:53
B, que tiene que asignarlo a un long 00:01:55
Pues dice, ah, pues me toca ampliarlo 00:01:57
Lo amplía, no hay problema 00:01:59
Y ya está, ¿vale? 00:02:01
Hasta ahí, eso ya lo sabemos 00:02:02
Vale, pero ¿qué ocurre si yo aquí pongo un número muy grandote 00:02:04
Que no puede ser un int? 00:02:08
Por ejemplo este 00:02:10
Vamos a ver, por curiosidad 00:02:11
¿Cuál es el número int más grande o más pequeño que se puede guardar? 00:02:14
¿Y cuál es el número long más grande o más pequeño que se puede guardar? 00:02:18
¿Cómo podemos ver eso? Bueno pues resulta que aunque a lo mejor no entendamos por qué se escribe así, Java tiene ya un montón de cosas que de toda la vida en programación se han llamado constantes que tienen ya valores asignados que pueden ser útiles, típico, estándar, la constante pi, ¿no? 00:02:20
cualquier lenguaje de programación puede necesitar operar con la variable, con el valor constante pi para hacer cosas, 00:02:44
pues entonces ya define en algún sitio una constante que tiene siempre ese valor, 00:02:51
para que cuando nosotros tengamos que operar con la constante pi para trabajar con trigonometría, 00:02:56
pues no tengamos que poner todo el rato 3, 14, 15, 9, no sé cuánto, no sé qué, tiene ya una constante pi, tiene sentido. 00:03:01
Y como la constante pi, que he dicho esa porque es la que todos conocemos, hay otros valores interesantes que tiene sentido que cualquier lenguaje de programación los guarde ya en una variable suya que llamamos constante mal llamada de alguna manera porque la idea es que ese nombre se conserve y no lo cambiemos, pero no deja de ser una variable más. 00:03:07
es una variable con ese valor pi 00:03:33
bueno, pues cualquier lenguaje de programación 00:03:35
tiene, cuando arranca 00:03:37
tiene ya 00:03:39
una serie de variables 00:03:41
con unos valores que nos pueden 00:03:43
ser útiles, a lo mejor podemos usarlos 00:03:45
o podemos no usarlos, pero ya tiene 00:03:47
algunos con unos valores que nos pueden ser útiles 00:03:49
el típico, repito, la variable pi 00:03:51
¿vale? el típico 00:03:53
¿qué otras variables 00:03:55
también según arranca un programa 00:03:58
se crean, si nosotros nos demos 00:03:59
cuente, nos enteremos, se crean y se quedan ahí con valores, pues por ejemplo 00:04:01
una variable que guarda el mayor número entero almacenable 00:04:05
en un int, el mayor número entero almacenable en un long 00:04:09
el menor número entero almacenable en un int 00:04:13
el menor número entero almacenable en un long, son valores que nos pueden 00:04:17
ser interesantes para saber si los datos con los que trabajamos 00:04:21
superan el rango de almacenamiento, son valores que son interesantes 00:04:25
y una aplicación cuando arranca, pues crea unas variables y les da ese valor. 00:04:28
Vamos a mostrar esas variables cuáles son, porque no sabemos cuáles son su nombre, 00:04:36
no las hemos declarado nosotros, nosotros hemos declarado estas. 00:04:39
Pero repito, hay otras que han aparecido ahí solas, de la nada, 00:04:43
la máquina virtual las ha hecho aparecer, porque pueden ser interesantes. 00:04:46
¿Cuál es su nombre? Pues tendríamos que buscarlo en la documentación de Java, 00:04:50
a ver cuál es, porque es un nombre fijo, claro, algunas, las típicas, pues las conocemos. 00:04:54
Bueno, pues por ejemplo, vamos a mostrar aquí, por curiosidad y porque ahora vamos a ejemplificar 00:05:00
un poco, ahora ya justo después de la promoción automática, vamos a mostrar el mayor y menor 00:05:05
valor 00:05:18
almacenable en una variable 00:05:20
de tipo long 00:05:23
variable de 00:05:23
tipo long 00:05:30
vale, mostrar por consola 00:05:32
recordad 00:05:35
que era esta sentencia, mostrar por consola 00:05:37
entonces yo esta sentencia 00:05:39
ya vamos poco a poco familiarizándonos 00:05:41
con su uso, poco a poco, porque tenemos que usar mucho 00:05:43
vamos poquito a poco 00:05:45
recordad que el uso que le hemos 00:05:46
dado hasta ahora es, si yo le paso una cadena de texto, me muestra tal cual la cadena de 00:05:49
texto, eso está claro, si le paso una cadena de texto me muestra tal cual la cadena de 00:05:56
texto, pero si le paso un identificador no entrecomillado, un identificador no entrecomillado, 00:05:59
por ejemplo este, entonces como este identificador no está entrecomillado, pasa lo mismo que 00:06:08
En la evaluación de expresiones 00:06:14
Dice, ah, pues debe ser que te refieres 00:06:16
A una variable que se llama así 00:06:18
Como no está entrecomillado, debe ser que te refieres a eso 00:06:20
¿Vale? Entonces él la busca 00:06:22
Mira, a ver si está declarada, coge el valor y muestra el valor 00:06:24
¿Vale? Hasta ahí 00:06:26
Está claro 00:06:28
Otra cosa es que yo le dé esto 00:06:29
Si le doy esto, ahí lógicamente 00:06:32
Como era de esperar, me dice 00:06:34
No te puedo mostrar esto 00:06:35
Porque no está entrecomillado, con lo cual 00:06:37
No es esa cadena tal cual 00:06:40
Si yo la entrecomillo, por supuesto puede 00:06:41
porque entonces se refiere cadena 00:06:44
número 4, ningún problema 00:06:46
la puede mostrar sin problema 00:06:48
pero si yo le quito las comillas 00:06:49
entonces lo que le estoy diciendo 00:06:51
es, este es el identificador 00:06:54
número 4, lo que me interesa es 00:06:56
que vayas a la variable que se llama 00:06:58
número 4 y cojas su valor 00:07:00
la variable número 4 no existe 00:07:01
no está declarada, no existe 00:07:04
pues no te la puede mostrar y te dice 00:07:05
muy mal, muy mal 00:07:08
y te da una recompilación y no puedes seguir 00:07:09
pero si le pongo número 3 pues sí 00:07:11
bueno, pues entonces yo he hecho este system out ahora 00:07:14
para mostrar el contenido 00:07:16
de la variable que contiene 00:07:19
el mayor valor long almacenable 00:07:20
y el menor valor, para tener esa información 00:07:23
porque puede ser interesante 00:07:25
¿cuál es el nombre de esa variable? 00:07:26
no lo sé, es una de esas que hace aparecer 00:07:28
java de partida 00:07:30
y que están ahí, yo las puedo usar, pero es que no sé cuál es el nombre 00:07:31
bueno, pues lo escribo yo 00:07:35
y lo digo yo ahí 00:07:37
pues el nombre de esa variable 00:07:39
ahora a lo mejor os parece un poco raro 00:07:41
porque tiene un punto 00:07:44
y eso es 00:07:46
es este, veis 00:07:47
ahí Java no se ha quejado 00:07:49
yo le he dado un identificador 00:07:51
le he dado un identificador 00:07:54
y me dice 00:07:56
ah si, si, conozco ese identificador 00:07:58
lo conoce, no lo hemos declarado nosotros 00:08:00
pero es uno de los 00:08:02
tropecientos mil 00:08:03
que Java hace aparecer 00:08:05
automáticamente, la máquina virtual de Java 00:08:08
lo hace aparecer automáticamente cuando la aplicación arranca, 00:08:09
y a los que yo puedo recurrir si lo necesito. 00:08:12
Uno obviamente no se los sabe todos de memoria, 00:08:16
pero sí sabe que hay unos cuantos valores a los que puede recurrir siempre si le hacen falta, 00:08:20
y los puede buscar en la documentación. 00:08:28
Este en particular es el nombre identificador que se refiere al mayor valor long almacenable en una variable long. 00:08:33
¿vale? entonces 00:08:39
¿por qué lo he quitado? 00:08:42
si lo quiero mostrar 00:08:44
este, vale, vamos a mostrar 00:08:45
también el mínimo, para ver 00:08:52
entonces vamos a ejecutar 00:08:54
este programa 00:09:00
a ver cuál es, min, perdón 00:09:01
he puesto max dos veces 00:09:04
vale, vamos a ejecutar este 00:09:05
programa a ver cuáles son los valores que me da 00:09:08
a ver los que me da 00:09:10
pues venga 00:09:13
lo ejecutamos 00:09:16
este es el mayor valor entero 00:09:17
que yo puedo usar en un programa 00:09:24
si necesito una aplicación 00:09:27
que tenga que trabajar con enteros mayores que este 00:09:30
pues con Java no puedo 00:09:34
o tengo yo que hacer un programa 00:09:38
en el cual lo divida en porciones el numerito 00:09:40
y luego lo construya, pero porque lo haga yo por programa 00:09:43
pero este es el máximo con el que podemos trabajar 00:09:45
Pero hombre, ya es grandote, ya es grande en cualquier aplicación normal 00:09:49
¿Dónde vamos a tener más de 9.000 billones de no sé qué? 00:09:52
Ya es un numerito grande 00:09:58
Vamos a hacer lo mismo con el entero 00:09:59
Vamos a hacer lo mismo con el entero 00:10:03
Pues el entero, ese nombre, ese identificador 00:10:30
Que usa Java y que es que es así porque es el que usa 00:10:32
No porque a mí me dé la gana 00:10:36
Es este 00:10:37
¿Vale? Es este 00:10:39
vamos a mirar a ver cuál es el mayor número almacenable en un entero 00:10:42
y el menor número almacenable en un entero 00:10:49
si ejecutamos esto 00:10:51
pues el entero es un poco más pequeñito 00:10:54
como veis, es bastante más pequeño que el long 00:11:01
este es el mayor número almacenable positivo en una variable int 00:11:04
y este es el menor 00:11:08
si nuestra aplicación va a trabajar con números enteros 00:11:09
más grandes de 00:11:13
2000 millones 00:11:15
pues hombre, usámoslo 00:11:18
¿vale? 00:11:21
pero este ya es un número muy grande 00:11:24
bueno, pues ¿para qué muestro esto? 00:11:25
aparte de para introducir la idea 00:11:29
de que hay un montón de variables ya creadas 00:11:30
a las que yo puedo acceder 00:11:33
si conozco su nombre 00:11:35
y para eso tengo toda la documentación 00:11:36
en la página de Oracle 00:11:39
que me puede interesar 00:11:41
estas pues a lo mejor me puede interesar 00:11:42
la que he dicho antes, vamos a mostrarla por curiosidad 00:11:44
aunque ahora mismo no la vayamos a usar 00:11:47
pues esta 00:11:48
¿dónde la puede encontrar? 00:11:59
si uno busca en la documentación 00:12:01
pues la puede encontrar bajo este identificador 00:12:02
bajo este identificador lo puede encontrar 00:12:05
¿por qué estos identificadores 00:12:07
tienen punto? 00:12:10
yo he dicho en su momento 00:12:11
me deberíais decir, oye cuando declaraste variables 00:12:13
el punto no era un carácter válido 00:12:15
eran letras 00:12:17
números, subrayado y dólar 00:12:19
no era un carácter válido 00:12:21
claro 00:12:24
pues porque esto es 00:12:25
esto en realidad es otra cosa 00:12:27
que ya en su momento 00:12:29
explicaremos 00:12:31
lo digo para que si os surge la pregunta 00:12:32
bueno, porque esto es un caso especial 00:12:35
que ya entenderemos por qué, ahora no podemos entenderlo 00:12:37
pero sí, tenemos que saber 00:12:39
porque estamos usando variables 00:12:41
que aparte de las variables 00:12:43
que yo declaro, hay muchas más 00:12:45
que ha hecho aparecer la máquina 00:12:47
virtual, pum, de la nada 00:12:50
cuando el programa arrancó, muchas más 00:12:51
y si yo conozco el nombre de ellas 00:12:53
puedo usarlas para hacer cosas 00:12:56
si conozco el nombre de ellas 00:12:57
bueno, pues en particular, aquí hemos visto unas cuantas 00:12:58
¿por qué el identificador es tan raro con un punto? 00:13:01
ya lo entenderemos 00:13:04
bueno, vamos a mostrar el pi, a ver el pi este 00:13:05
pues bueno, estos son 00:13:08
los decimales que le da, no le da más 00:13:10
pero bueno, es una precisión suficiente como para hacer 00:13:11
operaciones trigonométricas 00:13:13
¿vale? 00:13:16
entonces, aquí lo voy a indicar 00:13:21
que 00:13:22
cuando un programa arranca 00:13:23
en la RAM 00:13:29
aparecen 00:13:36
muchas variables 00:13:40
además de las nuestras, claro 00:13:44
no está muy bien expresado, pero bueno 00:13:47
además de las nuestras 00:13:49
a las que podemos acceder con su nombre 00:13:52
bueno, pues entonces 00:13:54
¿qué relación tiene esto con lo que estábamos viendo 00:13:55
de promoción automática, etcétera? 00:13:58
vale, pues yo he dicho, vamos a asignar 00:14:00
ahora un valor 00:14:03
a mi variable int 00:14:05
número 2 00:14:07
número 2 será entera, ¿verdad? 00:14:09
número 2 es una variable entera 00:14:13
entonces 00:14:14
vale 00:14:17
a la variable entera número 2 00:14:20
le voy a asignar un numerito 00:14:25
mayor que esto 00:14:32
Mayor que esto 00:14:34
Esto tiene 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 00:14:35
1 de 11 cifras 00:14:43
1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 00:14:44
Vale 00:14:48
Pues se ha quejado 00:14:50
¿Vale? Se ha quejado 00:14:52
Y efectivamente si miráis 00:14:54
Bueno, por no... 00:14:57
¿Vale? Si miráis el mensajito que os pone 00:14:58
efectivamente dice que esto 00:15:10
está fuera del rango 00:15:14
de entero 00:15:15
¿vale? que está fuera del rango 00:15:16
entonces voy 00:15:20
comentando estas cosas porque son 00:15:23
los típicos errores que pueden 00:15:25
salir al principio cuando uno está haciendo programas 00:15:27
y nos tenemos que ir familiarizando 00:15:30
con las diferentes situaciones que se dan 00:15:31
para cuanto antes 00:15:33
perder el menos tiempo posible con ellas 00:15:35
¿vale? pues cuidado con esto 00:15:37
entonces hay unos rangos posibles 00:15:41
y uno no se puede pasar 00:15:43
entonces si yo le quito un 1 00:15:45
pues ahora ya sí 00:15:47
¿vale? 00:15:49
más cosas 00:15:56
que tenéis que saber 00:15:57
os tienen que ir sonando 00:15:58
esta asignación ya sí que es posible 00:15:59
porque este numerito 00:16:02
es menor que este, luego está en rango 00:16:03
dentro de los enteros está en rango 00:16:06
es menor, ¿verdad? está en el rango 00:16:08
vale, entonces nosotros hemos dicho 00:16:09
Cuando Java ve un número entero, lo almacena en los 32 bits, lo almacena en los 32 y lo guarda en la variable número 2, que sea. 00:16:13
Este lo puede almacenar en los 32 bits, perfecto, y lo guarda en la variable número 2. 00:16:26
Vale, pero yo puedo darle la orden de que lo almacene ya directamente en 64 bits. 00:16:33
Por ejemplo, mi variable número 3 00:16:39
Mi variable número 3 00:16:46
Que es esta 00:16:49
1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 00:16:50
Vale, siguiente error que podríais no entender 00:16:57
Mi variable número 3 es long, ¿verdad? 00:17:01
Es la que yo he declarado como long 00:17:06
Mi variable número 3 es long 00:17:07
Vos estáis haciendo pruebas con este 00:17:09
Haciendo pruebas con estos 00:17:12
me decís, vamos a ver 00:17:13
el mayor número almacenable en un longe es este 00:17:15
resulta que yo le estoy dando uno 00:17:18
que perfectamente cabe ahí 00:17:21
en un longe 00:17:23
y aún así sigue insistiendo 00:17:24
y se sigue poniendo pesado 00:17:27
se sigue poniendo pesado 00:17:30
con que me salgo del rango 00:17:34
¿cómo que me salgo del rango? 00:17:37
no me salgo del rango 00:17:41
uno podría pensar, no me salgo 00:17:42
esto cabe en un log 00:17:44
y esta variable es log 00:17:47
claro, pero ese mensaje que te está diciendo 00:17:48
se refiere al primer paso que he dicho 00:17:50
igual lo estoy liando un poco 00:17:53
cuando Java ve un numerito entero 00:17:55
un número entero sin más 00:17:57
una sucesión de números 00:17:59
lo primero que hace es cogerlo 00:18:00
y hacer su codificación en 32 bits 00:18:02
es lo primero que hace, hacer su codificación en 32 bits 00:18:05
y luego ya lo guarda en la variable que sea 00:18:07
que se entera, ningún problema 00:18:09
que es log, tampoco ningún problema 00:18:11
le hace la promoción poniéndole 0 si se acabó 00:18:13
pero lo guarda en una de 32 00:18:15
y aquí ha visto 00:18:17
que esto no le cabe en una de 32 00:18:20
con lo cual no puede 00:18:21
entonces es el error 00:18:23
que nos está diciendo 00:18:26
oye que esto yo es un número entero 00:18:26
lo guardo en una de 32 y es que no me cabe 00:18:28
entonces diríais pues que sentido tiene las variables 00:18:31
long, que sentido tiene si yo no puedo expresarle 00:18:33
un número es que nos falta 00:18:35
esto, la L 00:18:37
me da igual que sea mayúscula 00:18:39
que minúscula como más os guste 00:18:41
cuando queréis alterar ese funcionamiento 00:18:43
y le dais 00:18:46
un numerito a java, un número entero 00:18:48
y le dices, oye java 00:18:50
máquina virtual de java 00:18:52
este número entero que yo te doy 00:18:53
codifícalo en binario 00:18:56
directamente de 64 00:18:58
y luego ya con él 00:18:59
haz lo que toque, llevarlo a variable 00:19:02
llevarlo a donde, ahora lo haces 00:19:03
la segunda parte, pues cuando tú le quieres 00:19:06
alterar ese funcionamiento 00:19:08
y le quieres decir, este numerito 00:19:09
directamente, codificamelo 00:19:11
en 64, le pones una L 00:19:14
después, vale 00:19:16
vamos a indicarlo así 00:19:17
entonces 00:19:19
esta sentencia da error 00:19:23
de compilación 00:19:30
porque 00:19:34
la máquina virtual 00:19:39
de Java, la Java Virtual Machine 00:19:41
la máquina virtual de Java 00:19:43
la JRE también se puede llamar 00:19:44
de Java Runtime Environment, la máquina virtual de Java 00:19:47
trata de 00:19:49
guardar 00:19:59
el número pasado 00:20:01
en 32 bits 00:20:05
trata de guardar en 32 bits 00:20:08
y en 32 bits no le cabe 00:20:13
no le cabe, entonces le da error 00:20:14
no le cabe 00:20:16
entonces, si hacemos esto 00:20:17
de aquí, si añadimos 00:20:21
una L 00:20:23
ahora ya sí 00:20:24
Guarda 00:20:26
El número pasado 00:20:29
Directamente en 64 bits 00:20:31
Lo guarda 00:20:33
Directamente en 64 bits 00:20:47
Vale 00:20:48
Pues entonces 00:20:51
Cuidado con esto 00:20:51
Si uno trabaja con números grandes 00:20:54
Va a tener que ponerles la L 00:20:55
Siempre para indicarle a Java 00:20:59
Que los guarden en 64 bits 00:21:00
Porque si uno le pone la L 00:21:03
Va a estar todo el rato en el orden de compilación 00:21:04
Y una vez que le pongamos la L 00:21:06
Java dice, ah, vale, que quieres que te guarde 64 00:21:08
Vale, te guarde 64 00:21:10
Y con números grandes me refiero a números 00:21:12
Por encima de este, más grandotes que este 00:21:14
Por encima de este 00:21:16
Y ahora hay otra cosa 00:21:18
Es la asignación 00:21:20
Este número ya está guardado en 64 bits 00:21:21
Ya está codificado en 64 00:21:25
Ahora ya el siguiente paso es hacer la asignación 00:21:26
En este caso la asignación 00:21:29
Ningún problema, porque número 3 es long 00:21:31
Perfecto, la asignación ningún problema 00:21:33
pero si a mi se me ocurriera 00:21:35
esto mismo, hacerlo en número 2 00:21:37
esto mismo lo hago en 2 00:21:39
que era int, aquí ya si que se queja 00:21:45
dice, oye yo este número te lo he guardado 00:21:47
en 64 bits, estupendo 00:21:49
pero es que ahora estás tratando de guardar una variable entera 00:21:50
ahora ya a la hora de hacer la asignación 00:21:53
es cuando dice que no, que no puedes 00:21:55
un dato 00:21:57
que ocupa 64 bits 00:21:59
no lo puedes guardar 00:22:01
en una variable entera, ahora te da el problema 00:22:03
que ya conocemos 00:22:05
¿vale? te dice que no puedes 00:22:06
lo ponemos aquí 00:22:09
error por lo mismo de antes 00:22:15
no puede guardar 00:22:19
64 bits 00:22:22
en variable 00:22:25
32 bits porque pierde espacio 00:22:27
¿vale? lo que me he dicho antes 00:22:30
entonces lo que me da error de compilación 00:22:32
lo voy poniendo en comentarios 00:22:35
para luego poder hacer ejecuciones 00:22:36
no puede, vale 00:22:39
a la inversa hemos visto antes que sí 00:22:43
a la inversa sí, verdad 00:22:45
en número 3 00:22:46
sí que podemos 00:22:48
esto 00:22:49
222 como no tiene el L 00:22:50
no lo tiene 00:22:54
lo guarda en 32 bits 00:22:55
y puede porque no se sale de rango 00:22:57
perfecto, va en 32 00:23:00
y lo asigna número 3 que es long 00:23:01
pero hemos dicho que 00:23:03
asignar 32 bits a variables 64 00:23:05
no hay problema, eso es lo que se llama 00:23:08
promoción automática, ¿verdad? 00:23:10
es lo que hemos dicho justo antes después del recreo 00:23:12
es esto mismo, puede, ¿verdad? 00:23:13
esto sí que puede 00:23:16
vale, bueno pues 00:23:17
¿qué ocurre en la situación que decíamos antes? 00:23:24
si necesitamos 00:23:26
¿por qué es que necesitamos? 00:23:28
para que nuestro programa pueda continuar 00:23:30
necesitamos 00:23:31
un número que está guardado 00:23:33
en 64 bits 00:23:35
que me lo han pasado porque 00:23:37
yo he accedido a un software 00:23:40
de otro, lo que sea, me lo han pasado en 00:23:42
64 bits, ¿qué ocurre 00:23:43
si tengo que guardar una variable mía que está declarada 00:23:45
como int y no puedo cambiar la declaración? 00:23:47
La declaración está aquí hecha 00:23:50
al principio y no puedo 00:23:51
cambiarla. ¿Qué ocurre 00:23:54
si yo tengo que hacer eso? 00:23:56
Bueno, pues para saltarnos 00:23:58
eso, podemos hacer una cosa 00:24:00
muy peligrosa que se llama 00:24:01
casting, que vamos a hacerlo. 00:24:03
Vamos a ponerlo así. 00:24:06
¿Qué podemos hacer 00:24:10
entonces 00:24:11
si queremos asignar 00:24:12
un dato de 00:24:15
64 bits 00:24:19
a una variable 00:24:21
de 32 bits 00:24:22
¿qué podemos hacer en esta situación? 00:24:25
pues podemos hacer 00:24:29
una cosa 00:24:30
que se llama casting 00:24:31
¿vale? 00:24:34
se llama casting 00:24:36
conversión 00:24:38
pero 00:24:40
que es muy muy 00:24:44
Solo se hace si tenemos claro que no va a inducir a error, si no es muy peligrosa y es fácil entender por qué. 00:24:46
Vale, pues vamos a hacer un ejemplo. 00:25:03
Recordemos los dos datos con los que estamos trabajando. 00:25:06
Tenemos número 2 y número 1. 00:25:08
A número 2 que es el entero, bueno, a número 2 que es el entero, dejamos como está. 00:25:12
A número 3 le vamos a asignar el numerito este de aquí. 00:25:19
En este caso me da igual poner la L que no ponerla, porque esto sí que cabe en 32 bits. 00:25:27
Entonces si yo no pongo la L, él lo guarda en 32 bits y luego al ver que lo lleva a número 3 ya lo amplía. 00:25:33
Pero el resultado es el mismo, que lo va a ampliar con ceros. 00:25:39
Si le pongo la L, lo que hace es guardarlo directamente en 64 y luego ya lo asigna a número 3. 00:25:42
Me da igual en este caso por la L que no ponerla 00:25:49
Me da igual porque el numerito es más pequeño que esto 00:25:51
Vale 00:25:54
Entonces 00:25:55
Vamos a asignárselo a número 2 00:25:57
Perdón, a número 2 00:25:59
A número 2 le vamos a asignar 00:26:00
Número 3 00:26:03
Aquí es cuando nos dice 00:26:05
El error de compilación 00:26:08
Que tenemos clarísimo 00:26:10
Cuando nos salga y time mismatch 00:26:11
Porque no nos hemos dado cuenta 00:26:13
Automáticamente nos vamos a 00:26:14
¿Qué estoy haciendo? 00:26:16
Entonces estoy asignando una variable que es long, una variable que es de tipo long o una que es de tipo entero. 00:26:19
A la máquina virtual de Java le da igual si el dato que hay dentro es pequeño, es grande, va a caber, no va a caber, le da igual. 00:26:27
Lo que sabe es que por lo general cortar de 64 a 32 puede que te haga perder información. 00:26:33
En algunos casos al menos puede que te haga. 00:26:43
Entonces él por defecto no te deja hacerlo. 00:26:45
pero resulta que nosotros estamos en una situación en la cual decimos 00:26:47
oye, que yo sé que en la variable número 3 00:26:49
todo lo que va a haber siempre 00:26:51
cabe en 32, nosotros lo sabemos 00:26:53
porque lo sabemos, porque es una restricción 00:26:55
de nuestro código, porque antes de llegar aquí 00:26:57
hemos hecho un if con una condición 00:26:59
porque lo sabemos, porque sabemos 00:27:01
que eso se va a dar, pues entonces 00:27:03
podemos hacer ese casting, porque ese casting 00:27:05
ahora es controlado 00:27:07
lo controlamos nosotros 00:27:09
¿y cómo se hace un casting? 00:27:11
pues un casting se hace 00:27:13
se pone entre paréntesis delante 00:27:14
del valor 00:27:17
que no se corresponde en tipo 00:27:19
con el que doy, se pone delante 00:27:21
el tipo de dato al que yo lo quiero convertir 00:27:23
y ala 00:27:26
automáticamente se me quita el error 00:27:27
de compilación 00:27:29
¿vale? entonces ¿qué hemos hecho aquí? 00:27:30
un casting 00:27:38
estamos convirtiendo el valor de número 3 00:27:39
que es long a int 00:27:42
entonces un casting 00:27:44
es tan radical como 00:27:46
meter la tijera 00:27:48
los casting 00:27:50
lo que hacen es 00:27:52
que tú quieres convertir de aquí a aquí 00:27:53
yo te lo convierto 00:27:56
que lo que te devuelva tenga sentido 00:27:57
es tu problema 00:27:59
un casting es, meto la tijera 00:28:01
hago lo que haga falta 00:28:03
y yo te lo convierto 00:28:05
pues en el casting concreto 00:28:06
de convertir de long a int 00:28:09
y la conversión es a int porque se indica así 00:28:11
entre paréntesis 00:28:13
el tipo de dato 00:28:15
Vale, el casting siempre se hace de esta manera 00:28:16
El casting siempre se hace 00:28:19
Se pone entre paréntesis 00:28:21
Se pone delante del valor a convertir 00:28:25
Convertir 00:28:29
El tipo final al que vamos a convertir 00:28:35
Entre paréntesis 00:28:39
Así se hace el casting 00:28:40
Bueno, pues el casting es estupendo 00:28:44
Cojo número 3, que son sus 64 bits 00:28:46
Meto la tijera 00:28:49
los 32 más significativos fuera 00:28:51
y lo que quede te lo guardo en número 2 00:28:53
eso es un casting 00:28:55
¿qué ocurre? que si el numerito era inferior 00:28:57
a lo que cabe en 32 bits 00:29:00
ningún problema 00:29:02
entonces si nosotros sabemos 00:29:02
porque lo sabemos, porque hemos hecho la comprobación 00:29:05
con un menor que por lo que sea 00:29:07
que no pasa nada 00:29:09
pues hacemos el casting 00:29:10
y nos saltamos este error de compilación 00:29:12
que nos impediría seguir trabajando 00:29:16
en nuestro programa 00:29:17
nos impediría seguir trabajando 00:29:18
pues ya hago el casting 00:29:20
y ya no me impide seguir trabajando 00:29:22
vale 00:29:24
entonces si yo ahora muestro 00:29:25
el contenido de número 2 00:29:28
vamos a mostrar 00:29:30
el contenido de número 3 00:29:34
y el contenido de número 2 00:29:36
vamos a poner aquí 00:29:38
el contenido de número 3 00:29:48
y el de 00:29:50
número 2 00:29:51
van a ser los dos números que me salgan al final 00:29:55
pues vamos a ver que los dos tienen el mismo valor 00:29:57
porque aunque yo he hecho el casting 00:30:00
el casting no ha roto nada 00:30:02
vamos a comprobarlo 00:30:03
efectivamente 00:30:07
este casting no ha inducido 00:30:10
ningún error en mi programa 00:30:12
no ha hecho nada raro 00:30:13
este casting 00:30:14
número 3 tenía 7654 00:30:17
y número 2 00:30:20
que yo lo he obtenido 00:30:22
con esta asignación 00:30:24
número 2 sigue teniendo 7654 00:30:25
estupendo 00:30:28
en este caso el programa no ha hecho nada raro 00:30:29
podemos continuar contando con que todo va a ir bien 00:30:32
luego este es un casting 00:30:35
con criterio 00:30:37
con criterio 00:30:40
vale 00:30:41
pero vamos a repetir ahora mismo 00:30:42
un ejemplo pues sin criterio 00:30:45
vale 00:30:48
vamos a volver a darle a número 3 00:30:52
otro valor 00:30:54
pero ahora le voy a dar un valor 00:30:55
gordote 00:30:57
vale, o sea este valor no cabe en un entero 00:31:00
no cabe en un entero 00:31:03
Pero aquí no hay ningún problema 00:31:05
Yo le he dicho, guárdalo 00:31:07
Si yo le hubiera quitado el L 00:31:08
Recordad que aquí sí que me diría 00:31:10
Uy, que yo no puedo guardarte esto en 32 bits 00:31:12
Digo, no quiero que lo hagas 00:31:15
Tú guárdalo directamente en 64 00:31:16
Vale, directamente en 64 00:31:18
Y ahora llévalo a número 3 que es 64 00:31:20
Nada, todo estupendo 00:31:23
Ahora, vamos a volver a hacer lo mismo 00:31:24
Vamos a tratar de llevar número 3 a número 2 00:31:26
Él me va a decir 00:31:29
No puedo, número 3 es long 00:31:30
No puedo guardarlo en número 2, no puedo 00:31:32
vale, vamos a hacerle el casting 00:31:34
para saltarnos este problema 00:31:36
no pasa nada, conviérteme el valor 00:31:38
que haya en número 3, sea el que sea 00:31:41
conviértemelo entero 00:31:42
el, paz, mete la tijera 00:31:44
le quita los bits que hagan falta 00:31:47
lo deja en 32 y lo lleva entero 00:31:49
pero en este caso la ha liado 00:31:51
porque obviamente ha perdido 00:31:53
el número original 00:31:55
porque es que es imposible que este número quepa en 32 bits 00:31:56
vale, si vamos a ejecutar esto 00:31:59
¿Vale? Si vamos a ejecutarlo 00:32:02
Este era el número original 00:32:07
Y después de hacer esta asignación 00:32:09
Este número ya ha perdido todo el sentido 00:32:13
Lo ha perdido 00:32:15
A partir de aquí el programa ya no tiene ningún sentido 00:32:16
Porque esta asignación 00:32:19
¿Vale? 00:32:22
Bueno, conclusión 00:32:24
Hay que entender que es un casting 00:32:26
Con esto que estamos hablando 00:32:28
De asignación con compatibilidad de tipos 00:32:30
que un casting te permite 00:32:34
que este tipo de datos no es del mismo valor que otro 00:32:35
no pasa nada 00:32:38
pongo entre paréntesis el tipo al que quiero llegar 00:32:39
y Java te lo convierte 00:32:41
pero te lo convierte 00:32:43
en muchos casos perdiendo información 00:32:45
y destrozándote 00:32:48
a partir de ahí el programa 00:32:50
entonces 00:32:51
en este caso 00:32:53
perdemos información 00:32:56
¿vale? en este caso 00:33:00
pues cuidado con los castings 00:33:01
porque 00:33:10
los castings son tan cómodos que son 00:33:10
el recurso ideal del compilador 00:33:19
yo ya os he dicho que cuando 00:33:22
el compilador vuelve de compilación 00:33:24
te lo pone en rojo 00:33:25
y no solo te dice 00:33:26
que no le gusta, sino que encima te da sugerencias 00:33:29
¿vale? 00:33:32
por ejemplo en este caso 00:33:33
que hemos visto en este caso 00:33:34
el compilador de compilación, ¿está claro? 00:33:39
entonces si yo 00:33:41
le pido ayuda al compilador 00:33:42
le pido ayuda 00:33:47
y se la pido poniendo aquí 00:33:48
él la ayuda que me dice es 00:33:51
no puedo 00:33:53
los tipos no encajan 00:33:55
no puedo convertir de lonja entero 00:33:57
él me da la información 00:33:59
si luego además hago clic 00:34:00
ahora deposito la mano sin más 00:34:03
si luego además hago clic 00:34:05
él 00:34:07
me ofrece cosas 00:34:09
que arregla el orden de compilación 00:34:11
me las ofrece 00:34:13
y yo si pincho 00:34:13
él automáticamente me hace el cambio 00:34:17
me las ofrece, por ejemplo 00:34:19
aquí me ha ofrecido añadir un cast a end 00:34:21
entonces yo pincho, hago doble clic 00:34:23
y me lo hace 00:34:25
a ver 00:34:27
¿qué quiero decir con esto? 00:34:29
que lo de 00:34:32
pon un casting, pon un casting es 00:34:33
la solución para todo 00:34:35
del eclipse, que esto 00:34:36
hay una red de compilación, haz un casting 00:34:39
claro, con un casting se acaba todo 00:34:41
todos los problemas, todos se han acabado 00:34:43
pero el programa casi seguro 00:34:45
ha dejado de tener todo el sentido del mundo 00:34:47
entonces, este es un ejemplo en el cual 00:34:50
no hay que recurrir a las soluciones que da el Eclipse 00:34:54
claro, las que te da te quitan el error de compilación 00:34:59
pero te han cambiado el programa y te lo han destrozado 00:35:03
en prácticamente la mayoría de los casos 00:35:07
entonces, solo usemos las posibles soluciones que te sugiere 00:35:09
el entorno de desarrollo cuando tengamos 00:35:15
clarísimo que es la que nosotros queremos 00:35:18
porque si no nos vale para nada 00:35:19
no nos vale para nada quitar errores de compilación 00:35:22
lo digo porque os encanta 00:35:24
en general, generalizando 00:35:26
me daba un error pero dice así 00:35:28
y se quitó 00:35:30
si el error de compilación se quitó 00:35:30
pero se acabó, no sigas programando 00:35:33
porque lo que haces ya no tiene ningún sentido 00:35:35
programar no es quitar errores de compilación 00:35:37
no es eso, es hacer códigos 00:35:39
que cumplan su función 00:35:42
cuando se están ejecutando 00:35:43
que hagan lo que tienen que hacer 00:35:45
eso es programar, hacer un software 00:35:46
que hace lo que me han pedido cuando se está ejecutando 00:35:48
no que compila 00:35:51
un software que compila es muy fácil de hacer 00:35:53
que luego cumpla su función 00:35:55
eso ya no es tan fácil 00:35:57
¿vale? 00:35:58
bueno, pues en este caso 00:36:02
este casting 00:36:03
a lo mejor si nos puede 00:36:06
interesar, hay un caso en el cual 00:36:07
a mí me lo han pasado en loan, yo he verificado 00:36:09
que nunca se va a pasar de cierto valor 00:36:11
en este caso me puede interesar, hay casos en los que me puede interesar 00:36:13
pero si me interesa 00:36:15
yo tengo que saberlo y hacerlo 00:36:16
y hay veces que no me queda más remedio que hacer un casting para seguir 00:36:18
pues si no me queda más remedio que hacer un casting 00:36:21
lo hago, pero con cuidado 00:36:23
bueno, pues en cuanto a enteros 00:36:24
estos son los matices 00:36:28
de los que hablamos 00:36:29
más o menos está todo recogido en estas situaciones 00:36:30
que hemos especificado 00:36:33
está todo recogido, sí, dime 00:36:35
este proyecto entero 00:36:36
con todos los ejemplos, lo voy a subir a la aula virtual 00:36:44
¿vale? lo voy a subir a aula virtual 00:36:45
sí, por eso estoy 00:36:47
comentándolo todo lo que puedo 00:36:51
para subirlo todo a la aula virtual 00:36:53
vale, bueno pues en cuanto a enteros 00:36:54
práctica de todos los matices que hay 00:37:00
vienen por aquí 00:37:01
no hay duda, ¿no? 00:37:02
y los decimales es un poquito parecido 00:37:06
con los decimales es un poco parecido 00:37:08
¿vale? vamos a 00:37:10
pasar a los decimales 00:37:12
¿vale? 00:37:14
voy a poner aquí 00:37:18
voy a comentarlo como 00:37:23
ejemplos 00:37:27
con enteros 00:37:34
vale 00:37:35
vale, vámonos ahora 00:37:37
después de todo este chorizo de aquí 00:37:45
vámonos a ejemplos 00:37:47
con decimales 00:37:53
yo sé que ahora al principio es un rollo 00:37:54
y hablo mucho 00:38:05
pero es que de verdad 00:38:06
al principio no queda más remedio 00:38:09
ya vosotros tendréis ya tiempo de trabajar 00:38:10
Y hacer cosas dentro de no mucho 00:38:12
Pero ahora mismo 00:38:16
Vale 00:38:17
Variables para guardar tipos decimales 00:38:20
Vimos dos, float y double 00:38:25
Double permiten más cifras decimales 00:38:26
Que el float, ¿vale? 00:38:29
Porque una es 64 y otra es 128 00:38:30
Juraría, una es 64 y otra es 128 00:38:31
Creo que es una 64 y otra es 128 00:38:34
Vamos a comprobarlo rápidamente 00:38:36
Vamos a 00:38:39
Porque me lío con los int 00:38:40
A ver, longitud, dato, floa, a ver si es 32 o 64, exponente y mantisa, 32, vale, pues entonces es 64 dabel y 32 floa, vale, vale, la única diferencia es la precisión en las cifras decimales que dejan, ¿no? 00:38:43
entonces, bueno, una cosa que no he dicho 00:39:18
que no he dicho, que he dado por 00:39:21
supuesta, pero no debería 00:39:23
cuando uno declara 00:39:25
una variable, la declaración de variable 00:39:27
se puede hacer en cualquier punto del programa 00:39:29
no hace falta que se haga en el principio 00:39:30
uno puede declarar una variable cuando dé la gana 00:39:32
que aquí de repente me interesa a mí 00:39:34
bueno, de hecho ya lo hemos hecho aquí, ¿verdad? 00:39:36
aquí hemos 00:39:40
declarado 00:39:41
una variable long aquí en medio, por las buenas 00:39:41
¿vale? no hay ningún problema 00:39:45
En C y en lenguajes, los primeros lenguajes estructurados, pues por organización te decían que declaras las variables al principio, pero no, las puedes declarar cuando quieras, ¿vale? Cuando quieras. 00:39:46
Bueno, pues en cuanto a variables, decimales y float 00:40:02
Double y float 00:40:05
Pues lo mismo, yo puedo tener aquí una variable double 00:40:09
Decimal 1 00:40:13
Y una variable float 00:40:16
Decimal 2 00:40:20
Bueno, pues esto tiene pocos matices 00:40:22
Es que es lo mismo, equivalente a los números int y long 00:40:27
Que son los que más se usan 00:40:33
Equivalente 00:40:36
Que yo le quiero asignar un valor a decimal 1 00:40:36
Dabel 00:40:41
Pues recordad 00:40:42
Que la coma decimal 00:40:44
Es el punto 00:40:46
¿Vale? 00:40:50
Que la coma decimal es el punto 00:40:52
Que yo le quiero asignar un valor a decimal 2 00:40:54
¿Vale? 00:41:01
decimal 2 00:41:06
es un número decimal 00:41:08
también en principio tendría una coma 00:41:09
pero, ¿qué ocurre? 00:41:12
que aquí 00:41:15
ocurre lo contrario 00:41:16
que con los enteros y long 00:41:19
con los enteros y long 00:41:21
si tú le dabas un número 00:41:22
él por defecto te lo guarda en 32 bits 00:41:23
por defecto 00:41:27
y si tú quieres que te lo guarde en 64 00:41:28
le tienes que poner una L 00:41:29
aquí es justo al revés 00:41:30
si tú no le dices nada 00:41:33
él por defecto te lo guarda en double 00:41:35
es decir, en 64 00:41:38
en double 00:41:40
entonces, si yo guardo en decimal 1 00:41:40
no hay ningún problema 00:41:44
me lo está guardando en un double, cabe 00:41:46
pero si guardo en decimal 2, que es un float 00:41:48
me dice, oye, que ese 65,6 00:41:50
que me has dado 00:41:52
aunque me cabría en 32, porque la precisión 00:41:53
decimal es muy pequeña, aunque me cabría 00:41:56
como no me has dicho nada, te lo guardo en 64 00:41:58
y ahora ya de 64 00:42:00
a float no puedo 00:42:02
bueno, pues si le ponemos una F 00:42:03
alteramos ese funcionamiento 00:42:06
en este caso le ponemos una F de float 00:42:07
vale 00:42:10
si le ponemos una F 00:42:11
estamos diciendo, oye 00:42:14
este 65,6 00:42:15
por favor, guárdalo ya de partida 00:42:17
32 bits 00:42:20
y ahora ya a decimal 2 00:42:21
puede ir sin ningún problema, porque decimal 2 es float 00:42:24
y lo que es más, también podría ir a decimal 1 00:42:26
vale 00:42:30
porque decimal 1 es dabel 00:42:32
pero 00:42:35
de float a dabel se puede 00:42:35
igual que de int a long se puede 00:42:38
porque eso se puede 00:42:40
hacer una promoción automática que se llama 00:42:43
porque de float a dabel no pierdo 00:42:45
precisión, el numerito no pierde información 00:42:47
de float a dabel puedo 00:42:49
pero al revés no 00:42:50
¿vale? al revés no 00:42:52
si yo 00:42:55
intento hacer esto 00:42:57
a decimal 2 que es dabel 00:42:58
guardarle decimal 1 00:43:03
perdón, a decimal 2 que es float 00:43:05
guardarle decimal 1 que es double 00:43:07
me dice que no puede 00:43:09
porque de double a float 00:43:11
tendría que hacer 00:43:13
podría perder información 00:43:14
no me deja 00:43:16
que yo quiero aún así guardarlo 00:43:18
porque tengo esa restricción 00:43:21
y sé que 56,5 00:43:23
va a caber en float 00:43:25
porque la precisión es pequeña 00:43:26
es solo una cifra que quiero 00:43:28
no pasa nada, le hago un casting 00:43:29
le hago un casting a float 00:43:32
y ala, el compilador se calla 00:43:34
en este caso 00:43:36
ese casting no habrá dado pérdida de información 00:43:38
porque 56.5 00:43:41
cabe en float 00:43:42
que es un número de pocas cifras decimales 00:43:44
cabe en float 00:43:47
en este caso no 00:43:49
pero si fuera un numerito que no cabe en float 00:43:50
al hacer el casting 00:43:52
se perdería 00:43:56
pues esto es lo mismo 00:43:57
estoy repitiendo lo mismo que con indilo 00:44:00
Lo mismo, pero con float y dabel. 00:44:02
Dabel más preciso, 64, y float menos con 32. 00:44:03
Lo mismo. 00:44:07
Que de partida, cuando Java ve un número decimal, 00:44:08
de partida lo interpreta como dabel, lo guarda en 64. 00:44:14
Si yo le pongo el F, entonces ya no. 00:44:17
Lo guarda en 32. 00:44:20
Lo mismo. 00:44:22
¿Vale? 00:44:25
Podemos ver, y ya con esto paramos. 00:44:26
por curiosidad 00:44:28
vamos a ver cuáles son 00:44:31
igual que aquí, los máximos y mínimos 00:44:33
números, esas variables famosas 00:44:35
por ejemplo 00:44:37
vamos a ver el máximo 00:44:54
y mínimo número double 00:44:56
y el máximo y mínimo número float 00:44:57
vale, vamos a mostrarlos 00:45:00
para ver que son números con una cantidad 00:45:15
de cifras decimales distinta 00:45:17
si lo ejecutamos 00:45:18
vale, pues primero 00:45:21
he puesto el double y luego el float 00:45:25
¿verdad? tiene esto el dabel y luego el floa 00:45:27
entonces 00:45:29
este es el exponente 00:45:30
o sea, el máximo número dabel 00:45:39
es este, como veis 00:45:42
con muchas cifras decimales 00:45:44
por 10 elevado 00:45:45
a 308 00:45:48
o sea, es la anotación exponencial de toda la vida 00:45:49
como la gran mayoría venís 00:45:56
de bachillerato de ciencias, pues no son nada raros 00:45:58
o sea, este es un número 00:46:00
la leche, de grandote 00:46:01
¿vale? es muy grandote 00:46:04
y como veis con una precisión decimal 00:46:05
bastante más grande que la precisión decimal 00:46:09
que me da el float 00:46:11
o sea cuando queráis precisiones decimales 00:46:12
de más de 00:46:16
4, 5, 6 cifras decimales 00:46:17
usar un double 00:46:19
cuando la precisión decimal nunca vais a pasar 00:46:21
de 2 o 3 00:46:23
cifras decimales podéis usar un float 00:46:24
tranquilamente 00:46:27
bueno, pues no tiene mayor 00:46:28
historia esto 00:46:36
vale, vamos a parar aquí un momentito 00:46:37
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
10
Fecha:
25 de septiembre de 2023 - 13:32
Visibilidad:
Público
Centro:
IES ROSA CHACEL
Duración:
46′ 41″
Relación de aspecto:
1.78:1
Resolución:
1280x720 píxeles
Tamaño:
890.97 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid